text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Kotlin DSL, Fixtures и элегантные UI тесты в Android
Когда познакомился с Kotlin DSL, подумал: отличная штука, жалко в продуктовой разработке она не пригодится. Однако, я был неправ: он нам помог сделать очень лаконичный и элегантный способ написания End-to-end UI тестов в Android.
Про сервис, тестовые данные и почему все не так просто
======================================================
Для начала немного контекста про наш сервис, чтобы вам было понятно, почему мы приняли те или иные решения.
Мы помогаем соискателям и работодателям найти друг друга:
* работодатели регистрируют свои компании и размещают вакансии
* соискатели ищут вакансии, добавляют их в избранное, подписываются на результаты поиска, создают резюме и отправляют отклики
Для того чтобы имитировать реальные пользовательские сценарии и убедиться, что на них приложение работает корректно, нам нужно создать на сервере все эти тестовые данные. Вы скажете: “Так создайте тестовых работодателей и соискателей заранее, а потом в тестах уже с ними и работайте”. Но тут есть пара проблем:
1. во время тестов мы меняем данные;
2. тесты запускаются параллельно.
Тестовое окружение и фикстуры
=============================
End-to-end тесты запускаются на тестовых стендах. На них практически боевое окружение, но отсутствуют реальные данные. В связи с этим при добавлении новых данных индексация происходит почти моментально.
Чтобы добавить на стенд данные, мы используем специальные методы фикстуры. Они добавляют данные прямиком в базу данных и моментально проводят индексацию:
```
interface TestFixtureUserApi {
@POST("fx/employer/create")
fun createEmployerUser(@Body employer: TestEmployer): Call
}
```
Фикстуры доступны только из локальной сети и только для тестовых стендов. Методы вызываются из теста непосредственно перед запуском стартового Activity.
DSL
===
Вот мы и дошли до самого сочного. Как же задаются данные для теста?
```
initialisation{
applicant {
resume {
title = "Resume for similar Vacancy"
isOptional = true
resumeStatus = ResumeStatus.APPROVED
}
resume {
title = "Some other Resume"
}
}
employer {
vacancy {
title = "Resume for similar Vacancy"
}
vacancy {
title = "Resume for similar Vacancy"
description = "Working hard"
}
vacancy {
title = "Resume for similar Vacancy"
description = "Working very hard"
}
}
}
```
В блоке initialisation мы заводим необходимые для теста сущности: в примере выше мы создали одного соискателя с двумя резюме, а также одного работодателя, который предоставил несколько вакансий.
Чтобы исключить ошибки, связанные с пересечением тестовых данных, мы генерируем уникальный идентификатор для теста и для каждой сущности.
**Связи между сущностями**
В чем основное ограничение при работе с DSL? Из-за его древовидности довольно сложно построить связи между различными ветками дерева.
К примеру, в нашем приложении для соискателей есть раздел “Подходящие вакансии для резюме”. Чтобы в этом списке появились вакансии, нам нужно задать их таким образом, чтобы они были связаны с резюме текущего пользователя.
```
initialisation {
applicant {
resume {
title = "TEST_VACANCY_$uniqueTestId"
}
}
employer {
vacancy {
title = "TEST_VACANCY_$uniqueTestId"
}
}
}
```
Для этого используется уникальный идентификатор теста. Таким образом, при работе с приложением заданные вакансии рекомендуются для данного резюме. Кроме того, важно отметить, что никакие другие вакансии в этом списке не появятся.
**Инициализация однотипных данных**
А что если нужно сделать много вакансий? Это каждый блок так копировать? Разумеется нет! Делаем метод с блоком вакансий, в котором указывается необходимое число вакансий и трансформер, чтобы разнообразить их в зависимости от уникального идентификатора.
```
initialisation {
employer {
vacancyBlock {
size = 10
transformer = {
it.also { vacancyDsl ->
vacancyDsl.description = "Some description with text ${vacancyDsl.uniqueVacancyId}"
}
}
}
}
}
```
В блоке vacancyBlock мы указываем, сколько клонов вакансий нам нужно создать и как трансформировать их в зависимости от порядкового номера.
**Работа с данными в тесте**
Во время выполнения теста работа с данными становится очень простой. Нам доступны все созданные нами данные. В нашей реализации они хранятся в специальных обертках для коллекций. Из них можно получить данные как по порядковому номеру задания ( vacancies[0]), так по тэгу, который можно задать в dsl (vacancies[“my vacancy”]), и по шорткатам (vacancies.first()
**TaggedItemContainer**
```
class TaggedItemContainer(
private val items: MutableList>
) {
operator fun get(index: Int): T {
return items[index].data
}
operator fun get(tag: String): T {
return items.first { it.tag == tag }.data
}
operator fun plusAssign(item: TaggedItem) {
items += item
}
fun forEach(action: (T) -> Unit) {
for (item in items) action.invoke(item.data)
}
fun first(): T {
return items[0].data
}
fun second(): T {
return items[1].data
}
fun third(): T {
return items[2].data
}
fun last(): T {
return items[items.size - 1].data
}
}
```
Практически в 100% случаях при написании тестов мы используем методы first() и second(), остальные держим для гибкости. Ниже привел пример теста с инициализацией и с шагами на [Kakao](https://github.com/agoda-com/Kakao)
```
initialisation {
applicant {
resume {
title = "TEST_VACANCY_$uniqueTestId"
}
}
}.run {
mainScreen {
positionField {
click()
}
jobPositionScreen {
positionEntry(vacancies.first().title)
}
searchButton {
click()
}
}
}
```
**Что не помещается в DSL**
Все ли данные можно уместить в DSL? Мы преследовали цель оставить DSL максимально лаконичным и простым. В нашей реализации из-за того, что порядок задания соискателей и работодателей не важен, не получается уместить их взаимосвязь — отклики.
Создание откликов уже выполняется в последующем блоке операциями над уже созданными на сервере сущностями.
Реализация DSL
==============
Как вы поняли из статьи, алгоритм задания тестовых данных и выполнения теста следующий:
* Парсится часть DSL в initialisation;
* По полученным значениям создаются тестовые данные на сервере;
* Выполняется опциональный блок transformation, в котором можно задать отклики;
* Выполняется тест с уже итоговым набором данных.
**Разбор данных из блока initialisation**
Что там за магия происходит? Рассмотрим, как конструируется верхнеуровневый элемент TestCaseDsl:
```
@TestCaseDslMarker
class TestCaseDsl {
val applicants = mutableListOf()
val employers = mutableListOf()
val uniqueTestId = CommonUtils.unique
fun applicant(block: ApplicantDsl.() -> Unit = {}) {
val applicantDsl = ApplicantDsl(
uniqueTestId,
uniqueApplicantId = CommonUtils.unique
applicantDsl.block()
applicants += applicantDsl
}
fun employer(block: EmployerDsl.() -> Unit = {}) {
val employerDsl = EmployerDsl(
uniqueTestId = uniqueTestId,
uniqueEmployerId = CommonUtils.unique
employerDsl.block()
employers += employerDsl
}
}
```
В методе applicant мы создаем ApplicantDsl.
**ApplicantDsl**
```
@TestCaseDslMarker
class ApplicantDsl(
val uniqueTestId: String,
val uniqueApplicantId: String,
var tag: String? = null,
var login: String? = null,
var password: String? = null,
var firstName: String? = null,
var middleName: String? = null,
var lastName: String? = null,
var email: String? = null,
var siteId: Int? = null,
var areaId: Int? = null,
var resumeViewLimit: Int? = null,
var isMailingSubscription: Boolean? = null
) {
val resumes = mutableListOf()
fun resume(block: ResumeDsl.() -> Unit = {}) {
val resumeDslBuilder = ResumeDsl(
uniqueTestId = uniqueTestId,
uniqueApplicantId = uniqueApplicantId,
uniqueResumeId = CommonUtils.unique
)
resumeDslBuilder.apply(block)
this.resumes += resumeDslBuilder
}
}
```
Затем мы выполняем над ним операции из блока block: ApplicantDsl.() -> Unit. Именно эта конструкция позволяет нам легко оперировать с полями ApplicantDsl в нашей DSL.
Обратите внимание, что uniqueTestId и uniqueApplicantId (уникальные идентификаторы для связи сущностей между собой) на момент выполнения блока уже заданные и мы можем к ним обращаться.
Блок initialisation изнутри устроен похожим образом:
```
fun initialisation(block: TestCaseDsl.() -> Unit): Initialisation {
val testCaseDsl = TestCaseDsl().apply(block)
val testCase = TestCaseCreator.create(testCaseDsl)
return Initialisation(testCase)
}
```
Мы создаем тест, применяем к нему действия блока, далее при помощи TestCaseCreator создаем данные на сервере и укладываем их в коллекции. Функция TestCaseCreator.create() устроена довольно просто — мы перебираем данные и создаем их на сервере.
Подводные камни и идеи
======================
> Некоторые тесты очень похожи и различаются только входящими данными и способами контроля их отображений (к примеру, когда в вакансии указана разная валюта).
В нашем случае, таких тестов оказалось немного, и мы решили не загромождать DSL специальным синтаксисом
> Во времена до DSL у нас долго происходила индексация данных, и мы для экономии времени делали в одном классе много тестов и создавали все данные в статическом блоке.
Не делайте так — это сделает для вас невозможным перезапуск упавшего теста. Дело в том, что во время запуска упавшего теста мы могли поменять исходные данные на сервере. К примеру, мы могли добавить вакансию в избранное. Тогда при перезапуске теста нажатие на звездочку приведёт уже наоборот к удалению вакансии из списка избранного, а это уже поведение, которые мы не ожидаем.
Итоги
=====
Такой способ задания тестовых данных очень упростил работу с тестами:
При написании тестов не нужно думать о том, есть ли сервер и в каком порядке нужно инициализировать данные;
Все сущности, которые можно задать на сервере, легко выпадают в подсказках IDE;
Появился единый способ инициализации и связи данных между собой.
**Материалы по теме**
Если Вас заинтересовал наш подход к UI-тестированию, то перед тем как начать, предлагаю ознакомиться со следующими материалами:
* [Type-Safe Builders](https://kotlinlang.org/docs/reference/type-safe-builders.html) — официальная документация на сайте kotlinlang.org;
* [Kotlin DSL: Теория и Практика](https://habr.com/ru/company/jugru/blog/416725/) — отличные доклад c jPoint 2018 про kotlin dsl и его расшифровка;
* [Kakao — how to make UI testing great again](https://proandroiddev.com/kakao-how-to-make-ui-testing-great-again-19972cf13740) — базовые знания про фреймворк Kakao для UI тестов;
* [Как перестать бояться и начать писать UI-тесты вместе с Kakao](https://appsconf.ru/moscow/2019/abstracts/4621) — доклад про Kakao с AppsConf 2019. Доступны пока только слайды, потом будет видео.
**Что дальше**
Данная статья является первой из серии про инструменты и высокоуровневые фреймворки для написания и поддержки UI тестов в Android. По мере выхода новых частей я буду их прилинковывать к данной статье. | https://habr.com/ru/post/455042/ | null | ru | null |
# Еще один фреймворк…
Основная концепция работыВчера я зарелизил свой первый Python фреймворк. Нет, не еще один. Это в мире - еще один. А для меня пока что первый. И я допускаю, что он первый в своем роде. Это фреймворк для создания кастомных серверов. И создаваться они будут через конфиг. Ух, насоздаем сейчас...
---
Вначале был конфиг
------------------
Итак, конфиг. Поскольку к этому моменту фреймворк мы уже установили. А если нет, то это легко и просто делается командой:
```
pip3 install idewavecore==0.0.1
```
Это при условии наличия у вас Python 3.6+, ~~интернета и компьютера~~.
Сам конфиг при этом выглядит примерно вот так:
```
# settings.yml
settings:
servers: !inject config_dir/servers.yml
db_connections:
sqlite:
host: ~
username: ~
password: ~
# default mysql 3306, postgresql 5432, sqlite don't need port
port: ~
# currently allowed: mysql, postgresql, sqlite
dialect: sqlite
# supported drivers:
# mysql: mysqlconnector, pymysql, pyodbc
# postgresql: psycopg2, pg8000, pygresql
driver: ~
# to use with sqlite this should be absolute db path
# can be empty to keep db in memory (sqlite only)
db_name: ~
charset: ~
```
Где `!inject` - это специальный тэг для импорта других yaml файлов. Что очень удобно, если нужно разбить огромную yaml-простыню на набор аккуратных мини-конфигов.
```
# servers.yml
sample_server:
connection:
host: 1.2.3.4
port: 1234
# possible values: tcp, websocket
connection_type: tcp
# optional
proxy:
host: ~
port: ~
# possible values: tcp, websocket
connection_type: tcp
options:
server_name: Sample Server
is_debug: false
middlewares: !pipe
- !fn native.test.mock_middleware
- !fn native.test.mock_middleware
- !infinite_loop
- !fn native.test.mock_middleware
- !fn native.test.mock_middleware
- !fn native.test.mock_middleware
- !router
ROUTE_1: !fn native.test.mock_middleware
ROUTE_2: !fn native.test.mock_middleware
ROUTE_3:
- !fn native.test.mock_middleware
- !fn native.test.mock_middleware
- !fn native.test.mock_middleware
# optional
db_connection: sqlite
```
Здесь уже побольше тэгов.
`!pipe` - это специальный тэг, который создает обертку над функциями в массиве. На данный момент все функции, используемые в разделе middlewares (о них - чуть ниже), должны быть обернуты в пайп. Вкратце - пайп выполняет поочередно переданные в него функции и пробрасывает в них необходимые параметры.
`!infinite_loop` - это специальный тэг, который автоматически создает пайп из переданных функций и затем выполняет их внутри вечного цикла. Что может быть полезно для создания непрерывного соединения (например, по websocket).
`!router` - это специальный тэг, который создает маршрутизируемый пайп. Фактически, создается словарь пайпов и какой из них выполнить, роутер определяет по специальному параметру (route).
И, наконец, `!fn` - специальный тэг, который позволяет импортировать функцию (далее - middleware) по указанному пути. Мой фреймворк предоставляет некоторое количество миддлвэров, но можно написать свои - достаточно создать в корне своего проекта одноименную папку - middlewares - и далее создать там файлы с необходимыми функциями. Далее, чтобы использовать вашу функцию, достаточно будет вызвать тэг:
`!fn <имя_вашего_файла>.<имя_функции>`
И строка будет преобразована в миддлвэр. Название корневой папки (middlewares) указывать не нужно - оно будет подставлено автоматически при импорте. Если же вы хотите использовать нативные миддлвэры фреймворка (есть! я использовал **три** заимствованных слова подряд!), достаточно указать префикс `native` в пути к функции, например:
`!fn native.test.mock_middleware`
В целом, большой акцент сделан именно на работу с конфигом.
Middle where
------------
Миддлвэры - это место, где будет сосредоточена вся кастомизируемая логика вашего приложения. Фактически, это - центр. Сердце каждого отдельно созданного сервера.
В общих чертах, миддлвэр - это асинхронная функция, имеющая доступ ко всем хранилищам (о них - ниже). Каждая такая функция должна выглядеть примерно вот так:
```
from idewavecore.session import Storage, ItemFlag
async def sample_middleware(**kwargs):
global_storage: Storage = kwargs.pop('global_storage')
server_storage: Storage = kwargs.pop('server_storage')
session_storage: Storage = kwargs.pop('session_storage')
session_storage.set_items([
{
'key1': {
'value': 'some_tmp_value'
}
},
{
'key2': {
'value': 'some_persistent_value',
'flags': ItemFlag.PERSISTENT
}
},
{
'key3': {
'value': 'some_persistent_constant_value',
'flags': ItemFlag.PERSISTENT | ItemFlag.FROZEN
}
},
{
'key4': {
'value': 'some_constant_value',
'flags': ItemFlag.FROZEN
}
}
])
value_of_key3 = session_storage.get_value('key3')
```
Каждый миддлвэр имеет доступ к одному из трех типов хранилищ (storage). Хранилища бывают трех типов: **глобальное** (global storage), **хранилище сервера** (server storage) и **хранилище сессии** (session storage).
**Глобальное хранилище** связывает все части приложения между собой, позволяя серверам получить доступ к общим данным.
**Хранилище сервера** используется для хранения соединений и в основном используется для броадкаста.
**Хранилище сессий** создается персонально для каждого клиентского соединения и хранит данные в пределах этого соединения.
В основном в миддлвэрах будет использоваться именно **хранилище сессии**.
(После третьего раза я понял, что больше не могу так. Простите за такой топорный перевод термина. Я не придумал, как по-другому. Предлагайте свои варианты в комментариях - возможно, эту ситуацию еще не поздно исправить.)
Запускаем...
------------
Теперь наконец пора применить то, без чего не обходится ни одно нормальное приложение на базе моего фреймворка - Assembler. Не совсем [тот](https://en.wikipedia.org/wiki/Assembly_language#Assembler), но тоже производит сборку. Примерно так:
```
# run.py
import asyncio
from idewavecore import Assembler
from idewavecore.session import Storage
if __name__ == '__main__':
loop = asyncio.get_event_loop()
global_storage = Storage()
assembler = Assembler(
global_storage=global_storage,
# ваш путь к конфигу
config_path='settings.yml'
)
servers = assembler.assemble()
for server in servers:
server.start()
loop.run_until_complete(
asyncio.gather(*[server.get() for server in servers])
)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
loop.close()
```
Запускаем в терминале - и можем лицезреть (при условии, что вы все сделали правильно) сообщения о том, что серверы запущены. Теперь к ним можно пробовать достучаться всеми возможными способами - браузер, curl, клиент mmo rpg игры...
Что теперь
----------
А теперь я хочу сказать спасибо всем, кто прочитал мой пост до конца. Я буду благодарен за любые конструктивные замечания. Даже если мой фреймворк - не первый в своем роде, я хочу его максимально приблизить к этой планке.
[**Присоединяйтесь**](https://github.com/idewave/idewavecore). | https://habr.com/ru/post/543570/ | null | ru | null |
# GUID-подобные первичные ключи в SQLite на Android
Интро
-----
Каждая таблица в SQLite по умолчанию содержит приватный ключ на основе автоматически генерируемого 64-битного целого. Это эффективно и удобно в большинстве ситуаций. Неудобства начинаются, пожалуй, только в двух случаях:
* когда диапазона 64 бит не хватает (тогда стоит задуматься о целесообразности SQLite задаче)
* когда хранилище становится "распределенным"
Может показаться, что и второй задачи в комбинации с SQLite не должно возникать, но распределенность не всегда означает что-нибудь вроде BigData. Типичный пример (из-за чего лично мне и понадобилось исследование на эту тему) это приложение с возможностью синхронизации данных между устройствами. Это может быть как что-то небольшое, как записная книжка, так и более нагруженное, как история браузера. Проблемой тут становится не столько объем данных, сколько слияние нескольких баз. Очевидно, что целочисленные счетчики записей, начинающие отсчет с 1, неизбежно будут выдавать конфликтующие последовательности, а значит использовать их в качестве уникального идентификатора записи на нескольких устройствах уже нельзя. Можно заморочиться с разделением на поддиапазоны или "сдвиганием" айдишников записей перед их передачей, но это все кривые и хрупкие костыли. Никто так не делает, конечно же. Вместо этого каждое устройство присваивает своим записям что-нибудь вроде GUID-а – просто и надежно.
GUID в качестве первичного ключа
--------------------------------
GUID это случайное "число", длиной в 128 бит. То есть в БД это будет 16 байт в виде BLOB-а, либо минимум 32 байта в виде строки. Определенный оверхед (особенно, если остальные столбцы небольшие) по сравнению с дефолтным ключом, который хранится очень эффективно: обычно там не 8 байт, а столько, сколько требует для представления значение ключа. Этот оверхед ради решения задачи мы готовы платить, но не хотим усугублять – поэтому конечно же предпочитаем хранение в бинарном виде, а не текстовой строкой.
Что ж, объявить столбец с блобом несложно, сделаем примитивную табличку:
```
CREATE TABLE records (id BLOB PRIMARY KEY, data CHARACTER);
```
Можно еще добавить `WITHOUT ROWID` в качестве спецификатора таблицы для оптимизации – чтобы SQLite не добавляла и не поддерживала неявный ключевой столбец.
Тему можно было бы закрывать, если бы не желание заставить БД самостоятельно генерировать айдишники, так же, как в случае с дефолтным целочисленным ключом. Что ж, если нет принципиального требования иметь *настоящие* GUID (которые не совсем просто рандомное число, а имеют несколько предопределенных бит), то это тоже легко:
```
CREATE TABLE records (id BLOB PRIMARY KEY DEFAULT (randomblob(16)), data CHARACTER);
```
На этом можно было бы вновь остановиться, если бы не перфекционизм. Забегая вперед, скажу, что даже с перфекционизмом тяжелой формы на этом и стоит остановиться, если вы не собираетесь вставлять в БД миллионы записей. А вот если может быть так, что собираетесь, то стоит обратить внимание, что длинное случайное число не очень хорошо подходит в качестве ключа по той причине, что его дороже индексировать: просто складывать записи одну за другой и надеяться на быстрый поиск уже не выйдет.
Проблема эта к счастью [давно и успешно решена](http://www.informit.com/articles/article.aspx?p=25862) и решение адаптировано [на многие БД](https://www.codeproject.com/Articles/388157/GUIDs-as-fast-primary-keys-under-multiple-database). Вкратце там все просто: первые 6 байт идентификатора заменяются на timestamp. В результате записи создаются сразу (частично) упорядоченными, что сильно облегчает их индексацию. Вероятность коллизий при этом увеличивается, но незначительно. И снова история закончилась бы ровно на этом месте, если бы в Android-ном API [SQLiteDatabase](https://developer.android.com/reference/android/database/SQLite/SQLiteDatabase.html) позволяла определять внешние функции, чтобы сгенерировать гуидоподобный BLOB. Можно конечно генерить их и в Java-коде и биндить ко всем запросам на вставку, но это неспортивно. Кроме того, могут быть другие причины не делать этого. Например необходимость держать "глобальные" идентификаторы отдельно от "локальных", генерируя их по мере необходимости при помощи триггера.
Ну хорошо, взять 6 байт от unix timestamp с грехом пополам [можно так](http://www.SQLite.org/lang_datefunc.html):
```
SELECT round((julianday('now') - 2440587.5) * 86400000) & 0xFFFFFFFFFFFF AS ts;
```
Результатом будет число. Например, такое: 1489877740453 – на момент написания статьи. Хорошие новости в том, что оно обычно будет неубывающим, и его можно считать средствами самой БД. Но дальше начинаются некоторые сложности. Дело в том, что в SQLite очень ограниченный набор функций для работы с BLOB: только обрезать (`substr()`) и склеить (`||`). И как заставить интерпретировать число в качестве строки байтов, непонятно. То есть можно конечно сделать `CAST(... AS BLOB)`, но это не то: [оно переведет число в строку](http://www.SQLite.org/lang_expr.html#castexpr), а потом возьмет байты полученной строки – то есть превратит 6 байт в 13. Даже если предварительно [отформатировать в шестнадцатиричное представление](http://www.SQLite.org/lang_corefunc.html#hex), будет много – 12. Не катит.
Преобразование числа в BLOB
---------------------------
… в SQLite невозможно – ответит вам google и stackoverflow. Так-то оно, конечно, правда, но если очень хочется, то вообще-то можно. В Интернете мне ничего найти не удалось, и пришлось изобрести самому. Сразу скажу: это будет грязно :)
Итак, у нас есть склейка (`||`), значит, имея две байтовые строки – timestamp и случайную часть – мы могли бы получить COMB Джимми Нельсона:
```
SELECT ts_bytes || randomblob(10);
```
Искомые `ts_bytes` это всего лишь строка из 6 байт, представляющая целое число. Давайте еще раз взглянем на него: `1489877740453`. Или `0x 01 5A E3 A2 2B A5`. Если бы могли взять по отдельности каждый байт в виде BLOB-а, и склеить их вместе – даже в ручном режиме это всего (и всегда) 6 склеек. Что ж, попробуем разделить число на байты. Их числовые значения можно получить при помощи небольшой арифметики:
* первый: `ts >> 40 == 1` (0x01)
* второй: `(ts >> 32) % 256 == 90` (0x5A)
* третий: `(ts >> 24) % 256 == 227` (0xE3)
* ...
Но, опять же, это пока не байты. Интерпретатор SQLite будет считать это просто числами:
```
SELECT typeof( (1489877740453 >> 24) % 256 );
integer
```
А нам нужен BLOB. BLOB из одного байта, представляющего полученное число. Явно мы это сделать не можем, но если бы у нас было что-то вроде таблицы – значений байта-то *всего 256 штук*. Тут мы вспоминаем о второй операции, доступной в SQLite и возвращающей байты – `substr`, которая по индексу возвращает подстроку букв **или байт**. Бинго! Захардкодим все значения байта в строку, где индексом само значение этого байт и будет. К счатью, можно записывать бинарный литерал при помощи синтаксиса вида x'DEADBEEF':
```
SELECT X'
000102030405060708090A0B0C0D0E0F
101112131415161718191A1B1C1D1E1F
202122232425262728292A2B2C2D2E2F
303132333435363738393A3B3C3D3E3F
404142434445464748494A4B4C4D4E4F
505152535455565758595A5B5C5D5E5F
606162636465666768696A6B6C6D6E6F
707172737475767778797A7B7C7D7E7F
808182838485868788898A8B8C8D8E8F
909192939495969798999A9B9C9D9E9F
A0A1A2A3A4A5A6A7A8A9AAABACADAEAF
B0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF
C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF
D0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF
E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF
F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF' as b;
```
Это слегка псевдокод, потому что переносить строки так нельзя, но так нагляднее, а в коде можно и в одну строку отформатировать. Зато теперь все, что осталось сделать, это "вырезать" нужный байт из таблицы и склеить с другими. Шесть раз:
```
SELECT
substr(b, (ts >> 40) + 1, 1) ||
substr(b, (ts >> 32) % 256 + 1, 1) ||
substr(b, (ts >> 24) % 256 + 1, 1) ||
substr(b, (ts >> 16) % 256 + 1, 1) ||
substr(b, (ts >> 8) % 256 + 1, 1) ||
substr(b, ts % 256 + 1, 1) ||
randomblob(10);
```
Псевдо-GUID в бинарной форме готов! На самом деле SQLite пока что будет считать получаенную строку байт "текстом", но `CAST(... AS BLOB)` сделает все, как надо. Вообще-то это даже обязательно, потому что иначе чтение из этого столбца будет возвращать не 16 байт, как ожидается, а 17 – с нулевым терминатором строки. Осталось подставить выражение в качестве значения столбца по умолчанию.
Автовставка идентификаторов
---------------------------
Просто запихнуть весь этот "поезд" внутрь `DEFAULT(...)` в определении столбца таблицы нельзя, потому что там должны быть только "простые" выражения, а нам нужны вложенные SELECT-ы, чтобы избежать копипасты и множественных вычислений одного и того же.
К счастью, в SQLite есть триггеры, с помощью которых можно модифицировать строки на лету при вставке. К сожалению, ни фаза `BEFORE INSERT`, ни `AFTER INSERT` не подходят для обслуживания `PRIMARY KEY`, т.к. для удовлетворения неявного условия `NOT NULL` значение столбца нужно обязательно указывать в изначальном запросе. К тому же, для таких триггеров UPDATE-выражение снова позволяет только примитивные выражения. Зато доступен тип триггеров `INSTEAD OF INSERT`, который как раз может создать новую запись на основе переданных значений с добавлением сгенерированного блоба. Есть с ним только одна особенность, не указанная в документации: триггер INSTEAD OF INSERT нельзя создать на таблицу. Можно только на VIEW.
В итоге схема выстраивается следующая:
* основная таблица явно используется только для чтения
* запросы на запись идут во VIEW-пустышку с триггером на вставку
* триггер генерирует BLOB и делает вставку в основную таблицу
```
CREATE TABLE records (id BLOB PRIMARY KEY, data CHARACTER) WITHOUT ROWID;
CREATE VIEW fake AS SELECT NULL as ts, NULL as data;
CREATE TRIGGER auto_guids INSTEAD OF INSERT ON fake BEGIN
INSERT INTO records(id, data) SELECT CAST(new_guid AS BLOB), NEW.data FROM (
SELECT
substr(b, (ts >> 40) + 1, 1) ||
substr(b, (ts >> 32) % 256 + 1, 1) ||
substr(b, (ts >> 24) % 256 + 1, 1) ||
substr(b, (ts >> 16) % 256 + 1, 1) ||
substr(b, (ts >> 8) % 256 + 1, 1) ||
substr(b, ts % 256 + 1, 1) ||
randomblob(10) AS new_guid FROM (SELECT
round((julianday('now') - 2440587.5) * 86400000) & 0xFFFFFFFFFFFF as ts,
x'000102030405060708090A0B0C0D0E0F...' as b
)
);
END;
```
Читаем как обычно:
```
SELECT * FROM records;
```
А записываем так:
```
INSERT INTO fake (data) VALUES ('Hello COMBs!');
```
Можно было положить таблицу байт в отдельную VIEW ради удобочитаемости, но это несколько негативно сказывается на производительности. Также можно было оставить первичный ключ на целоцисленном счетчике, сделать столбец `guid` просто уникальным и написать триггер `ON AFTER INSERT`, которы бы "передобавлял" строку с новым `guid`, но, забегая чуть вперед, скажу, что это медленнее примерно на 30%. Кстати, самое время посмотреть на производительность.
Производительность
------------------
Очевидно, что склейка байтов вручную медленнее встроенной функции `randomblob()`. Выигрыш должен появиться на большом количестве вставок. Проведем замеры. Сравнивать будем "обычный" целочисленный ROWID, ключ на основе `randomblob(16)` и наши частично упорядоченные блобы (COMBs, как их назвали в вышеупомянутой статье).
Тестовый сценарий таков:
* три транзакции вставок по миллиону записей
* случайная выборка всех вставленных записей по id
Время записи замеряется как для каждой серии, так и внутри через каждые 20% записей. Тесты запускались в эмуляторе Android 6.0 (SQLite 3.8.10). [Исходники тут](https://bitbucket.org/knuckles/sqlite-combs-test).
На графике: время вставки каждой последующей порции из 200 тысяч записей. Эталон производительности, понятное дело, дефолтный целочисленный индекс (синяя линия). Его скорость не зависит от количества последовательных вставок. Желтная линия (COMBs) это наш пациент. Его скорость также практически постоянна, хотя и ниже на 55-59%. А красная линия это таблица с первичным ключом на randomblob(16). Видно, что, начиная всего на 11% медленнее INTEGER PRIMARY KEY, где-то после первого миллиона вставок ее накладные расходы на поддержание индекса превышают частично упорядоченные последовательности и продолжают расти, достигая 75% замедления к концу 3го миллиона.
На самом деле COMB можно сделать еще быстрее. Текущая проблема заключается в том, что с миллисекундной точностью временных отметок соседние строки выстраиваются в кластеры по 18-20 штук, где первые 6 байт (таймстамп) – одинаковые, частично возвращая проблему упорядочивания случайных байт. Если к таймстампу каким-то образом прибавлять порядковый номер добавляемой записи (хотя бы внутри транзакции), это снизит оверхед до 29-34% по сравнению с "INT" и даст выигрыш по сравнению с `randomblob(16)` уже после 500 тысяч записей.
Недостаток в том, что в простейшем случае порядковый номер нужно передавать из управляющего кода, а этого делать не хочется по условиям задачи. Кроме того, уже и так можно сделать выводы.
Выводы
------
SQLite сама по себе очень неплохо управляется с индексированием даже чего-то GUID-о-подобного.
Если предполагаемый объем данных не превышает хотя бы 500 тысяч записей, чистый `randomblob()` обладает вполне приемлемой производительностью. Я в своем текущем проекте поэтому скорее всего его и выберу.
Даже если записей будет много, но вставляются они редко или, тем более, в виде единичных записей, тип первичного ключа не будет играть вообще никакой роли в производительности. Одна только фиксация транзакции (в Android с дефолтными настройками БД) занимает порядка 20-50 миллисекунд. И в разы больше, если система IO поднагружена. Вставка записи внутри массовой транзакции, которая происходит за микросекунды, по сравнению с этим занимает ничтожное время при любом раскладе.
В SQLite можно превращать числа в BLOB – было бы желание :) | https://habr.com/ru/post/323794/ | null | ru | null |
# Как компьютер сам свой код улучшал, или программируем процесс программирования
На носу было придумывание темы для диплома, на кафедре популярностью пользовались различные варианты идей связанных с генетическими алгоритмами, а мне самому хотелось сделать что-нибудь этакое. Так и родилась идея, давшая начало данному проекту, а именно генетическому оптимизатору программного кода.
Цель была довольно амбициозной — в идеале сделать такую штуку, которой на вход подается программа, а дальше она ее крутит так и сяк и пытается всячески ускорить отдельные ее фрагменты без участия человека, попутно собирая себе базу для последующих оптимизаций. Сразу скажу что хотя в целом задача была решена, практической пользы я из нее извлечь не смог. Однако некоторые полученные в процессе результаты показались мне достаточно интересными чтобы ими поделиться.
Например вот такая забавная оптимизация набора арифметических инструкций (взятых из какой-то подвернувшейся под руку математической библиотеки), соответствующих формулам: , которая на 6 джаве с выключенным JIT у меня давала около 10% ускорения, при этом на первый взгляд даже не очевидно что эти формулы эквивалентны (ОТКУДА ТУТ OR? ЭТО ВООБЩЕ ЗАКОННО?!), хотя это так. Под катом я расскажу, как именно получались такие результаты и каким образом компьютер придумывал лучший код чем тот, который мог написать я сам.
Заняться я решил не абы какой оптимизацией, а так называемой «локальной» или peephole optimization. Это как правило последний этап через который прогоняют программы современные оптимизирующие компиляторы, и по сути он очень прост — они ищут заданные небольшие линейные последовательности инструкций и меняют их на другие, оптимальные с их точки зрения. То есть вот какая-нибудь пресловутая замена *mov eax, 0* на *xor eax eax* — это вот как раз и есть локальная оптимизация. Самым интересным тут является то, каким именно образом эти правила замены строятся. Их могут составлять как вручную специально обученные и разбирающиеся в ассемблере люди, так и искать перебором наборов инструкций. Очевидно что первый вариант достаточно затратен (специально обученные люди наверняка захотят много денег) и малоэффективен (ну сколько таких наборов человек из головы сможет придумать и предусмотреть?), а второй — долог, особенно если пытаться перебирать длинные последовательности.
Вот тут на сцену и выходят генетические алгоритмы, позволяющие заметно сократить процесс перебора.
Про сами генетические алгоритмы я тут рассказывать не буду, надеюсь все хотя бы в общих чертах представляют что это такое, а кто не представляет — на хабре достаточно статей на эту тему, например [вот](http://habrahabr.ru/post/200454/). Остановлюсь только на том, как именно я их применял.
Достаточно очевидно, что особи в нашем случае — это фрагменты кода, операторы скрещивания и мутации должны каким-то образом модифицировать входящие в них инструкции, а фитнес-функция — отбирать наиболее быстрые варианты (так как оптимизировать мы будем именно скорость выполнения). Вот только как именно должно работать это самое скрещивание?
**Скрещивание и мутация фрагментов кода**
От идеи меняться произвольными фрагментами я отказался очень быстро. В этом случае очень велика вероятность получения невалидного кода — такого, который просто не получится запустить. В качестве своей целевой архитектуры я выбрал JVM (из-за простоты как самого байткода так и средств манипулирования им, хотя позже я уже понял что это было не самое удачное решение), а в ней достаточно строгий валидатор, который просто не даст загрузить кривой код (например вызывающий опустошение стека). Соответственно и значение фитнес-функции для него посчитать не выйдет.
Поэтому пришлось соорудить достаточно сложную систему, практически этакий мини-эмулятор JVM. Для каждой инструкции и каждой их последовательности определялись начальное и конечное состояние. Конкретные значения не вычислялись, определялись только типы операндов. То есть всегда можно было сказать сколько значений и каких типов снималось и клалось на стек в результате выполнения произвольного фрагмента кода. Затем на основе этой информации находился другой набор, которым можно заменить данный (в случае мутации он создавался случайно, в случае скрещивания — искался во второй особи), для сохранения корректности кода он должен был быть эквивалентен в плане обращения с состоянием JVM — то есть снимать со стека и класть обратно ровно то же количество и типы значений.
Это не относится к промежуточным вычислениям, то есть фрагмент внутри себя может делать со стеком что угодно, но после себя должен оставить ровно такое же состояние.
Пример:
Начальное поколение создавалось по этим же правилам — оно должно было изменять состояние JVM таким же образом как и исходная последовательность инструкций. Таким образом всегда поддерживалась корректность особей и их сравнимость: поскольку все особи после своей работы всегда оставляли одинаковое состояние (значения одних и тех же типов на стеке в одном и том же порядке) то легко было сравнивать похожесть получаемых результатов с референсными: достаточно было просто посчитать разность двух многомерных векторов, в которых каждое значение — это один регистр или элемент стека (я тут периодически использую как джавовскую так и не-джавовскую терминологию так как в принципе алгоритм применим к любому виду вычислительной машины, и я сам его проверял на нескольких целях).
**Фитнес-функция**
Что же нам нужно от наших особей? А нужно нам чтобы они во-первых считали те же самые результаты, а во-вторых — делали это быстрее исходной. А чтобы это проверить — нам их надо запустить.
У нас уже есть посчитанные состояния VM на каждом шаге выполнения наших особей. В частности это дает нам необходимый набор входных данных — то есть то, какие регистры надо заполнить и сколько и каких элементов на стек положить чтобы все сработало как надо. Отлично, дописываем к началу каждой особи один и тот же код, который будет эти данные создавать, а к концу — который будет записывать результаты куда нам надо. Итоговое значение фитнес-функции составим из расстояния между векторами результатов и коэффициента ускорения по сравнению с оригиналом.
По ходу исследований выяснилось, что «лобовая» реализация приводит к быстрому вырождению популяции, которая забивается очень короткими (и очень быстрыми) особями, которые не делают ничего полезного (то есть вместо вычислений, например, просто опустошают стек до нужной глубины) но при этом выигрывают за счет длины и скорости. Поэтому пришлось сделать так, что скорость начинает учитываться только после того, как вычисленные результаты становятся достаточно близкими к референсным.
Помимо скорости работы и эквивалентности результатов оказалось необходимым дополнительно контролировать длину особей. Без такого контроля в популяции достаточно быстро (примерно за 50 поколений) начинается рост средней длины особи, вплоть до 10-20 длин исходного фрагмента кода. Появление таких длинных особей сильно замедляет генетический процесс, так как во-первых увеличивается время анализа кода, необходимого для проверок корректности (растет время каждой итерации), а во-вторых для получения решения необходимо избавиться от большого числа ненужных инструкций в особи, что может занимать значительное число поколений (растет общее число итераций).
Поскольку в данной работе исследуется оптимизация скорости выполнения, а не размера набора инструкций, коэффициент длины используется только для отсева слишком длинных кандидатов и применяется к формуле только если особь, для которой вычисляется фитнес-функция, длиннее исходной.
Итоговый вид фитнес-функции:
Здесь *Xc* — тестируемая особь, *Xo* — оригинальный фрагмент, *diff* — разность векторов результатов, *len* — отношение длинн, *speedup* — отношение времени выполнения.
*speedup* приравнивается к единице если *diff* больше некоторой константы, то есть скорость начинает учитываться только для считающей почти правильные значения особи.
Нетрудно убедиться что данная функция обладает следующими свойствами:
* Она близка к нулю для начальных случайных фрагментов кода (велика разница результатов)
* Она приближается к единице по мере схождения вычисляемых результатов с референсными
* Она равна единице для исходного фрагмента
* Все варианты с фитнес-функцией большей единицы — потенциальные результаты работы нашего алгоритма, это те особи которые считают что надо и при этом быстрее/короче
**Верификация**
По ходу работы алгоритма каждая особь проверялась на соответствие результатов тем, что давал исходный фрагмент на нескольких десятках тестовых примеров. Это быстрая и достаточно эффективная проверка, но она явно недостаточна для строгого доказательства эквивалентности полученной оптимизированной последовательности и исходной. Чтобы такое доказательство получить использовалась формальная верификация.
Для этого для верифицируемой и исходной особей все их операции представлялись в символьном виде, то есть после прогона через специальный эмулятор в каждом регистре/ячейке стека лежало символьное представление вычисленной и записанной в него формулы. Затем все эти формулы сравнивались с помощью решателя SMT-выражений Z3. Такой решатель способен доказать, что не существует набора входных параметров, на которых две проверяемые формулы дадут разный результат. Если же такой набор существует, то он будет построен и предъявлен.
Поскольку верификация эта достаточно длительный процесс (могла занимать десятки минут для одной особи и пары простейших математических выражений) то подвергались ей только кандидаты в окончательное решение, то есть особи с фитнес-функцией большей 1.
Впрочем стоит отметить что в ходе исследований не встретился ни один кандидат, который бы вычислял все правильно на тестовых наборах данных но отсеивался бы на этапе верификации.
**Примеры**
Генетические алгоритмы, как и любая наверное отрасль машинного обучения — удивительная вещь, периодически заставляющая программиста хвататься за голову и кричать «как, как он это сделал?». Пикантности тут добавляло то, что в моем случае с моей помощью компьютер фактически улучшает сам свои программы каким-то неведомым образом, придумывая такие штуки до которых я сам сходу додуматься бы не смог.
В общем я иногда ощущал себя героем этого и подобных комиксов:
Ну вот мы прогнали наших особей через скрещивания и эмуляции, проверифицировали эквивалентность результатов и что же мы получили? Приведу пару примеров найденных мной оптимизаций.
Сворачивание констант и прочие стандартные штуки
Во-первых алгоритм достаточно хорошо находит всякие стандартные вещи на синтетических тестах, типа удаления неиспользуемых вычислений или свертывания констант, хотя под это специально я его не затачивал. Например довольно быстро он понял что *x + 1 — 2* можно сократить до *x — 1*:
Было:
```
ILOAD 0
ICONST_1
IADD
ICONST_2
ICONST_M1
IMUL
IADD
```
Стало:
```
ILOAD 0
ICONST_1
ISUB
```
Все остальные примеры взяты из реального кода, была написана специальная тулза которая парсила скомпилированные классы и искала в них подходящие последовательности для оптимизации (то есть не содержащие ветвлений и неподдерживаемых инструкций).
Упрощение математических выражений и вынесение за скобки
Пример из начала статьи сократился с 11 до 9 инструкций: . На первый взгляд выражение вообще неправильное, и получив его я бросился искать ошибку в коде эмулятора. Ан нет, все верно, так как выражение *(x + 1)x* всегда четное и неотрицательное, то есть младший бит у него всегда ноль, а в таком случае сложение с единицей эквивалентно xor с ней же, а работает видимо на какие-то доли быстрее. Правда только в отсутствии JIT, если его включить то на первое место выходит вполне ожидаемое *((x + 1)x + 1)x*. Уж не знаю почему вариант с OR (или с XOR) работал быстрее, но этот результат был регулярно воспроизводим, в том числе на разных версиях джавы и на разных компьютерах
Вообще JIT в случае с джавой принес очень много головной боли, и я даже пожалел что выбрал эту платформу. Никогда нельзя было быть уверенным на все сто, это твоя оптимизация увеличила скорость, или это чертова джава-машина внутри себя что-то там провернула. Я конечно изучил всякие полезны статьи типа [Анатомия некорректных микротестов оценки производительности](http://www.ibm.com/developerworks/ru/library/j-jtp02225/), но все равно намучался с ней изрядно. Очень раздражало последовательное улучшение кода, зависящее от числа запусков. Запустил фрагмент сто раз — он работает в режиме интерпретатора и дает один результат, запустил тысячу — включился JIT, перевел в нативный код но особо не оптимизировал, запустил десять тысяч — JIT принялся что-то ковырять в этом нативном коде, в итоге скорости выполнения меняются на порядки и все это приходится учитывать.
Логические операторы
Впрочем кое-где мне даже JIT удалось обскакать. Например выражение *(x XOR -1)AND y* Достаточно очевидной оптимизацией для него будет *!x and y*, и это именно то что сгенерирует для него вам компилятор С++. Но в байткоде джавы нет операции побитового однооперандного не, так что оптимальным вариантом здесь будет *(x XOR y) AND y*. При этом JIT до такого уже не додумывается (проверялось включением дебажного вывода на server JVM 1.6), что позволяет немного выиграть по скорости.
Хитрая особенность сдвига влево
Был еще один забавный результат с оператором сдвига. Где-то в недрах BigInteger было найдено выражение *1 << (x & 31)*, оптимизированной версией которого алгоритм выдал *1 << x*.
Опять хватание за голову, опять поиски бага — очевидно ведь что алгоритм взял и выкинул целый значимый кусок кода. Пока я не додумался повнимательнее перечитать спецификацию операторов, в частности оказалось что оператор << использует только 5 младших бит своего второго операнда. Поэтому явный *&31* в общем-то не нужен, оператор сделает это за тебя (я так понял что в байткоде библиотечных классов принудительный & оставлен для совместимости со старыми версиями, так как эта фишка появилась не в самой первой джаве).
**Проблемы и заключение**
Получив свои результаты я начал думать что с ними делать дальше. И вот тут как раз ничего и не придумалось. Оптимизации мои в случае с джавой слишком малы и незаметны чтобы оказать существенное влияние на скорость работы программы в целом, во всяком случае для тех программ на которых я мог все это тестировать (может какие-нибудь глубоконаучные вычисления и выиграют заметно от замещения пары инстркций и сокращения времени одного такта на пару наносекунд). К тому же эффект значительно съедается самой структурой джава-машины, виртуальностью и JIT.
Я попробовал перейти на другие архитектуры. Сперва на x86, получил первую работающую версию, но ассемблер там слишком сложный и написать требующийся для его верификации код оказалось мне не под силу. Затем я попробовал ткнуться в сторону шейдеров, благо работал тогда в геймдеве, и добавил поддержку для пиксельного шейдерного ассемблера. Но там я просто не смог найти ни одного подходящего шейдера, содержащего хороший пример последовательности инструкций.
В общем так и не придумал куда это дело прикрутить. Хотя ощущение от того, когда компьютер оказывается умнее тебя и находит такую оптимизаци, которую ты даже не сразу сам можешь понять как она работает, я запомнил надолго. | https://habr.com/ru/post/265195/ | null | ru | null |
# Rust. Borrow checker через итераторы
Привет, Хабр!
Я уже около года изучаю и, в свободное время, пишу на расте. Мне нравится как его авторы решили проблему управления памятью и обошлись без сборщика мусора — через концепцию заимствования. В этой статье подойду к этой идее через итераторы.
Последнее время scala является моим основным языком, так что сравнения будут с ней, но их не много и все интуитивно понятные, без магии :)
Статья рассчитана на тех кто что-то слышал о rust'e, но в детали не вдавался.
фотографии взяты [отсюда](https://www.flickr.com/photos/gilles_dubochet/7327041044) и [отсюда](https://abandonedkansai.com/2015/04/07/yubara-onsen-ropeway-lower-terminus/extremely-rusty-staircase/)
### Предисловие
В jvm языках принято прятать работу со ссылками, то есть там мы почти всегда работаем со ссылочными типами данных, поэтому решили спрятать амперсанд(&).
В расте же есть явные ссылки, например на integer — `&i32`, ссылку можно разыменовать через `\*`, так же может быть ссылка на ссылку и тогда её надо будет дважды разыменовывать `\*\*`.
Iterator
--------
При написании кода очень часто нужно отфильтровать коллекцию условием (предикатом). В скале взять чётные элементы выглядело бы как-то так:
```
val vec = Vector(1,2,3,4)
val result = vec.filter(e => e % 2 == 0)
```
Заглянем в сорцы:
```
private[scala] def filterImpl(p: A => Boolean, isFlipped: Boolean): Repr = {
val b = newBuilder
for (x <- this)
if (p(x) != isFlipped) b += x
b.result
}
```
Не вдаваясь в детали `newBuilder'a`, видно что создаётся новая коллекция, итератором пробегаемся по старой и если предикат вернул true, то добавляем элемент. Несмотря на то что коллекция новая, её элементы на самом деле это ссылки на элементы из первой коллекции, и если, вдруг, эти элементы будут мутабельны, то их изменение будет общим для обоих коллекций.
Теперь попробуем сделать аналогичное в расте. Я сразу дам рабочий пример, а потом буду рассматривать различия.
```
let v: Vec = vec![1, 2, 3, 4];
let result: Vec<&i32> = v.iter().filter(|e| \*\*e % 2 == 0).collect();
```
Воооу, воу, что? Двойное разыменование указателя? Просто чтобы отфильтровать вектор? Жёстко :( Но на это есть свои причины.
Выделим чем этот код отличается от скалы:
1. явно получаем итератор на вектор (`iter()`)
2. в функции предикате зачем-то дважды разыменовываем указатель
3. вызываем `collect()`
4. ещё и в итоге получился вектор ссылочных типов Vec<&i32>, а не обычных интов
Borrow checker
--------------
Зачем же явно вызывать `iter()` на коллекции? Любому скалисту понятно, что если вызываешь `.filter(...)` то нужно проитерироваться по коллекции. Зачем же в расте явно писать то, что можно сделать неявно? Потому что там есть **три** разных итератора!
Чтобы разобраться «почему три?» нужно затронуть тему **Borrow***(заимствовать, брать)* **checker**'a. Той самой штуки за счёт которой раст работает без GC и без явного выделения/освобождения памяти.
Зачем он нужен?
1. Чтобы избежать ситуаций когда несколько указателей указывают в одну и туже область памяти, позволяя её менять. То есть race condition.
2. Чтобы не деаллоцировать одну и туже память несколько раз.
За счёт чего это достигается?
За счёт концепции владения.
В целом концепция владения проста — владеть чем-либо (даже интом) может только один.
Владелец может меняться, но он всегда один. Когда мы пишем `let x: i32 = 25` это означает, что произошло выделение памяти под 32битный int и им владеет некий `x`. Идея владения существует только в уме компилятора, в borrow checker'e. Когда владелец, в данном случае `x` выйдет из области видимости (goes out of scope), то память которой он владеет будет очищена.
Приведу код который не пропустит borrow checker:
```
struct X; //объявляем структуру
fn test_borrow_checker () -> X {
let first = X; // создаём экземпляр
let second = first; // меняем владельца
let third = first; // раз владелец изменился, то использовать first тут уже нельзя
// компилятор ругнётся словами value used here after move
return third;
}
```
`struct X` это что-то вроде `case class X()` — структура без полей.
Такое поведение супер контринтуитивно, думаю, для всех. Не знаю других языков в которых нельзя было бы «использовать» одну и туже «переменную» дважды. Тут важно прочувствовать этот момент. first вовсе не ссылка на X, это его **владелец**. Меняя владельца мы как бы убиваем предыдущего, borrow checker не допустит его использования.
**Зачем надо было создавать свою структуру, почему бы не использовать обычный integer?**
Вдумчивый читатель может спросить — зачем автор создал тут новую структуру (`struct X`), взял бы, например, тот же integer. По идее да, можно было бы так сделать, но тогда код бы компилировался:
```
fn test_borrow_checker () -> i32 {
let first = 32;
let second = first;
let third = first;
return third;
}
```
Этот код скомпилируется, потому что borrow checker, увидит что мы дважды используем одно и тоже и попытается скопировать значение, вместо замены владельца. В расте есть трейт Copy, смысл которого это копирование области памяти. То есть в примере с `i32` second получит не владение на число, а его копию(и станет её владельцем), из-за этого third сможет получить владение. Для структуры X я не определил трейт Copy, поэтому там компилятор не смог выкрутиться.
Далеко не всё можно просто скопировать. Например строку нельзя, ведь строка это ссылка на мутируемую область памяти и если мы скопируем эту ссылку, то у нас получится две «владеющие» ссылки на одну и туже область памяти и это разрушит всю концепцию. Для копирования таких сложносоставных структур есть трейт Clone, его отличие в том, что он вызывается только явно. Более детально про [copy](https://doc.rust-lang.org/std/marker/trait.Copy.html) и [clone](https://doc.rust-lang.org/std/clone/trait.Clone.html).
Вернёмся к итераторам. Концепцию «захвата» среди них представляет **IntoIter**. Он «поглощает» коллекцию давая владение над её элементами. В коде эта идея будет отражена так:
```
let coll_1 = vec![1,2,3];
let coll_2: Vec = coll\_1.into\_iter().collect();
//coll\_1 doesn't exists anymore
```
Вызвав `into\_iter()` у coll\_1 мы «превратили» его в итератор, поглотили все его элементы, как в предыдущем примере `second` поглотил `first`. После этого любые обращения к coll\_1 будут караться borrow checker'ом во время компиляции. Потом собрали эти элементы функцией `collect`, создав новый вектор. Функция `collect` нужна чтобы собрать из итератора коллекцию, для этого приходится явно указывать тип того что мы хотим собрать. По этому у coll\_2 явно указан тип.
Окей, в целом описанного выше достаточно для языка программирования, но не особо эффективно будет копировать/клонировать структуры данных каждый раз когда мы хотим передать их, да и иметь возможность изменять что-то тоже надо. Так мы переходим к указателям.
Pointers
--------
Владелец, как мы выяснили, может быть только один. А вот ссылок можно иметь сколько угодно.
```
#[derive(Debug)]
struct Y; //объявляем структуру
fn test_borrow_checker() -> Y {
let first = Y; // создаём экземпляр
let second: &Y = &first // не меняем владельца, а берём ссылку на значение
let third = &first // берём ещё одну ссылку
//используем обе
println!("{:?}", second);
println!("{:?}", third);
return first;
}
```
Этот код уже валидный, потому что владелец по прежнему один. Вся логика с владением проверяется только на этапе компиляции, никак не влияя на выделение/перемещение памяти. Более того, можно заметить что тип у second изменился на `&Y`! То есть семантика владения и ссылок отражена в типах, что позволяет во время компиляции проверить, например, отсутствие race condition.
Каким образом можно защититься от race condition во время компиляции?
Задав ограничение на кол-во мутабельных ссылок!
Мутабельная ссылка в один момент времени может быть одна и только одна (без иммутабельных). То есть либо одна/несколько иммутабельных, либо одна мутабельная. В коде выглядит так:
```
//объявляем структуру
struct X {
x: i32,
}
fn test_borrow_checker() -> X {
let mut first = X { x: 20 }; // создаём экземпляр
let second: &mut X = &mut first; // создаём мутабельную ссылку
let third: &mut X = &mut first; // создаём мутабельную ссылку. До тех пор пока мы не используем `second` можно считать что мутабельная ссылка только одна - последняя.
// second.x = 33; // если раскоментить эту строку, то это приведёт к тому что у нас появится две мутабельных ссылки одновременно, компилятор не допустит такое
third.x = 33;
return first;
}
```
Пройдёмся по изменениям относительного предыдущего примера. Во-первых, добавили одно поле в структуру, чтобы было что менять, нам ведь нужна мутабельность. Во-вторых, появилось `mut` в объявлении «переменной» `let mut first = ...`, это маркер компилятору о мутабельности, как `val` & `var` в скале. В-третьих, все ссылки изменили свой тип с `&X` на `&mut X` (выглядит это, конечно, монструозно. и это без лайфтаймов...), теперь мы можем изменять значение хранящееся по ссылке.
Но я говорил, что мы не можем создавать несколько мутабельных ссылок, мол borrow checker этого не даст, но сам создал две! Да, но проверки там весьма хитрые, как раз поэтому порой неочевидно почему компилятор ругается. Он всеми силами пытается сделать так, чтобы ваша программа скомпилировалась и если совсем никаких вариантов нет уложиться в правила, тогда ошибка, и, возможно, не та которую вы ждёте, а та которая нарушает последнюю его попытку, самую отчаянную и не очевидную для новичка :) Например, вам сообщают что структура не реализует Copy трейт, хотя вы нигде не вызывали никаких копий.
В данном же случае существование двух мутабельных ссылок одновременно позволено потому, что используем мы только одну, то есть `second` можно выбросить и ничего не изменится. Также `second` можно использовать **до** создания `third` и тогда всё будет окей. Но, если раскомментировать `second.x = 33;`, то получится что две мутабельные ссылки существуют одновременно и никак тут уже не выкрутишься — compile time error.
Iterators
---------
Итак, у нас есть три типа передачи:
1. Поглощение, заимствование, moving
2. Ссылка
3. Мутабельная ссылка
Для каждого типа нужен свой итератор.
1. **IntoIter** поглощает объекты оригинальной коллекции
2. **Iter** бегает по ссылкам на объекты
3. **IterMut** бегает по мутабельным ссылкам на объекты
Возникает вопрос — когда какой использовать. Нет серебряной пули — нужна практика, чтение чужого кода, статей. Приведу пример, демонстрирующий идею.
Допустим есть школа, в ней класс, в классе ученики.
```
#[derive(PartialEq, Eq)]
enum Sex {
Male,
Female
}
struct Scholar {
name: String,
age: i32,
sex: Sex
}
let scholars: Vec = ...;
```
Вектор школьников мы взяли запросом к базе данных, например. Дальше понадобилось посчитать кол-во девочек в классе. Если мы «поглотим» вектор через `into\_iter()`, то после подсчёта не сможем больше использовать эту коллекцию для подсчёта мальчиков:
```
fn bad_idea() {
let scholars: Vec = Vec::new();
let girls\_c = scholars
.into\_iter()
.filter(|s| (\*s).sex == Sex::Female)
.count();
let boys\_c = scholars
.into\_iter()
.filter(|s| (\*s).sex == Sex::Male)
.count();
}
```
На строке подсчёта мальчиков будет ошибка «value used here after move». Очевидно также, что и мутабельный итератор нам тут ни к чему. По-этому просто `iter()` и работа с двойной ссылкой:
```
fn good_idea() {
let scholars: Vec = Vec::new();
let girls\_c = scholars.iter().filter(|s| (\*\*s).sex == Sex::Female).count();
let boys\_c = scholars.iter().filter(|s| (\*\*s).sex == Sex::Male).count();
}
```
Вот чтобы увеличить кол-во потенциальных новобранцев в стране уже потребуется мутабельный итератор:
```
fn very_good_idea() {
let mut scholars: Vec = Vec::new();
scholars.iter\_mut().for\_each(|s| (\*s).sex = Sex::Male);
}
```
Развивая идею можно сделать из «ребят» солдат и продемонстрировать «поглощающий» итератор:
```
impl Scholar {
fn to_soldier(self) -> Soldier {
Soldier { forgotten_name: self.name, number: some_random_number_generator() }
}
}
struct Soldier {
forgotten_name: String,
number: i32
}
fn good_bright_future() {
let mut scholars: Vec = Vec::new();
scholars.iter\_mut().for\_each(|s| (\*s).sex = Sex::Male);
let soldiers: Vec = scholars.into\_iter().map(|s| s.to\_soldier()).collect();
// нет больше scholars, как это не грустно
}
```
На этой замечательной ноте, пожалуй, всё.
Остался последний вопрос — откуда взялось двойное разыменование ссылок в `filter`. Дело в том, что предикат представляет собой функцию которая принимает ссылку на аргумент (дабы его не захватить):
```
fn filter(self, predicate: P) -> Filter where
Self: Sized, P: FnMut(&Self::Item) -> bool,
```
предикат это FnMut(грубо говоря функция), которая принимает ссылку на свой(self) item и возвращает bool. Так как у нас уже была ссылка от итератора`.iter()`, то в фильтре появилась вторая. При поглощении итератором(`into\_iter`) двойное разыменование ссылки превратилось в обычное.
### Продолжение
Большого опыта в написании статей у меня нет, так что буду рад критике.
Если интересно, то могу продолжить. Варианты тем:
* как и когда происходит деаллокация памяти
* время жизни ссылок
* асинхронное программирование
* написание небольшого веб сервиса, можно даже предложить api
### Links
* [rust book](https://doc.rust-lang.org/book/)
* Из-за концепции владения реализация таких базовых вещей как, например, связный список перестаёт быть тривиальной. [Тут](https://rust-unofficial.github.io/too-many-lists/index.html) разбирают несколько способов как их реализации | https://habr.com/ru/post/499108/ | null | ru | null |
# 6 вещей на JavaScript, которые можно делать и нельзя
Язык JavaScript претерпел много изменений с момента своего создания. Поэтому сейчас не так просто отслеживать хорошие практики с таким количеством новых функций, изменений и фреймворков.
В этой статье мы рассмотрим некоторые общие правила, которые лучше всего использовать в JavaScript. Эти советы помогут нам писать код лучше. Они подходят как для новичков, так и для опытных разработчиков.
---
### 1. Объявление одной переменной на одной линии
В JavaScript вы можете объявить сразу несколько переменных на одной линии. Это то, что я не рекомендовал бы делать. Объявление переменных на разных линиях делает код более простым для чтения и понимания.
Посмотрим пару примеров:
```
// ❌ нежелательно
const x = 0, y = 10, z = 20;
// ✅ предпочтительно
const x = 0;
const y = 10;
const z = 20;
```
Объявление нескольких переменных на одной строке может выглядеть "круче", но это непрактично. Код становится менее читабельным. Этот подход также может привести к нежелательным результатам.
В нижеприведенном примере может показаться, что `x`, `y`, и `z` - все константы. Но это неправда, константой является только `x`.
```
const x = y = z = 10;
// ❌ y и z не константы, им можно присвоить новые значения
y = 15; // works
z = 15; // works
// только x константа
x = 15; // error: Uncaught TypeError: Assignment to constant variable.
```
Но в любом правиле есть свои исключения. Мы можем определять более одной переменной на одной линии, используя деструктуризацию.
Давайте посмотрим на код:
```
const point = { x: 10, y: 15, z: 20 };
// ✅ желательно
const { x, y } = point;
// ✅ выведет 10
console.log(x);
// ✅ выведет 15
console.log(y);
```
Пример выше - лучшее решение.
---
### 2. Понимание браузерной оптимизации
Поскольку JavaScript не компилируется, единственный способ оптимизации, которую делает движок — во время выполнения. Он придумывает способы оптимизации на ходу.
Эти способы скрыты и не всегда понятны. Каждый движок имеет собственную реализацию оптимизаций. Например, у движка Хрома`v8` этот механизм называется `TurboFan`. Понимая некоторую базу его внутреннего устройства, мы может писать более эффективный код.
Если мы будем игнорировать движок, производительность может пострадать. Наше приложение будет работать медленнее, что явно не понравится пользователю.
Посмотрим на несколько ситуаций, откуда мы можем извлечь пользу:
#### Прототипы
Движок JavaScript понимает, что какие-либо изменения прототипов довольно редки. Прототип объекта стабилен и предсказуем. Вот почему движок делает некоторые оптимизации на ранних этапах прототипов.
Однако, тут две стороны одной медали. При изменении прототипа объекта движок пересчитывает все оптимизации. Из-за этих изменений приложение работает медленнее. Это даже может замедлить код, который взаимодействует с прототипом.
Рассмотрим пример плохого использования:
```
// объявление прототипа
function Item() {}
Item.prototype.save = () => {};
Item.prototype.delete = () => {};
...
...
function foo() {
// ❌ плохо, мы не должны менять прототип
delete Item.prototype.save;
// выведете undefined: save метод больше недоступен
console.log(Item.prototype.save);
}
```
Если вам правда необходим похожий функционал, просто используйте свойства самого объекта. Это не приведет к пересчету оптимизаций его прототипа.
Посмотрим на исправленный пример:
```
// объявление прототипа
function Item() {
this.save = () => {};
}
Item.prototype.delete = () => {};
...
...
function foo() {
const newItem = new Item();
// ✅ желательно, удаление свойства без изменения самого прототипа
delete newItem.save;
// выведет undefined: save метод больше недоступен
console.log(newItem.save);
}
```
Больше можно узнать в статье от [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/The_performance_hazards_of_prototype_mutation).
#### Типизация
Так как JavaScript использует JIT компиляцию, ему необходимо делать много проверок перед тем как выполнить какую-либо функцию. Во многом он зависит от оптимизаций.
Как происходят эти оптимизации? Когда функция выполняется часто, она "нагревается". Движок хранит скомпилированную версию. Когда функция становится "горячее", она отправляется в качестве оптимизирующего компилятора. Там используется множество стратегий оптимизаций.
Одна из таких стратегий - типизация. Функция создаст заглушку для каждой комбинации типа и параметров. Это значит, если наша функция мономорфная (с одинаковым типом параметров), потребуется всего одна заглушка. Если она полиморфная, потребуется одна заглушка для каждой комбинации параметра и типа.
Соответственно, если следить за типами параметров, можно улучшить производительность.
Рассмотрим пример:
```
function add(a, b) {
return a + b;
}
// ✅ "горячую" функцию JIT оптимизирует эффективно
add(1,2);
add(1,1);
add(2,3);
add(4,5);
```
Если бы мы выполняли эту функцию с разными типами параметров, код не выполнялся бы так быстро.
Как раз посмотрим на такой вариант:
```
function sum(a, b) {
return a + b;
}
// ❌ если "горячая" функция будет храниться
// будет создано много заглушек для каждой комбинации
add(1,2);
add(1,'3');
add(2,true);
add(4,5);
```
TypeScript, например, может помочь нам сделать наши методы максимально эффективными.
---
### 3. Ранний вызов return
Мы привыкли к шаблону `if/else`, и не подвергали его сомнению. Однако, с опытом вы могли понять, что использование полного ветвления это:
* неэффективно;
* трудно читать;
* трудно поддерживать.
Как мы можем улучшить наш код? Просто используем шаблон раннего вызова return.
"Ранний вызов return" - это шаблон, в котором рекомендуется возвращать какой-либо результат настолько рано, насколько это возможно, не прибегая к `else` выражению.
Взглянем на классическую реализацию `FizzBuzz` функции.
Код ниже мог бы быть решением:
```
function FizzBuzz(i) {
let result = undefined;
if (i % 15 == 0) {
result = 'FizzBuzz';
} else if (i % 3 == 0) {
result = 'Fizz';
} else if (i % 5 == 0) {
result = 'Buzz';
} else {
result = i;
}
return result;
}
```
Однако, его можно улучшить, используя шаблон раннего вызова return:
```
function FizzBuzz(i) {
if (i % 15 == 0) {
return 'FizzBuzz';
}
if (i % 3 == 0) {
return 'Fizz';
}
return (i % 5 == 0) ? 'Buzz' : i;
}
```
В итоге наш код стал:
* более продуманным;
* более читабельным;
* более эффективным.
---
### 4. Принятие функционального программирования
JavaScript это мультипарадигменный язык программирования. Мы можем выбирать между объектно-ориентированным программированием и функциональным. Первый подход стал более доступным с появлением классов в ES6.
Правда, это все еще синтаксический сахар для обычного прототипного наследования в JS. Это может привести к конфликтам.
По моему мнению, функциональный подход предполагает модульность и очень легок при тестировании.
Мы можем наблюдать как создатели React упростили процесс разработки, отказавшись от классового подхода. Даже если вы никогда не писали на React, сразу сможете заметить большую разницу.
Посмотрим на пример с классами на React:
```
class ClassComponent extends React.Component{
constructor(){
super();
this.state={
count :0
};
}
increase = () => {
this.setState({count : this.state.count + 1});
}
render(){
return (
{this.state.count}
Add
)
}
}
```
А теперь перепишем тот же компонент, используя функциональное программирование:
```
const functionComponent = () => {
const [count, setCount] = useState(0);
const increase = () => setState(count + 1);
return (
{count}
Add
);
}
```
В результате мы тратим меньше кода, что делает его более простым.
У функционального подхода есть много преимуществ. Он спасает нас от большого количества проблем, связанных с изменениями сущностей.
---
### 5. Использование '===' для проверки на равенство
Оператор `==` - оператор сравнения, который приводит операнды к одному и тому же типу.
Он использует приведение типов, чтобы сравнить их значения. Например, когда сравниваются число и строка, движок преобразует строку в число и после этого сравнивает их.
Оператор `==` сравниваниет значения, но не типы.
Посмотрим несколько примеров:
```
'1' == 1 // ✅ true
true == 1 // ✅ true
false == 0 // ✅ true
'0' == false // ✅ true
```
Это может привести к некоторым "веселым" ситуациям, изображенным на картинке ниже:
Чтобы предотвратить нежелательное поведение, лучше проверять и тип, и значение. Это возможно с помощью оператора `===` .
При строгом сравнении сначала будут сравниваться типы значений. Если они не равны, то вернется false. Только если они совпадут, будут проверяться сами значения.
*⚠️* *Есть такая особенность, что*`NaN` *ничему не равно при строгом сравнении. Для этого мы можем использовать*`isNan()`*.*
Посмотрим на оператор `===` в действии:
```
1 === 1 // ✅ true
1 === '1' // ❌ false
const obj = {};
obj === obj // ✅ true
'x' === 'x' // ✅ true
NaN === NaN // ❌ false
isNaN(NaN) // ✅ true
```
### 6. Await вместо промисов
До промисов работа с асинхронными операциями была довольно утомительной. Все делалось через колбэки. Это приводило к, так называемому, "аду колбэков" (callback hell). Код было трудно читать и поддерживать. Промисы помогли писать код лучше, но они все еще далеки от совершенства, и могут привести к "аду промисов" (promise hell).
`Async/await` функционал был представлен в ES7. Он упростил работу с промисами в языке. Работать с асинхронностью стало удобнее, ведь ведь всю тяжелую работу на себя взял движок. А выпуск await верхнего уровня в ES12 добавил последнюю часть, отсутствующую в этом функционале.
Сейчас осталось не так много случаев, когда нам надо использовать промисы вместо `async/await`. Использование `async/await` повысит читабельность нашего кода.
Рассмотрим пример:
```
const createItem = (id) => Promise.resolve(true);
const updateStock = () => Promise.resolve(true);
function addItem() {
createItem()
.then(({ id }) => updateStock(id))
.then(() => console.log('success'))
.catch(() => console.error('oops error'));
}
```
Если мы перепишем его с `async/await`, то его станет легче прочитать:
```
const createItem = (id) => Promise.resolve(true);
const updateStock = () => Promise.resolve(true);
async function addItem() {
try {
const { id } = await createItem();
await updateStock(id);
console.log('success');
} catch {
console.error('oops error');
}
}
```
`Async/await` хорошо работает с новыми методами промисов такими как `Promise.all`, `Promise.any`, `Promise.allSettled` и тд.
Посмотрим пример с промисами и `async/await` в ES12:
```
(async () => {
const result = await Promise.any([
Promise.reject('Error 1'),
Promise.reject('Error 2'),
Promise.resolve('success'),
]);
console.log(`result: ${result}`);
})();
// result: success
```
---
### Итог
Это были мои заметки по разработке, когда дело доходит до JavaScript. Конечно, их намного больше, но эти шесть - мои фавориты. Важность использования `Strict` также очень близка к ним. К счастью, нам не нужно об этом сильно беспокоиться, поскольку есть инструменты, которые уже сделают все за нас.
Обязательно используйте `ESLint`. Он автоматизирует цикл разработки, помогает нам писать код лучше и ускоряет процесс проверки кода. | https://habr.com/ru/post/656583/ | null | ru | null |
# Непрерывная интеграция проектов .NET: NAnt и/или MSBuild?
Привет всем читателям Хабра!
Не так давно я начал использовать для сборки сервером непрерывной интеграции некоторых проектов NAnt наряду с уже освоенным MSBuild. Как всегда, в процессе работы обнаруживаются бонусы с разными знаками (как плюс, так и минус). Тех, кому интересны детали сборки разными движками (MSBuild, NAnt) в контексте сервера CI, с удовольствием приглашаю под кат.
Процесс сборки
--------------
Сначала вкратце рассмотрим процесс сборки, то есть список фаз которые проходят исходные файлы, чтобы стать конечным продуктом:
1. чистка сборочной папки от результатов предыдущей сборки
2. инициализация процесса сборки (например, установка нужной версии в файлы кода)
3. компиляция файлов с кодом
4. прогон тестов
5. создание файлов специального назначения на основе бинарных файлов (инсталляторы msi, пакеты NuGet и т.п.)
6. публикация результатов сборки (выкладка на FTP, nuget push)
Эта модель сборки достаточно упрощена, чтобы не загромождать обсуждение несущественными деталями. Так фаза компиляции может включать в себя загрузку пакетов из хранилища, фаза тестирования разбиваться на прогоны модульных и интеграционных тестов. Возможность адаптации инструмента сборки под нужный процесс, на мой взгляд, является достаточно существенным фактором в выборе.
### Поддержка процесса сборки в MSBuild
В виду того, что MSBuild является штатным сборщиком для IDE (Visual Studio, SharpDevelop), то изначально работали с ним.
Для сборки проекта целиком использовалась пара дополнительных скриптов. Почему именно пара, а не один, спросите вы. Всё достаточно просто: MSBuild не умеет подгружать targets-файлы в процессе выполнения скрипта. Он сначала импортирует все заданные в скрипте файлы, а затем стартует процесс сборки. Поэтому первый скрипт отвечал только за скачивание дополнительных targets-файлов из репозитория NuGet, а второй, пользуясь всем свалившимся на него богатством, выполнял сценарий сборки.
Для сборки отдельных проектов использовались сгенерированные IDE файлы-csproj с лёгким обогащением их своими переменными. Оказалось, что с наследованием проектов у MSBuild дело обстоит туго. Для правильного прогона родительский скрипт должен был полностью передавать весь набор параметров внутрь дочернего, простого определения свойства в теле родителя было недостаточно. Это, конечно, не смертельно, но заставляет нас делать лишнюю работу.
Если с тремя первыми фазами, особых проблем нет, то реализация оставшихся требует некоторой сноровки. Т.к. файлы csproj используются IDE для управления проектом, то сильно менять их нельзя. Выходом стало написание в главном скрипте сборки сценария всех оставшихся фаз. Плюсы такого решения в том, что всё описано в одном месте. Однако, когда число production и парных им unit-test проектов возрастает до десятка, поддерживать такой скрипт сборки становится сложно.
IDE любят генерировать отдельные выходные папки на каждую комбинацию Platform/Configuration, поэтому определить в процессе сборки, в какой папке у тебя находятся dll-ки от Reference-проекта не всегда является тривиальной задачей.
Если мы решаем использовать у себя в проекте репозиторий пакетов NuGet, то тут же получаем дублирование. Ссылка на dll из пакета будет присутствовать в двух местах, а именно в файлах csproj и packages.config. У клиента Nuget имеются известные проблемы при поддержании синхронности двух этих файлов. В частности, обновление пакетов не всегда приводит к желаемому результату.
### Поддержка процесса сборки в NAnt
NAnt на сегодняшний день имеет актуальную версию 0.92 (релиз лета 2012 года), поэтому в своих изысканиях я опирался именно на неё.
Здесь мы, пожалуй, начнём с выявленных недостатков.
Основные IDE (Visual Studio, SharpDevelop) не любят NAnt и «из коробки» формат его проектов не поддерживают. Хотя, ради полноты картины можно отметить, что одна из старых версий SharpDevelop NAnt поддерживала. Почему в текущей ветке развития SharpDevelop поддержка NAnt свёрнута в ноль для меня пока остаётся загадкой.
NAnt не обладает некоторыми проприетарными бонусами, позволяющими ему собирать некоторые типы проектов без помощи MSBuild (например, WPF). О минимизации последствий работы с MSBuild скажем чуть позже.
Что же мы имеем из приятных бонусов?
Работа с файлами по маскам позволяет нам минимизировать объём работы по поддержке единожды написанных скриптов.
Наследование свойств между проектами позволяет нам не заботиться о явной передаче всех значений между проектами разных уровней. Например, легко организовать сбор всех результатов компиляции в одной папке на уровне Solution вместо размножения папок bin, obj в каждом отдельном проекте.
Императивность работы NAnt позволяет легко модифицировать отдельные target'ы проектов по своему усмотрению. Реализация типовой задачки: скопировать помимо библиотек еще и пару самодельных конфигов при помощи BeforeBuild и AfterBuild событий (внутри них не используются задачи MSBuild, а обычно используются cmd- или Powershell-скрипты) смотрится «костыльной» по сравнению с явным использованием родной задачи NAnt copy.
Система вывода штатного сборщика Java Ant давно и хорошо парсится на сборочных серверах, соответственно с NAnt особых проблем нет. Для сервера сборки Jenkins (Hudson) наличествует отдельный плагин для NAnt.
NAnt, в отличие от MSBuild, умеет динамически загружать наборы дополнительных задач при явном на то указании внутри скриптов или загружает их автоматически, если их нужным образом расположить рядом с NAnt.exe. Таким образом, сам сборщик может распространяться способом «xcopy», что значительно облегчает использование единой конфигурации сборщика параллельно на нескольких машинах. Из полезных библиотек с дополнениями штатного набора задач хочется отметить:
* [NAnt Contrib](http://nantcontrib.sourceforge.net) большой набор дополнений для NAnt, обеспечивающий в том числе взаимодействие с MSBuild и Subversion
* [Wix](http://wixtoolset.org) позволяет собирать инсталляторы MSI
* [Nuget](https://github.com/Alxandr/NAnt.Nuget.Tasks) бонусы для работы с менеджером пакетов
По итогам всего выше сказанного для меня оптимальным сочетанием стало такое: сборка MSBuild при работе в IDE, запуск NAnt при работе сервера CI.
Сборка проекта WPF
------------------
В заключение своего поста хотел рассказать о ложке мёда в бочке дёгтя, а именно о сборке проекта WPF при помощи NAnt. Скажу сразу, волшебства по полному преодолению двойной компиляции (xaml -> cs -> dll) не будет. Однако, обучить MSBuild ходить в лоточек под зорким присмотром NAnt всё-таки можно.
При запуске MSBuild в контексте сборки NAnt у нас в наличии две ключевые проблемы:
1. MSBuild ошибочно думает, что проекты зависимостей нужно собирать
2. MSBuild ищет dll с зависимостями там, где они должны были оказаться после сборки проектов-зависимостей
Первая проблема решается установкой ключа сборки **/p:BuildProjectReferences=false**.
Вторая в лоб не решается, поэтому подойдём немного с иной стороны. Содержать статическую версию файла csproj для прогона сборки через NAnt нерентабельно, т.к. поддерживать придётся обе версии. Значит, нужно генерировать такую версию «на лету». Возьмём и напишем небольшое преобразование XSL, запустим его через задачу style NAnt и скормим MSBuild скорректированный проект. При запуске задачи style передаётся один параметр, содержащий путь к уже скомпилированным файлам DLL.
**Преобразование XSL**
```
xml version="1.0"?
.dll
```
Таким образом, нам удаётся добиться того, что MSBuild собирает свой проект изолированно, ничего не подозревая о других проектах. Как говорят люди «меньше знаешь, лучше спишь», что для управления MSBuild весьма актуально.
### Место (вместо) выводов
Как и чем пользоваться всегда надо решать самому или внутри команды, тщательно взвесив все «за» и «против».
Начать лучше всего с MSBuild, т.к. он обычно уже установлен на машине разработчика и не требует лишних телодвижений по основной настройке.
Работа с NAnt тоже не слишком сложна, но требует от разработчика некоторого «поворота» мозга. | https://habr.com/ru/post/192828/ | null | ru | null |
# Уже можно использовать две новые библиотеки из будущей PHPixie 3
Пока еще только ведутся работы над третьей версией фреймворка [PHPixie](http://phpixie.com), но уже можно точно сказать что он сильно изменится в лучшую (как по мне) сторону:
* Полный переход на стандарт PSR-2
* Поскольку фреймворк будет являть собой набор библиотек, то его компоненты можно будет использовать в любом проекте без самого PHPixie.
* 100% покрытия кода тестами. При чем в данном случае 100% не просто фигуральное слово а реально просчитанный «code coverage», то есть отношение строк которые вызываются при исполнении тестов ко всем строкам кода, кстати у Laravel это всего-лишь [53%](http://imgur.com/l18XuGf).
Вчера стали доступны две библиотеки которые войдут в PHPixie 3, они полностью готовы и их уже можно использовать с любым проектом. Это сделано Подробнее об этом можно почитать в [посте на сайте](http://phpixie.com/blog/new-phpixie-database-and-configuration-libraries/), а я здесь опишу то что мне больше всего в них нравится.
Кстати библиотеки таки действительно покрыты тестами на 100%, убедится можно [тут](https://rawgithub.com/PHPixie/Config/master/tests/report/index.html) и [тут](https://rawgithub.com/PHPixie/Database/master/tests/report/index.html).
#### PHPixie Config
##### Отрезки конфигурации (Config Slices)
Позволяют отделить опции для частей системы от самой системы, тем самым делая их более агностическими и независимыми. Для примера, рассмотрим такие настройки уровня какой-то игры в какой игрок пробует захватить замок:
```
array(
'battlefield' => array(
'background' => 'forest',
'castle' => array(
'turrets' => array(
'amount' => 5
)
)
),
'attackers' => array(
'knight' => array(
'attack' => 6
),
'paladin' => array(
'attack' => 4,
'spell' => 'heal'
)
)
);
```
Мы уже привыкли использовать '.' для чтения таких массивов, например используя $config->get('battlefield.castle.turrets.amount'), но использовать такой код в классе Castle было бы некорректно, так как ему надо тогда знать весь путь к тому месту где начинается его конфигурация. Можно конечно в родительском классе передавать все turrets\_amount прямо в конструктор, но есть лучший путь:
```
class Level {
public function __construct($slice){
$this->battlefield = new Battlefield($config->slice('battlefield');
}
}
class Battlefield {
public function __construct($slice){
$this->background = new Background($config->get('background'));
$this->castle = new Castle($config->slice('castle'));
}
}
class Castle {
public function __construct($slice){
$this->background = new Background($config->get('turrets.amount'));
}
}
$level = new Level($config);
```
Как видите все классы теперь полностью независимы от самого пути конфигурации, как раз для этого и придуман slice().
##### Разбиение конфигурации на папки
Возможность создавать отдельные файлы для частей конфигурации позволяет например легко коммитить только настройки самого приложение и включить в .gitignore файл с конфигурацией чего-то специфического ( например конекта к базе данных). Также как написано на сайте PHPixie позволяет на своей базе легко создать файлы с переводом текста на сайте на разные языки. Для примера возьмем такую структуру файлов:
```
config.php
config/
+-forest.php
+-forest/
+-meadow/
+-fairy.php
```
Теперь если мы будем искать опцию *forest.meadow.fairy.name*, поиск будет идти в таких местах:
1) 'name' в config/forest/meadow/fairy.php
2) 'fairy.name' в config/forest/meadow.php
3) 'meadow.forest.name' в config/forest.php
4) 'forest.meadow.forest.name' в config.php
Кстати есть поддержка записи информации назад в файл конфигурации, например если у вас есть система бана которая будет писать забаненные айпишки в конфиг.
#### PHPixie Database
Во первых добавлена обещанная поддержка MongoDB, примеры использования ее можно посмотреть в той же статье на сайте, полученный интерфейс ну очень похож на интерфейс доступа к MySQL, поэтому позволит попробовать MongoDB даже тем кто ни разу с ним не сталкивался. Но я остановлюсь на других возможностях:
##### Condition Placeholders
Всем нам знакомы разные строители запросов (query builders), которые позволяют добавлять условия вот так:
```
$query
->where('type', 'elf')
->orWhere(function($q){
$q
->_and('name', 'Trixie')
->_and('type', 'fairy')
});
// WHERE type = 'elf' OR (name = 'Trixie' and type = 'fairy')
```
Здесь ничего нового нет, но у них есть маленькая проблема: что делать если потом понадобится в тот OR ( ) добавить еще одно условие, уже в другом месте/классе? В PHPixie можно создать контрольную точку в которую потом добавлять условия, например:
```
$placeholder = null;
$query
->where('type', 'elf')
->orWhere(function($q){
$q
->_and('name', 'Trixie')
->_and('type', 'fairy');
$placeholder = $q->addPlaceholder('and');
});
$placeholder->_and('status', 'active');
// WHERE type = 'elf' OR (name = 'Trixie' and type = 'fairy' and status='active')
```
Для построение сложных запросов использование таких точек очень полезно.
##### Упрощенное добавление условий
Поскольку для SQL запросов кроме WHERE условий можно добавлять еще и HAVING и ON условия, то для каждого из них есть свой набор методов: orWhereNot, xorHaving… итд. Чтобы ускорить написание условий можно использовать сокращенные версии, которые будут добавлять условия последнего добавленного типа:
```
//Вместо
$query
->where('type', 'elf')
->orWhere('id', 5)
->having('count', 5)
->xorHaving('max', 6);
//Можно
$query
->where('type', 'elf')
->_or('id', 5)
->having('count', 5)
->_xor('max', 6);
```
##### Поддержка вложенных $or для MongoDB
[Известный баг](https://jira.mongodb.org/browse/SERVER-9180) что MongoDB не будет использовать индексы если вы напишете слишком сложный запрос используя вложенные $or. PHPixie сама исправит это для вас превратив такие запросы в развернутую форму, которая уже будет использовать индексы. Все это работает из коробки.
##### Особенные операторы для сравнения
Часто приходится сравнивать одну колонку с другой, проблема в том что если написать вот так:
```
$query
->where('amount','>', 'minAmount');
```
то на самом деле значение колонки amount будет сравниваться со стрингом «minAmount», для того чтобы указать что значение есть названием колонки в базе надо просто приставить звездочку к оператору:
```
$query
->where('amount','>*', 'minAmount');
```
Просто, понятно и лаконично.
##### Если вам интересно...
Чтобы увидеть как это все работает в действии [вот тут](http://phpixie.com/blog/new-phpixie-database-and-configuration-libraries/) приведен пример кода который работает с MongoDB и MySQL а также показывает как это все настроить без самого фреймворка всего в несколько строк кода. | https://habr.com/ru/post/216107/ | null | ru | null |
# Hi Programming Language
*Начиная с этой статьи мы приступаем к публикации концепта реализации нового языка программирования Hi.
Необходимость разработки нового языка, а не копирование синтаксиса любого из существующих распространенных языков программирования обусловлено своеобразным исходным концептом, о котором мы сегодня расскажем. По нашему мнению, процесс создания и реализации концепта нового языка сам по себе является увлекательной и познавательной историей для всех, кто интересуется прагматикой языков.
Мы предполагаем, что для понимания изложенного материала читателю знакомы синтаксис и семантика нескольких распространенных языков программирования общего назначения.*
> Don't bite my finger, look where I am pointing
>
> Warren S. McCulloch, 1960s
### Исходная постановка задачи
Первоначально мы ставили задачу реализации технологии автономной генерации интерактивных задач для развития интеллекта человека, которая будет адаптивна к его успехам и неудачам. То есть, если человек успешно решает последовательность головоломок и результативен в прохождении игр, то эта технология перестраивает свои алгоритмы так, чтобы человек мог решать головоломки с новыми, более сложными условиями и непредсказуемыми вариантами игр, которые никогда в точности не повторяются. В случае неудач эта технология возвращает человека на уже знакомые позиции для перестройки программы своих способностей и готовности осуществить новый интеллектуальный подъем. По своей сути адаптивная программа здесь выполняет ту же работу, которую делает опытный персональный тренер в спорте.
В целом, при некоторых ограничениях, эта задача была решена еще в 2018 году приложением **Helius' — full of life**, которое можно найти в [App Store](https://apps.apple.com/us/app/helius/id1338472119).
В процессе реализации концепта Helius’ мы осознали, что для того, чтобы сделать следующий шаг и реализовать принципиально новый класс адаптивного приложения, которое было бы способно полностью трансформировать свою архитектуру, адаптируясь к способностям человека, нам необходим встроенный алгоритмический скриптовый язык, листинг которого может быть одинаково успешно сгенерирован в текстовой форме как самим приложением, так и человеком или может быть изменен человеком или *другой программой* на основе представленного кода в качестве исходного прототипа.
Мы сформировали главные требования и быстро сделали вывод, что концепт, ориентированный на выражение креативных потребностей разработчика, не очень удачно моделируется каким-либо из распространенных языков, потому что наша цель с некоторой долей шутки — программирование людей, а не компьютеров.
Так как хорошо спроектированной интеллектуальной системе одинаково «удобно» сгенерировать синтаксис любого непротиворечивого языка в любой форме, то для того, чтобы использовать язык коммуникаций между «искусственным» и «естественным» интеллектом логично использовать традиционный алгоритмический код, сделав его максимально удобным для паттернов мышления человека, знакомого с мейнстримовыми языками, предком которых был Algol. Это потомки по линии Pascal (Ada, Modula) и C (C++, Java, Swift). Впрочем, наш концепт построения абстракций и внимательное отношение к скобкам близки к духу Scheme (Lisp), а интеграция команд программного окружения в выразительные средства языка соответствует идеям скриптовых языков, винтажному BASIC для первых микрокомпьютеров и проекту Oberon – системы Никлауса Вирта.
Наша исходная цель также включает предоставление простого и удобного алгоритмического языка для быстрого программирования интеллектуальных игр и головоломок со временем обучения начинающего разработчика в течение одного — двух часов. При этом мы принципиально оставили в стороне визуальное конструирование объектов приложений в духе Scratch или макетирование игр в редакторах сценариев и визуальных объектов. На наш взгляд это уводит в сторону от творчества и выражения собственных идей, потому что креативные усилия скорее заменяются кропотливым изучением и преобразованием [графических] объектов. Предлагаем в будущем предоставить эту работу в качестве обучения алгоритмам для интеллектуальных агентов.
В итоге сформулируем назначение языка как *обмен алгоритмами между искусственным и естественным интеллектом, совместное программирование задач (игр и головоломок) для себя и других, свободный обмен текстами программ.*
### Hi World
Перед тем, как мы обсудим основные тезисы для конструирования синтаксиса языка, представим три коротких фрагмента кода. Начнем с традиционной программы вывода приветственного сообщения:
```
PRINT “Hello world!”
```
Мы видим, что наш язык имеет скриптовый характер, предполагающий быструю интерпретацию; команда печати набрана в верхнем регистре и аргумент встроенной функции здесь не сопровождается скобками.
Представим два более интересных примера: нахождение для двух целых чисел наибольшего общего делителя в императивном стиле и с использованием рекурсии:
```
FUN gcd
INPUT a: INT
INPUT b: INT
WHILE a ~= b LOOP
IF a > b THEN a -= b ELSE b -= a ENDIF
REPEAT
PRINT “gcd = “, a
RETURN
FUN gcd _ a: INT, _ b: INT -> INT
IF b == 0 THEN RETURN a ENDIF
RETURN gcd b, (a % b)
PRINT gcd 6, 9
# печатает 3
```
### Требования для языка Hi
Каждый удачный язык проектируется с конкретным назначением, которое определяет его синтаксические особенности и семантику. Например, ASSEMBLER был предназначен для прямого кодирования команд процессора в мнемонической форме, удобной человеку; BASIC (тот который с номерами строк и оператором GOTO) — удачно продолжил идею прямой трансляции команд высокоуровневому интерпретатору. Hi programming language предназначен стать языком команд и алгоритмов для коммуникаций между Human и абстрактным интеллектом некоторой спроектированной системы.
Как логичное следствие, программным кодом считается не скомпилированный машинный код и не байт-код виртуальной машины, а *исходный текст* (листинг), включая комментарии. Соответственно, внутренняя реализация кода никоим образом не стандартизируется и оставляется на усмотрение реализации интерпретаторов или компиляторов.
Итак, наша главная цель – обмен мыслями при помощи формального языка. Введем три основных требования:
1. Язык должен быть легким в освоении человеком
2. Язык должен быть надежным в использовании
3. Язык должен быть способен к организации очень сложных программных систем.
Давайте подробнее исследуем эти базовые требования.
#### Язык должен быть легким в освоении
1) Мы будем использовать написание синтаксических конструкций с возможностью легкого прочтения, хорошо знакомое любому современному образованному человеку. Мы будем избегать экспериментов с краткостью в ущерб прочтению, как это сделано, например, в языке APL.
Следовательно, мы используем конструкции вида `LOOP…REPEAT`, а не `{…}`. Фигурные скобки в качестве приятного бонуса будем использовать вот так:
`s = {1, 2, 3}` у нас будет обозначать присвоение переменной s **множества** из трех целых чисел.
`a = [1, 2, 3]` у нас будет обозначать присвоение переменной a **массива** из трех целых чисел.
Использование продуманных кратких языковых конструкций также позволяет сделать более логичную связь семантики и синтаксиса языка без использования контекста окружения. Подробнее обсудим этот тезис позднее при рассмотрении конкретных языковых конструкций.
2) Для арифметических выражений используем запись вида: `a + b + c`, а не `(+ a b c)`, как в семействе LISP.
3) Природа нашего скриптового языка требует встроенной библиотеки всех необходимых функций в окружение языка без необходимости подключения внешних фреймворков.
4) Используем нативную алгоритмизацию паттернов мышления: императивный язык с возможностью рекурсивных функций и элементами функциональных вычислений. Как мы в дальнейшем рассмотрим на одном из примеров, императивный стиль вполне удобен и для программирования приложений, основанных на архитектуре обработки событий в декларативном ключе, подобных SwiftUI. Иначе говоря, термины «императивный» и «декларативный» скорее отображают позицию наблюдателя, чем реальность, данную нам в ощущение.
5) Следим за отсутствием избыточности синтаксических конструкций и эргономичностью ввода символов кода. Мы используем новую строку в качестве разделителя. Впрочем, как и в языке Swift, можно использовать «;» в одной строке в качестве разделителя для нескольких выражений. При этом наше инженерное образование категорически протестует против придания синтаксической значимости отступам в тексте программы, как это ранее использовалось в Fortran, а в настоящее время в Python.
#### Надежный язык
Необходимым условием существования сложных систем во времени является требование полной семантической однозначности и исполнимости каждой корректно написанной программы без исправлений при неизбежной эволюции и усложнении языка в будущем. Как решить эту проблему надежности работы программ при его неизбежном развитии и расширении? Для того, чтобы избежать конфликта совпадения идентификаторов и зарезервированных слов мы используем простой и эффективный способ, как сделано, например, в Oberon. Язык **HI** *резервирует все идентификаторы с буквами в верхнем регистре без цифр с количеством символов более одного как служебные*. Таким образом допустимыми идентификаторами, написанными вручную программистом или сгенерированными интеллектуальной системой, являются следующие примеры:
```
foo, Foo, f_001, F1, F, for
```
Примеры идентификаторов, которые зарезервированы языком:
```
FOO, FOR, HI, YES, EVERYRESTRICTIONMATTER
```
В целях надежности кода мы используем статическую типизацию с возможностью автоматического вывода типов из деклараций вида:
```
LET x = 6 # константа x имеет тип INT
VAR boolean = TRUE # объявление переменной boolean типа BOOL
```
Мы различаем константы и переменные не для оптимизации времени исполнения кода, а для того, чтобы разработчик хорошо понимал предназначение тех объектов, которыми он управляет.
#### Язык для построения очень сложных программных систем
Архитектура любого универсального языка должна предусматривать продуманную возможность построения сложных программ из небольших автономных кусочков, допустим до 250 LOC в одном источнике, ибо, да простит нас уважаемый Читатель, только сканеру и парсеру легко работать с исходными текстами любой сложности, а человеку даже перемножить пару трехзначных целых чисел тяжело без калькулятора.
Мы пока оставим в стороне реализацию архитектуры сложных систем на языке Hi и детально разберем эти вопросы в последующем при изложении концепции организации классов – протоколов, коммуникации между ними и способам построения их иерархии. Заметим только, что архитектура сложных приложений будет строиться из небольших автономных, легко читаемых и модифицируемых фрагментов и вдохновение здесь мы черпали не в изучении computer science, а в архитектуре взаимодействия клеток и органов живых организмов. Тело обыкновенного человека составляет порядка 50 триллионов жизнеспособных клеток, успешно функционирующих несмотря на сложные окружающие условия, наличие множества паразитов и постоянные повреждения миллионов микрокомпонентов. Создателю компьютерной системы, которая полностью прекращает свое функционирование вследствие единственного обращения к несуществующему индексу массива здесь есть чему поучиться.
Хотя мы начинаем с изложения скриптового языка, удобного для быстрого и приятного программирования небольших головоломок, мы должны дать полную уверенность разработчикам, что на платформе однажды разработанных простых программных компонентов без использования сторонних решений в будущем они смогут строить жизнеспособные системы неограниченной сложности.
#### Ограничения
На практике всегда, когда мы применяем какие – либо требования для конструирования систем, то чем-то приходится или жертвовать или на что-то не обращать внимания. Для нас в конструкции языка Hi не имеет принципиального значения:
* Точная совместимость синтаксиса с другими языками программирования
* Возможность использования существующих внешних библиотек кода или интеграция с другими программными системами
* Оптимизация скорости исполнения программ c ориентацией на аппаратные возможности и n-битную архитектуру компьютеров
* Сложность реализации интерпретаторов / компиляторов для полной версии языка
* Так как исполняемый интерпретатором программный код — это исходный текст, то не предусмотрено встроенной защиты от копирования и легкой модификации в случае наличия доступа к источнику
В завершение скажем о происхождения приветливого наименования языка программирования HI, Hi или hi. Допустим это будет **H**elius’ **i**nteractive Programming Language или **H**uman **I**ntelligence Programming Language. В отличие от всех конструкций нашего языка это единственный мета — идентификатор, который не имеет однозначной семантики.
*В следующей статье начнем поэтапное конструирование синтаксиса языка Hi включая грамматику в форме EBNF, следуя требованиям тезисов, представленных выше.* | https://habr.com/ru/post/519978/ | null | ru | null |
# Как Яндекс научил меня собеседовать программистов
После того, как я изложил свою историю «трудоустройства» в Яндекс [в комменте](/ru/post/470337/#comment_20719957) к нашумевшей заметке «Как я проработала 3 месяца в Я.Маркете и уволилась», было бы несправедливо утаить и ту пользу, которую я вынес из своего опыта Яндекс.Собеседования.
В мои рабочие обязанности входит техническое интервьюирование кандидатов на позицию Fullstack JavaScript/TypeScript Developer, активно этим делом (стоит ли говорить, что слегка поднадоевшим?) я занимаюсь больше года, за плечами более 30 технических интервью.
Раньше на техническом интервью я задавал кандидату довольно бестолковые вопросы аля «что такое замыкание», «как в JavaScript реализуется наследование», «вот есть такая-то таблица в БД с такими-то индексами, расскажите, пожалуйста, как можно ускорить такой-то запрос», которые хоть и помогали выявить инженерные способности кандидата, но совершенно не позволяли сделать вывод о том, насколько хорошо человек сможет решать задачи и насколько быстро он сможет разобраться в уже существующем коде. Что не могло не привести к печальным последствиям…
Но всё поменялось после того, как я прошёл четыре круга технических собеседований в Яндексе.
Обычно в огород интервьюеров Яндекса летят камни за:
1. Задачи, которые не имеют практической ценности;
2. Необходимость решать эти задачи на листках бумаги карандашом или на доске.
Уже 2019-й год и настала пора запускать в аду отдельную производственную линию по отливу котлов для тех, кто заставляет людей писать от руки текст, не говоря уже о коде. Каждый человек пишет по-разному, и мне, подготавливая текст к этой заметке, пришлось переписать, например, конкретно вот этот абзац шесть раз — если бы я писал заметки для Хабра на бумаге, я бы не писал заметки для Хабра.
Но вот с тезисом о практической бесполезности яндексовских заданий я не соглашусь. Даже рутинная разработка нет-нет, да поставит перед тобой задачу, у которой есть несколько решений. Над одним долго думать не нужно, но оно не является оптимальным ни по размеру кода, ни по производительности, ни по выразительности. Другое прямо противоположно, но требует от программиста некоторого опыта в построении эффективных и понятных алгоритмов. Вот пример с собеседования:
```
/* Необходимо реализовать функцию getRanges, которая возвращает следующие результаты: */
getRanges([0, 1, 2, 3, 4, 7, 8, 10]) // "0-4,7-8,10"
getRanges([4,7,10]) // "4,7,10"
getRanges([2, 3, 8, 9]) // "2-3,8-9"
```
На этой задаче я серьёзно затупил, и решил её не самым красивым образом. Решение, к сожалению, не сохранилось, поэтому я приведу решение одного из наших кандидатов:
```
function getRanges(arr: number[]) {
return arr.map((v, k) => {
if (v - 1 === arr[k - 1]) {
if (arr[k + 1] === v + 1) {
return ''
} else {
return `-${v},`
}
} else {
return v + ','
}
}).join('').split(',-').join('-')
}
```
Из минусов: обращение к массиву по несуществующему индексу и некрасивая манипуляция со строкой: join-split-join. А ещё это решение неправильное, потому что на примере getRanges([1, 2, 3, 5, 6, 8]) возвращается «1-3,5-6,8,», и чтобы «убить» запятую в конце, нужно ещё нарастить условия, усложнив логику и снизив читаемость.
Вот решение в духе Яндекса:
```
const getRanges = arr => arr
.reduceRight((r, e) => r.length ? (r[0][0] === e + 1 ? r[0].unshift(e) : r.unshift([e])) && r : [[e]], [])
.map(a => a.join('-')).join(',')
```
Поможет ли гугление писать такие элегантные решения? Чтобы выдать такой код, нужны две составляющие: опыт работы с множеством алгоритмов и отличное знание языка. И именно об этом предупреждают рекрутёры Яндекса: вас будут спрашивать об алгоритмах и языке. Яндекс предпочитает нанимать разрабов, способных писать крутой код. Такие прогеры эффективны, но, самое главное, взаимозаменяемы: они будут писать примерно одинаковые решения. Менее подкованные в теоретическом плане разработчики на одну задачу способны выдать десятки разнообразных, порой просто удивительных решений: один из кандидатов на нашу вакансию завернул такой костыль, что у меня глаза на лоб полезли.
**UPD:** как [заметил](https://habr.com/ru/post/470407/#comment_20726734) пользователь [MaxVetrov](https://habr.com/ru/users/maxvetrov/), моё решение неверное:
```
getRanges([1,2,3,4,6,7]) // 1-2-3-4,6-7
```
Таким образом, я сам не смог нормально решить эту задачу до сих пор.
**UPD2:** В целом, комментарии убедили меня, что этот код получился хреновым, даже если бы и работал правильно.
Я не зря потратил время, переводя бумагу в офисе Яндекса, потому что за этим занятием я понял, как самому стать эффективным интервьюером. Я взял за основу идею и формат их задач, но:
* Не предлагал писать код на бумаге, но просил писать в [code.yandex-team.ru](https://code.yandex-team.ru/). Это многопользовательский онлайн-редактор кода без возможности его выполнения. Возможно, есть и другой, более удобный вариант, но искать и было, и осталось лень;
* Не требовал идеального решения, но просил решить хоть как-то;
* Не требовал знания языка наизусть, нужную функцию или метод можно было спросить;
* Сократил время на техническое интервью до 30 минут.
Одна из задач нашего технического интервью:
```
let n = 0
while (++n < 5) {
setTimeout(() => console.log(n), 10 + n)
}
// Что будет выведено в консоль?
```
Я считаю, что для JavaScript-разработчика это очень показательный тест. И дело здесь не в замыкании и не в понимании отличий между преинкрементом и постинкрементом, а в том, что по какой-то необъяснимой причине четверть интервьюируемых полагает, что console.log выполнится раньше, чем завершится цикл. Я не преувеличиваю. У этих людей в резюме и опыт работы минимум два года, да и другие задачи, не завязанные на коллбеки, они успешно решали. То ли это новое поколение JavaScript-разработчиков, выросшее на async/await, которое ещё что-то слышало про Promise, но коллбеки для них — как дисковый телефон для современного подростка — номер наберёт, пусть не с первого раза, но так и не поймёт, как оно работает и зачем.
Эта задача имеет продолжение: нужно дописать код так, чтобы console.log так же выполнялся внутри setTimeout, но в консоль вывелись значения 1, 2, 3, 4. Тут уместна поговорка «век живи — век учись», так как однажды один из интервьюируемых предложил такое решение:
```
setTimeout(n => console.log(n), 10 + n, n)
```
И тут я узнал, что setTimeout и setInterval третий и последующие аргументы передают в коллбэк. Стыдно, да. Знание, кстати, оказалось полезным: я не раз использовал эту особенность.
А вот эту задачу я позаимствовал у Яндекса как есть:
```
/* Необходимо реализовать функцию fetchUrl, которая будет использоваться следующим образом. Внутри fetchUrl можно использовать условный метод fetch, который просто возвращает Promise с содержимым страницы или вызывает reject */
fetchUrl('https://google/com')
.then(...)
.catch(...) // сatch должен сработать только после 5 неудачных попыток получить содержимое страницы внутри fetchUrl
```
Тут проверяются навыки работы с Promise. Обычно я прошу решить эту задачу на чистых промисах, а затем с использованием async/await. С async/await решение интуитивно простое:
```
function async fetchUrl(url) {
for (let n = 0; n < 5; n++) {
try {
return await fetch(url)
} catch (err) { }
}
throw new Error('Fetch failed after 5 attempts')
}
```
К этому решению тоже можно применить поговорку «век живи — век учись», но уже относительно моего интервьюера из Яндекса: он не уточнил, что можно/нельзя использовать async/await, и когда я написал такое решение, он удивился: «я не работал с async/await, не думал что это можно решить так просто». Наверное, он ожидал увидеть что-то такое:
```
function fetchUrl(url, attempt = 5) {
return Promise.resolve()
.then(() => fetch(url))
.catch(() => attempt-- ? fetchUrl(url, attempt) : Promise.reject('Fetch failed after 5 attempts'))
}'error'
```
Этот пример способен показать насколько хорошо человек понимает промисы, это особенно важно на бэке. Однажды я видел код JavaScript разработчика, не разобравшегося до конца с промисами, подготовившего промис для транзакции sequelize следующим образом:
```
const transaction = Promise.resolve()
for (const user of users) {
transaction.then(() => {
return some_action...
})
}
```
И удивлявшийся, почему в его транзакции фигурирует только один пользователь. Можно было бы использовать Promise.all, ну а можно было знать, что Promise.prototype.then не добавляет ещё один коллбэк, а создаёт новый промис и правильно будет так:
```
let transaction = Promise.resolve()
for (const user of users) {
transaction = transaction.then(() => {
await perform_some_operation...
return some_action...
})
}
```
Этот случай заставил меня задуматься над тем, чтобы усложнить задачу на понимание промисов, но сформулировать новое задание мне помог кандидат, который отказался решать задачи, назвал их буквально хренью и сказал, что он привык работать с реальным кодом, на что я, покопавшись пару минут в исходниках одного из наших проектов, дал ему реальный код:
```
public async addTicket(data: IAddTicketData): Promise {
const user = data.fromEmail ? await this.getUserByEmail(data.fromEmail) : undefined
let category = data.category
if (category === 'INCIDENT' && await this.isCategorizableType(data.type)) {
category = 'INC\_RFC'
}
const xml = await this.twig.render('Assyst/Views/add.twig', {
from: data.fromEmail,
text: data.text,
category,
user,
})
const response = await this.query('events', 'post', xml)
return new Promise((resolve, reject) => {
xml2js.parseString(response, (err, result) => {
if (err) {
return reject(new Error(err.message))
}
if (result.exception) {
return reject(new Error(result.exception.message))
}
resolve(result.event.id - 5000000)
})
})
}
```
И попросил избавиться от ключевых слов async/await. С тех пор это задание стало первым и, в половине случаев, последним на собеседовании — его реально часто заваливают.
Сам я ни разу не решал эту задачу до написания этой заметки и делаю это ~~в первый~~ в третий раз ([первый](https://habrastorage.org/webt/cu/uw/v7/cuuwv7hr2eqqdi866oxjt9huodw.gif) слишком долгий, а во [втором](https://habrastorage.org/webt/rb/90/ez/rb90ezupkm7jgfy6fffooq_bh_i.gif) я не заметил один оставшийся await):
Какой вывод из этого всего можно сделать? Собеседования — это интересно и полезно… Разумеется, если вы в срочном порядке не ищeте работу.
Напоследок приведу ещё одну задачу из истории с Яндексом, я её ещё никому\* почти не показывал, берёг, что называется, для особого случая. Есть набор баннеров, у каждого баннера есть «вес», который указывает на то, с какой частотой будет отображаться баннер относительно других баннеров:
```
const banners = [
{ name: 'banner 1', weight: 1 },
{ name: 'banner 2', weight: 1 },
{ name: 'banner 3', weight: 1 },
{ name: 'banner 4', weight: 1 },
{ name: 'banner 5', weight: 3 },
{ name: 'banner 6', weight: 2 },
{ name: 'banner 7', weight: 2 },
{ name: 'banner 8', weight: 2 },
{ name: 'banner 9', weight: 4 },
{ name: 'banner 10', weight: 1 },
]
```
Например, если есть три баннера с весами 1, 1, 2, их совокупный вес равен 4, а вес третьего равен 2/4 от общего веса, значит и отображаться он должен в 50% случаев. Необходимо реализовать функцию getBanner, которая рандомно, но с учётом весов, возвращает один баннер для показа. Решение можно проверить [в этом сниппете](https://codepen.io/shibaon/pen/QWWwVwY), там же выводится ожидаемое и фактическое распределение.
**UPD:** мне начали не только минусить саму статью, но и семимильными шагами жечь карму и я сперепугу скрыл материал, что некрасиво по отношению к комментаторам. Исправляю этот мудачизм с моей стороны. | https://habr.com/ru/post/470407/ | null | ru | null |
# Настройка Single Sign-On в Zimbra Collaboration Suite 9 Open-Source Edition
Одной из важных технологий для обеспечения удобства и безопасности работы пользователей во внутренней сети предприятия является технология Single Sign-On. Данная технология позволяет сотрудникам проходить процедуру аутентификации всего один раз и после успешного ее завершения, получать доступ ко всем корпоративным ресурсам автоматически. В том случае, если вы используете Zimbra Collaboration Suite, то можете настроить SSO в ней. В данной статье мы расскажем о том, как это сделать.
В данной статье подразумевается, что вы используете для аутентификации пользователей Active Directory, Single Sign-On осуществляется при помощи Kerberos, а пользователи в Zimbra OSE соответствуют тем, что заведены в AD. Напомним, что ранее мы уже писали о том, как настроить автоматическое создание пользователей в Zimbra OSE из AD.
Исходные данные: Сервер с Zimbra 9 расположен на домене madegirah.ru, на нем используется тип аутентификации AD. Сервер с AD находится по адресу MADEGIRAH.LOCAL.
Принцип настройки SSO в таком случае будет довольно прост. В рамках него мы:
1. Создадим специального пользователя, так называемого «билетера», который будет выдавать пользователям билеты для аутентификации
2. Создадим Keytab-файл в Kerberos
3. Настроим утилиту SPNEGO и сам сервер Zimbra OSE на работу с Kerberos
4. Настроим браузеры и почтовые клиенты на работу с SSO.
Обращаем ваше внимание на то, что необходимо создавать резервные копии всех файлов при внесении в них каких-либо изменений.
В первую очередь нам потребуется создать в AD новую учетную запись zimbra и запретить ей смену пароля.
После этого на контроллере домена создадим для неё ряд SPN-записей. В нашем случае это будут принципалы для протоколов http, pop, imap и smtp. Для их добавления в учетную запись zimbra нужно поочередно выполнить команды
* setspn -S HTTP/madegirah.ru zimbra
* setspn -S POP/madegirah.ru zimbra
* setspn -S IMAP/madegirah.ru zimbra
* setspn -S SMTP/madegirah.ru zimbra
После этого проверим, что пользователю были добавлены все необходимые принципалы при помощи команды setspn –L zimbra.
После этого создаем на контроллере домена папку C:\keys, в которую будем складывать сгенерированные с помощью Kerberos keytab-файлы. Сгенерируем наш первый keytab при помощт данной команды:
**ktpass -out c:\keys\jetty.keytab -princ HTTP/madegirah.ru@MADEGIRAH.LOCAL -mapUser zimbra -mapOp set -pass \*\*\*\*\*\*\*\* -crypto RC4-HMAC-NT -pType KRB5\_NT\_PRINCIPAL**
Создастся keytab с одним принципалом. Теперь нам необходимо добавить в него еще 3 принципала. Делается это при помощи следующих команд,:
1. ktpass -princ IMAP/madegirah.ru@MADEGIRAH.LOCAL -mapuser zimbra -pass \*\*\*\*\*\*\*\* -crypto All -ptype KRB5\_NT\_PRINCIPAL -in c:\keys\jetty.keytab -out c:\keys\jetty.new.keytab
2. ktpass -princ POP/madegirah.ru@MADEGIRAH.LOCAL -mapuser zimbra -pass \*\*\*\*\*\*\*\* -crypto All -ptype KRB5\_NT\_PRINCIPAL -in c:\keys\jetty.new.keytab -out c:\keys\jetty.new1.keytab
3. ktpass -princ SMTP/madegirah.ru@MADEGIRAH.LOCAL -mapuser zimbra -pass \*\*\*\*\*\*\*\* -crypto All -ptype KRB5\_NT\_PRINCIPAL -in c:\keys\jetty.new1.keytab -out c:\keys\jetty.new2.keytab
В итоге файл c:\keys\jetty.new2.keytab будет содержать все необходимые принципалы. Удалим все полученные в ходе выполнения инструкции keytab-файлы, кроме jetty.new2.keytab. Его мы переименуем в jetty.keytab и скопируем на сервер с Zimbra OSE 9 в папки /opt/zimbra/data/mailboxd/spnego/ и /opt/zimbra/jetty/. Сменим права доступа к keytab-файлу с помощью команд
**chown zimbra:zimbra /opt/zimbra/data/mailboxd/spnego/jetty.keytab
chown zimbra:zimbra /opt/zimbra/jetty/jetty.keytab**
Теперь приступим к настройке встроенной в Zimbra Collaboration Suite утилиты SPNEGO, которая и будет работать с созданным ранее .keytab-файлом. Настроить SPNEGO можно при помощи следующих команд:
**sudo su — zimbra
zmprov mcf zimbraSpnegoAuthEnabled TRUE
zmprov mcf zimbraSpnegoAuthRealm MADEGIRAH.LOCAL
zmprov ms madegirah.ru zimbraSpnegoAuthTargetName HTTP/madegirah.ru
zmprov ms madegirah.ru zimbraSpnegoAuthPrincipal HTTP/madegirah.ru
zmprov ms madegirah.ru zimbraImapSaslGssapiEnabled TRUE
zmprov ms madegirah.ru zimbraPop3SaslGssapiEnabled TRUE
zmprov md madegirah.ru zimbraAuthKerberos5Realm MADEGIRAH.LOCAL
zmprov md madegirah.ru zimbraWebClientLoginURL '/service/spnego'
zmprov md madegirah.ru zimbraWebClientLogoutURL '../?sso=1'**
Обращаем ваше внимание на то, что настойка SPNEGO является глобальной, а это значит, что все домены на вашем сервере Zimbra должны использовать для аутентификации одну и ту же Active Directory.
Следующим шагом станет приведение файла настроек /opt/zimbra/jetty/etc/krb5.ini в следующий вид:
> [libdefaults]
>
> default\_realm = MADEGIRAH.local
>
> dns\_lookup\_realm = no
>
> dns\_lookup\_kdc = no
>
> kdc\_timesync = 1
>
> ticket\_lifetime = 24h
>
>
>
> default\_keytab\_name = FILE:/opt/zimbra/data/mailboxd/spnego/jetty.keytab
>
> default\_tgs\_enctypes = arcfour-rc4-md5 rc4-hmac des-cbc-crc des-cbc-md5
>
> default\_tkt\_enctypes = arcfour-rc4-md5 rc4-hmac des-cbc-crc des-cbc-md5
>
> permitted\_enctypes = arcfour-rc4-md5 rc4-hmac des-cbc-crc des-cbc-md5
>
>
>
> [realms]
>
> MADEGIRAH.local = {
>
> kdc = DC.MADEGIRAH.LOCAL
>
> admin\_server = DC.MADEGIRAH.LOCAL
>
> default\_domain = MADEGIRAH.LOCAL
>
> }
>
>
>
> [domain\_realm]
>
> madegirah.local = MADEGIRAH.LOCAL
>
> .madegirah.local = MADEGIRAH.LOCAL
>
> .local = MADEGIRAH.LOCAL
>
>
>
> [appdefaults]
>
> autologin = true
>
> forwardable=true
На этом настройка серверной части завершается и остается лишь внести некоторые изменения в настройки на стороне пользователя. В частности, необходимо настроить браузеры на работу с SPNEGO. В случае с Firefox нужно ввести в адресную строку about:config и в поле поиска ввести network.neg. В отобразившихся полях, содержащих слово uris в названии указать значение madegirah.ru, либо `https://`.
В случае с Internet Explorer нужно добавить в местную интрасеть [madegirah.ru](https://madegirah.ru). Также это можно сделать через групповые политики. Google Chrome же подхватывает настройки Internet Explorer.
Для SSO-аутентификации в почтовом клиенте Thunderbird необходимо при настройке учетной записи указать тип аутентификации GSSAPI. Именно для того, чтобы это работало, мы ранее добавляли принципалы для IMAP, POP и SMTP. Обращаем ваше внимание, что Outlook подобного вида аутентификации при использовании POP/IMAP и SMTP не поддерживает ввиду ограничений клиента.
Еще одним неприятным нюансом может стать предупреждение о небезопасной странице при использовании в Zimbra OSE самоподписанного сертификата. Этот нюанс не является критичным, однако регулярно появляющееся предупреждение противоречит самому принципу удобства технологии Single Sign-On. Для того, чтобы его убрать, необходимо установить сертификат Zimbra OSE на целевой машине.
Для того, чтобы это сделать, необходимо на сервере Zimbra следующие команды:
**sudo su
cd /opt/zimbra/ssl/zimbra/ca
openssl x509 -in ca.pem -outform DER -out ~/zimbra.cer**
После этого полученный сертификат необходимо перенести на целевую машину и дважды кликнуть по нему мышкой. В открывшемся окне нужно выбрать «Установить сертификат» и импортировать его в Мастере импорта сертификатов. Единственный нюанс при его установке, что при выборе хранилища для сертификата необходимо поместить его в хранилище «Доверенные корневые центры сертификации». Кроме того, можно установить данный сертификат через групповые политики.
После того, как данный сертификат будет указан в качестве доверенного, предупреждение при входе в веб-клиент Zimbra OSE и при использовании Thunderbird перестанет появляться.
По всем вопросам, связанными c Zextras Suite Pro и Team Pro вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/533328/ | null | ru | null |
# Symfony 4: Тестируем плагин Symfony Flex
Несколько месяцев назад вышла альфа версия Composer плагина [Symfony Flex](https://github.com/symfony/flex). С выпуском Symfony 3.3 стало возможным протестировать работу данного плагина и «попробовать на вкус» подход к построению приложений на Symfony 4. Что мы сейчас и попробуем сделать.
В [предыдущем посте](https://habrahabr.ru/post/331516/) я писал про структуру приложения Symfony 4 и некоторых особенностях, поэтому сейчас заострять внимание на этом не буду. Для того, чтобы процесс установки прошел гладко, рекомендую пользователям Windows использовать GitBash или Cygwin терминал. Вообще-то вы можете использовать любой терминал, главное чтобы в окружении была доступна утилита make и установленные linux-tools. Так же вам понадобится PHP версии ^7.1.3
### Symfony Flex
Несколько слов о самом плагине. Symfony Flex берет на себя заботу по настройке компонент, устанавливаемых в ваше приложение с помощью Composer. Это не обязательно должны быть компоненты Symfony. Плагин работает с рецептами. Если рецепт для пакета определен в репозитории, то Symfony Flex сделает свою работу, в противном случае вам придется как и раньше настроить все руками.
На данный момент существует два репозитория рецептов, [главный (или официальный)](https://github.com/symfony/recipes) и [публичный](https://github.com/symfony/recipes-contrib). Главный репозиторий отличается тем, что может определять алиасы для пакетов и размещение рецепта в этот репозиторий должно быть одобрено core-team Symfony. В публичном репозитории более мягкие правила для размещения.
### Установка плагина
Первым делом установим Symfony Flex:
```
composer require symfony/flex
```
С этого момента плагин контролирует процесс установки пакетов в ваше приложение. Чтобы получить простое «Hello World» приложение установим symfony/framework-bundle. Мы уже можем воспользоваться «магией» Symfony Flex плагина и использовать удобный алиас для этого:
```
composer req frameworkbundle
```
Теперь давайте посмотрим на структуру каталогов:
```
/etc
/src
/vendor
/web
.env
.env.dist
.gitignore
composer.json
composer.lock
Makefile
```
В каталоге /etc, теперь находится вся конфигурация и файл bundles.php, который содержит массив всех бандлов установленных в вашем проекте. Этот файл модифицируется плагином Symfony Flex, каждый раз когда вы устанавливаете или удаляете бандл. Если вы хотите использовать локальный бандл, вам придется самостоятельно прописать его в этот файл.
Для конфигурации контейнера предусмотрен файл container.yaml, для роутинга routing.yaml. Так же в /etc вы увидите каталог packages, в котором хранятся минимальные конфигурации по умолчанию для всех компонентов. По сути эти конфигурации копируются из рецептов.
В каталоге /src, располагается класс Kernel, переработанный под новую структуру каталогов. Так же здесь есть пустой каталог Controller.
В папке /web теперь только index.php для всех видов окружения. Если посмотреть содержимое этого файла, можно заметить, что для имитации присутствия переменных окружения используется компонент symfony/dotenv. Этот компонент поставляется по умолчанию с symfony 3.3. В режиме разработки он позволяет определять переменные окружения в файле .env
Давайте установим этот компонент:
```
composer req symfony/dotenv
```
Теоретически мы установили минимальный набор компонентов необходимых для запуска приложения. Но есть один нюанс. По умолчанию рецепты поставляются с конфигурацией в YAML. И поэтому даже если собственные конфигурации вы хотите писать в другом формате, вам все равно придется установить компонент symfony/yaml, чтобы конфигурации всех компонентов могли быть загружены. В противном случае вам придется переписывать все конфиги в каталоге /etc/packages в нужный вам формат каждый раз когда вы добавляете новый компонент.
Давайте установим symfony/yaml:
```
composer req symfony/yaml
```
Почти все готово. Осталось немного «поколдовать» над файлом composer.json. Первое, что нужно сделать это прописать секцию psr-4, для автозагрузки наших классов. Так как весь код у нас лежит теперь прямо в /src, добавим:
```
{
"autoload": {
"psr-4": {
"App\\": "src/"
}
}
}
```
Обратите внимание на следующую секцию в composer.json:
```
{
"scripts": {
"auto-scripts": {
"make cache-warmup": "script",
"assets:install --symlink --relative %WEB_DIR%": "symfony-cmd"
}
}
}
```
В эту секцию плагин Symfony Flex, добавляет необходимые вызовы команд для каждого компонента. Данные вызовы прописаны в рецептах. При текущей конфигурации, секция «auto-scripts» не будет исполнена плагином. Для того, чтобы это исправить нужно добавить вот такие параметры:
```
"post-install-cmd": [
"@auto-scripts"
],
"post-update-cmd": [
"@auto-scripts"
]
```
Этот шаблон позволяет плагину Symfony Flex включиться в процесс при наступлении событий «post-install» и «post-update» композера.
**Финальный вид composer.json**
```
{
"require": {
"symfony/flex": "^1.0",
"symfony/framework-bundle": "^3.3",
"symfony/dotenv": "^3.3",
"symfony/yaml": "^3.3"
},
"autoload": {
"psr-4": {
"App\\": "src/"
}
},
"scripts": {
"auto-scripts": {
"make cache-warmup": "script",
"assets:install --symlink --relative %WEB_DIR%": "symfony-cmd"
},
"post-install-cmd": [
"@auto-scripts"
],
"post-update-cmd": [
"@auto-scripts"
]
}
}
```
Теперь попросим Composer пересобрать класс автозагрузки:
```
composer dump-autoload
```
Самое время добавить контроллер. Создадим в папке /src/Controller класс TestController:
```
namespace App\Controller;
use Symfony\Component\HttpFoundation\Response;
class TestController
{
public function test()
{
return new Response('It works!');
}
}
```
Теперь нужно прописать маршрут в файле /etc/routing.yaml:
```
index:
path: /
defaults: {_controller: 'App\Controller\TestController::test'}
```
Запускаем веб-сервер с помощью make:
```
make serve
```
Переходим в браузере по 127.0.0.1:8000 и видим наше сообщение «It works!».
Минимальное приложение собрано и запущено, но хочется использовать аннотации для определения маршрутов. Без проблем! Для этого нам потребуется sensio/framework-extra-bundle и symfony/annotations-pack, для последнего предусмотрен удобный алиас annot.
```
composer req sensio/framework-extra-bundle
composer req annot
```
Теперь закомментируем маршрут в файле routing.yaml, который определили до этого и вместо него укажем где лежат наши классы контроллеров для парсера аннотаций:
```
controllers:
resource: ../src/Controller/
type: annotation
```
Изменим наш контроллер, добавив аннотацию для маршрута (не забудьте так же добавить use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route):
```
namespace App\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Component\HttpFoundation\Response;
class TestController
{
/**
* @return Response
* @Route("/test", name="test")
*/
public function test()
{
return new Response('It works!');
}
}
```
Переходим по 127.0.0.1:8000/test и видим наше сообщение. Если нам больше не нужно использовать аннотации, то мы можем удалить компоненты:
```
composer rem annot
composer rem sensio/framework-extra-bundle
```
Останется только вернуть настройки роутинга в routing.yaml, и все будет работать. Плагин Symfony Flex позаботится о том, чтобы удалить за собой весь мусор, а так же убрать из конфигурации бандл sensio/framework-extra-bundle.
Вот таким образом можно уже сейчас экспериментировать с приложениями в стиле Symfony 4.
По правде говоря, вы можете воспользоваться уже готовым composer.json файлом для установки такого приложения «из коробки»:
```
composer create-project "symfony/skeleton:^3.3" demo
```
Я описал процесс ручной сборки проекта, чтобы акцентировать внимание на некоторых деталях.
Исходники проекта можно посмотреть [тут](https://github.com/shude/flextest).
Спасибо за внимание. | https://habr.com/ru/post/331526/ | null | ru | null |
# Динамическое программирование в олимпиадных задачах
Привет!
Недавно решал задачи с архива [Timus Online Judge](http://acm.timus.ru/) и наткнулся на раздел под названием *задачи динамического программирования*. Задачи такого типа вызывают у меня особый интерес, потому что зачастую такой подход обеспечивает быстроту и элегантность решения. Что же такое — динамическое программирование?
Динамическое программирование — это подход к решению задач, при котором происходит разбиение на подзадачи, которые «проще» в сравнении с исходной. Слово «динамический» близко по значению к «индуктивный»: предполагается, что известен ответ для какого-то значения , и хочется найти ответ для . В математике это называется индуктивным переходом, и составляет основную идею динамического программирования.
Простые примеры
---------------
Наиболее яркой и показательной задачей является задача вычисления -ого числа последовательности Фибоначчи. Известно, что последовательность обладает такими свойствами:
Отсюда сразу вытекает рекуррентная формула:
```
int Fibonacci(int n) {
if(n == 1 || n == 2) return 1;
return Fibonacci(n-1) + Fibonacci(n-2);
}
```
Если рекурсия ищет число «с конца», то следущий метод последовательно вычисляет все числа, расположенные между  и :
```
int dpFibonacci(int n) {
int prev1 = 1;
int prev2 = 1;
int curr = 0;
for(int j = 2; j < n; j++) {
curr = prev1 + prev2;
prev1 = prev2;
prev2 = curr;
}
return curr;
}
```
Понятно, что при достаточно больших  этот алгоритм работает намного быстрее: он не вычисляет промежуточные значения по нескольку раз. Рассмотрим чуть более сложный пример.
**Пример 1.** Вы шагаете по платной лестнице. Чтобы наступить на -ую ступеньку, необходимо заплатить  монет. Вы можете перешагивать на следующую ступень или перепрыгивать через одну. Задача: пройти  ступенек и потратить как можно меньше монет.
Понятно, что перешагивая через каждую ступень, мы минимизурем количество «платежей», но можем нарваться на очень дорогую ступень, которую хотелось бы избежать. Создадим массив значений , в котором на -ом месте будет (минимальное) число монет, которые необходимо потратить, чтобы добраться до -ой ступеньки. Сразу ясно, что . А дальше будем брать минимум из двух предыдущих ступенек и добавлять стоимость самой ступеньки: 
Немного изменим условия задачи: предположим, что на каких-то ступеньках вы можете получать монеты (это будет означать, что ). Что необходимо изменить в алгоритме, чтобы он давал правильный результат?
**Решение**Нужно изменить только «начало» нашей динамики. Если первая лестница не приносит нам монет, то желательно перепрыгнуть через нее, однако, если , то лучше наступить и собрать свои монетки. Итак, .
Рассмотрим другой пример, в котором используется «двумерная» динамика.
**Пример 2.** В лабиринте имеется  комнат, в каждой из которых находится золото (в клетке  лежит  золота). Задача — определить, какое максимальное количество золота можно собрать при оптимальном маршруте из точки  в точку , если идти можно либо вниз, либо направо.
Итак, мы хотим узнать оптимальный маршрут в клетку . Сюда мы можем попасть из двух клеток —  и . С учетом того, что оптимальные маршруты для этих двух клеток известны (они хранятся в какой-то таблице ), то ответ для клетки  получается следующим образом:
Эта еще одна классическая задача динамического программирования, модификации которой довольно часто встречаются в задачах спортивного программирования. Более подробно аналогичная задача объясняется [здесь](https://habr.com/post/113108/).
Более сложные задачи
--------------------
При желании динамический подход можно прикрутить куда вздумается. Рассмотрим [задачу](http://acm.timus.ru/problem.aspx?space=1&num=1073) с архива Timus Online Judge.
Математическая формулировка задачи такая: требуется найти минимальное количество слагаемых, необходимых для разложения заданного числа на полные квадраты.
Как и раньше, предположим, что нам известны ответы для всех чисел , которые хранятся в каком-нибудь массиве , и нам бы хотелось найти .
Возьмем это число  и проанализируем, какие могут быть ситуации:
1.  является полным квадратом. В этом случае .
2. Возможно, предыдущее число  было полным квадратом. Тогда .
Вообще, вариант прибавления единицы к предыдущему кажется не таким уж плохим.
Поступим следующим образом: будем искать разложение  такое, что 
Так как  — полный квадрат, то , и 
то есть мы нашли разбиение, которое просто-напросто лучше, чем , и ответ в этом случае будет 
**Пример кода на Java, реализующий данный алгоритм:**
```
for(int k = 1; k <= n; k++) {
int best = d[k - 1] + 1; // принимаем этот вариант за наилучший
int q = 1;
while(k - q*q >= 0) { // k = q*q + s
if(k - q*q == 0) { // k - полный квадрат
best = 1;
break;
} else if(d[k - q*q] < best) best = d[k - q*q] + 1;
q++;
}
d[k] = best;
}
```
Рассмотрим следующую [задачу](http://acm.timus.ru/problem.aspx?space=1&num=1017). Цель — построить лестницу из  кубиков по правилам:
1. лестница имеет минимум две ступени;
2. лестница не может иметь две одинаковые ступени;
3. ступени лестницы идут в порядке возрастания (то есть следующая больше, чем предыдущая).
На этот раз будем строить двумерную динамику. Создадим табицу , в которой на позиции  будет лежать количество лестниц, состоящих из  кубиков, высота которых не превосходит . Если получится, то ответом к нашей задаче будет сумма 
Итак, будем решать задачу по нахождению количества лестниц, составленных из  кубиков, которые имеют высоту . На картинке показаны лестницы, которые попадут в :
Поскольку нам известны все лестницы, которые состоят из меньшего количества кубиков, то «отщепим» от лестницы  правый столбик. В результате получится лестница c  кубиками. Пример для :
Но для таких лестниц результат уже известен, поэтому переберем все такие лестницы циклом по  и сложим все результаты. Таким образом, 
Теперь будем перебирать высоты лестниц: 
Окончательно, изменяя  от  до , получим ответ.
**Важно**: в процессе построения нашей матрицы необходимо учитывать , так как в противном случае будут «теряться» некоторые виды лестниц (при «отщеплении»), но разумеется, что такая лестница не удовлетворяет условиям задачи, поэтому в ответе будет число .
**Пример кода на Java, реализующий данный алгоритм:**
```
dp = new long[n + 1][n+1];
d[1][1] = 1;
d[2][1] = 0;
d[2][2] = 1;
for(int i = 3; i < n + 1; i++) {
for(int j = 2; j
```
Следующая [задача](http://acm.timus.ru/problem.aspx?space=1&num=1537) решается с использованием одномерного массива.
Итак, что мы имеем. Первый энт знает 2 слова. Каждый энт обучает всем словам, которые знает сам, двух энтов: молодого и старого. В свою очередь, молодого обучили еще стольким же словам, сколько он уже знает, а старого обучили только одному слову. Необходимо узнать, сколько энтов знает в точности  слов (необходимо вывести число этих энтов по модулю ).
Решение довольно простое. Создадим массив , в котором на -ом месте будем хранить количество энтов (по модулю ), которые знают  слов. Все начинается с первого энта, который знает два слова, поэтому . А дальше все просто:
* Все энты, которые знают нечетное количество слов, являются старыми и могли научиться только от предыдущих. Поэтому для нечетных 
* Что касается энтов, которые знают четное количество слов — так это все те, кто получил столько же слов от эльфов (молодые)  те, кто научился от предыдущих (старые); то есть для четного  имеем .
Осталось разобраться с вычислением по модулю. Для того, чтобы не хранить огромные числа, будем сразу запоминать все значения по модулю.
**Пример кода на Java, реализующий данный алгоритм:**
```
int[] d = new int[K + 1];
if(K >= 2) d[2] = 1;
if(P != 1) {
for(int i = 3; i <= K; i++) {
if(i % 2 != 0) {
d[i] = d[i - 1];
}
else {
d[i] = ((d[i/2] % P) + d[i - 1] % P) % P;
}
}
} else d[K] = 0;
```
Используемые ресурсы:
1. [Timus Online Judge;](http://acm.timus.ru/)
2. [Немного](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) о динамическом программировании;
3. [Свойства](https://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%BE_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8E#%D0%A1%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0_%D1%81%D1%80%D0%B0%D0%B2%D0%BD%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8_%D0%BF%D0%BE_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8E) сравнения по модулю. | https://habr.com/ru/post/418867/ | null | ru | null |
# Хостинг FastVPS.ru или почему OpenVZ Это зло
Пару лет назад мы с товарищем купили виртуальный сервер на двоих у компании FastVPS.ru. Сервер был отличный, и нас очень радовал низкой стоимостью и большим функционалом. Вдумайтесь, на сервере был поднят bind для всех наших доменов, 8 сайтов, пара баз данных для них, ftp сервер, postfix, trac и xml rpc сервер на питоне. И все это отлично работало пока… пока ребята из FastVPS не перешли на новую мега-технологию виртуализации OpenVZ.
Первое что нам пришлось сделать, это перенести все сайты и базы, настройки и прочее на новый сервак, потому как сквозного переноса сделать было нельзя. Честно сказать, в администрировании я не особо силен, поэтому на это ушла неделя. Пока вкурили HOW-TO и best practice по debian, пока забекапили все, в общем, пришлось повозиться со всем этим хозяйством.
И вот настал долгожданный момент Х, когда осталось лишь нажать Enter и снова увидеть родные до боли страницы сайтов. Сайты загрузились, и мы было уже откупорили непочатую пачку с соком (великий пост все таки). Однако нашу радость прервало странное сообщение в ssh консоли сервера:
`Cannot allocate memory: fork: Unable to fork new process` (которое не давало мне спать еще несколько недель). С этого момента никакие программы запустить не удавалось. И если бы не знание некоторых особенностей линукса, сервер совсем бы вышел из-под контроля.
Товарищ мой, который, надо сказать, с unix и linux давно знаком (и знал, что kill – это не процесс, и потому не выделяет памяти, а значит работает по-любому) с миной сильнейшего удивления на лице выговорил только одну фразу — «этого не может быть». Как оказалось впоследствии, на обычных, пусть даже очень древних, компьютерах системные ресурсы в linux не кончаются. Но тут был другой случай.
После часа непрерывного гугления в четыре руки и просмотра выдачи top, ps, free, apache2ctl fullstatus, а так же анализа логов, стало ясно — процессы апача (который раньше работал на 192 Мб RAM), сожрали всю память на новой системе с 400 Мб RAM (мы решили, что небольшой апгрейд не помешает). Сделали тюнинг потребления памяти mysql, тюнинг памяти и prefork apache2 и php, и, показалось, система задышала. Но какой же нормальный сайт обходится без атак со стороны юных длиннопальцых прыщавых хакеров. Apache2 начал регулярно падать, даже при очень низких параметрах префорка процессов (что удалось выяснить впоследствии, благодаря наблюдениям за сайтами в течении нескольких недель).
Параметры ДО переезда (192 Мб RAM):
`Timeout 300
KeepAlive On
MaxKeepAliveRequests 100
KeepAliveTimeout 15
< IfModule mpm_prefork_module >
StartServers 5
MinSpareServers 5
MaxSpareServers 10
MaxClients 150
MaxRequestsPerChild 0`
В конце концов, мы поняли, в чем дело. У новой системы не было swap файла. Обратились в саппорт, но поддержка свелась к «Поставьте nginx, вас атакуют. А swap раздел создать невозможно» (здесь под словом «атака» я имею ввиду подбор паролей, поиск уязвимостей, прощупывание сканнером и т.д. Но не DDoS атаку). Снова погуглили, и, действительно, OpenVZ не может эмулировать swap в системе linux. Но мало того, ресурсы OpenVZ распределяет динамически, а значит, память у нашего сервера в любой момент могут отъесть другие сервера, в результате чего apache2 падает без предупреждения. Мы вначале даже не поверили в это, увеличив тарифный план на хостинге до 600 Мб. Но это абсолютно никак не изменило ситуации, веб сервер как падал, так и падает на более или менее разумных параметрах префорка.
Параметры после (на которых не падает апач) 600 Мб RAM:
`Timeout 90
KeepAlive On
MaxKeepAliveRequests 50
KeepAliveTimeout 3
< IfModule mpm_prefork_module >
StartServers 1
MinSpareServers 1
MaxSpareServers 1
MaxClients 2
MaxRequestsPerChild 300`
Может мы действительно чего-то не понимаем, и надо было еще погемороиться с nginx? Но, мне кажется, что OpenVZ — это классический пример, когда продукт разрабатывается не для конечных пользователей, а для продавцов услуги. Так что виртуальные хостинги OpenVZ теперь никому не рекомендую, и ищу разумные заменители. Коллеги – буду рад, если Вы мне посоветуете, как больше не иметь проблем с хостингом.
**UPD:** *В результате выяснилось, что на момент публикации поста прошло 12 часов, как ошибка была найдена и устранена. Поэтому сейчас даже без nginx на OpenVZ все работает нормально. К FastVPS.ru претензий больше не имею, ниже можно увидеть комментарий компании.* | https://habr.com/ru/post/89851/ | null | ru | null |
# 3\. Частотные характеристики. 3.10 Минимально-фазовые и не минимально-фазовые звенья
Рассмотренные ранее типовые звенья имели передаточные функции, которые можно представить в виде:
 где  и - многочлены (1 или 2-го) порядка с коэффициентами равными 1 при младших членах. Пусть все коэффициенты знаменателя - **обязательно положительны**, т.е. .
Рассмотрим полюса передаточных функции, значения при которых .
Поскольку мы рассматривали свойства звеньев, порядок которых не выше 2-го, то полюса лежат в левой полуплоскости полюсов, т.е. либо действительны и меньше или равны нулю, либо имеют неположительную действительную часть. (см. рисунок 3.10.1):
Рисунок 3.10.1 Полюсы некоторых звеньевДействительно, при коэффициентах знаменателя, положительная действительная часть s, приведет к тому, что выражение для будет всегда больше нуля:
Например, полюсы апериодических звеньев ([1-го](https://habr.com/ru/post/536636/) и [2-го](https://habr.com/ru/post/541852/) порядка) расположены на отрицательной части оси абсцисс, у [колебательного звена](https://habr.com/ru/post/544260/) – комплексные полюса, причем, , т.е. они находятся в левой полуплоскости; полюсы интегрирующих звеньев – на оси абсцисс и т.д.
Рассмотренные типовые звенья являются устойчивыми (за исключением интегрирующих и консервативных звеньев, которые находятся на границе устойчивости) – смотри ниже раздел «Устойчивость САР»
Если хотя бы один коэффициент в многочлене звеньев 1-го и 2-го порядков станет **отрицательным**, один полюс (и пара комплексно-сопряженных полюсов) будет находиться в правой полуплоскости полюсов.
**Например:**
Рисунок 3.10.2 Положительный полюсРисунок 3.10.3 Пара комплексно-сопряженных полюсовТакие звенья становятся неустойчивыми, т.е. при любом воздействии, отклонившим звено от состояния равновесия, выходное воздействие 
Принято называть типовые звенья со всеми положительными коэффициентами в **минимально-фазовыми**, а если хотя бы один коэффициент в отрицателен – **неминимально-фазовыми**.
Поясним это сравнением 2-х апериодических звеньев 1-го порядка (устойчивого и неустойчивого)
**Устойчивое звено:**
![h(t) = k \cdot[1-e^{-\frac{t}{T}}]](https://habrastorage.org/getpro/habr/upload_files/f4b/c4d/de7/f4bc4dde7b6d204a4385780736bb8827.svg)
**Неустойчивое звено:**
****
![h(t) =k\cdot[e^{\frac{t}{T}}-1]](https://habrastorage.org/getpro/habr/upload_files/3ce/c72/023/3cec72023056379d1dc6c5e72f08137f.svg)
Рисунок 3.10.4 Годограф устойчивого звенаРисунок 3.10.5 Годограф неустойчивого звенаРисунок 3.10.6 Сдвиг фазы устойчивого звенаРисунок 3.10.7 Сдвиг фазы неустойчивого звенаРисунок 3.10.8 Переходная функция устойчивого звенаСравнение этих звеньев показывает, что сдвиг фазы устойчивого звена  меньше по модулю, чем сдвиг фазы неустойчивого звена .
Поэтому минимально-фазовыми (в общем случае) являются такие звенья, которые не имеют положительной вещественной части ни в полюсах, ни в нулях передаточной функции. Такие звенья имеют наименьшие по абсолютному значению фазовые характеристики.
Важным свойством минимально-фазовых звеньев является однозначное соответствие между и амплитудной характеристикой и фазовой характеристикой , т.е. по заданной можно всегда рассчитать и наоборот.
#### Пример 1
Проверим аналитическое решение численным моделированием. На рисунке 3.10.9 представлена модель двух звеньев вида  и  в которых коэффициенты 
Модель для сравнения и результаты моделирования представлены на рисунке 3.10.9
3.10.9 Сравнение двух простых звеньев.Видим, что переходной процесс, в первом звене затухающий. К 7 – 8 секунде расчета выход блока 1 стабилизируется на значении 0. Для второго блока выходное значение растет по экспоненте.
#### Пример 2
Проверим вышесказанное утверждение на более сложной передаточной функции второго порядка.
Для этого используем блок «***Передаточная функция общего вида***» и задаем свойства как показано на рисунке 3.10.10. Получим две передаточные функции 3 и 4 которые отличаются только знаком при одном из коэффициентов знаменателя. У передаточного звена 3 все коэффициенты положительные. У звена 4 один из коэффициентов в знаменателе отрицательный. См. рисунок 3.10.10
Рисунок 3.10.10 Настройка передаточной функции общего вида.Результаты расчета показывают, что звено общего вида, так же становится неустойчивым, если один из коэффициентов в знаменателе отрицательный. см. рис. 3.10.11
Рисунок 3.10.11 Сравнение переходных процессов в устойчивом и неустойчивом звене.Для звена 3, где все значения знаменателя положительные, переходной процесс заканчивается к 3 секунде расчёта, и устанавливается новое значение выходной величины. Для звена 4 переходной процесс представляет собой колебания, у которых амплитуда растет экспоненциально. См. рис. 3.10.11
В модели на рисунке 3.10.11 добавлен блок «Построение частных характеристик» для отображения АЧХ и ФЧХ. На рисунке 3.10.12 приведены АЧХ и ФЧХ двух звеньев. Видно, что графики АЧХ практически совпадают, а вот графики ФЧХ отличаются, при чем у неустойчивого звена 4 сдвиг фазы по модулю больше, чем у устойчивого звена 3.
Рисунок 3.10.12 Сравнение частотных характеристик устойчивого и неустойчивого звена.Проведем боле масштабное исследование. В одном блоке можно смоделировать множество разных передаточных функций с разными наборами коэффициентов числителя и знаменателя.
Создадим серию передаточных звеньев, у которых все коэффициенты, кроме одного, одинаковы, а один коэффициент меняется плавно от отрицательного до положительного в серии.
В качестве базового передаточного звена возьмем звено второго порядка, передаточная функция которого представлена на рисунке 3.10.13 Коэффициенты подобраны таким образом, чтобы изменения выходных функций при ступенчатом воздействии не вызвали чрезмерного роста масштаба графика, как на рисунке 3.10.11, где амплитуда колебаний для неустойчивого звена составляет 1е14, и весь график в начальный момент времени представляет собой прямую линию, хотя на самом деле там идут колебания с постоянно увеличивающейся амплитудой, которые не отражаются в полном объеме из-за масштаба графика.
Рисунок 3.10.13 Модель для серии передаточных функций.Для формирования серии звеньев воспользуемся тем, что практически все звенья могут обрабатывать не только скалярные сигналы, но и векторные. Ступенчатое воздействие может быть размножено в нужном количестве и отправлено в виде вектора в звено, где будет вычислено заданное количество передаточных функций.
Для формирования вектора воспользуемся скриптом в главном окне программы. Сам скрипт представлен на рисунке 6. Для удобства мы сделаем количестве звеньев переменным и можем провести расчёты как для произвольного размера вектора. Изменяя константу Size, мы можем получить разный размер вектора.
Изменять будем второй коэффициент в знаменателе в диапазоне от -0.1 до 1, с равномерным шагом в зависимости от размер вектора.
Ниже приведен исходный код главного скрипта программы.
```
const
Size = 50, //размер вектора (количество звеньев)
N_v = [85 4 0.01], //коэффициенты числителя
L_v = [2 1 0.5]; //коэффициенты знаменателя
X_0 = matrix(Size,1); //матрица - вектор начальных условий
var
N_m = matrix(Size,3), //матрица коэффициентов числителя
L_m = matrix(Size,3); //матрица коэффициентов знаменателя
initialization
for (i=1,Size) begin //в цикле присваиваем коэффициенты
for (j=1,3) begin //формируется набор одинаковых коэффициентов
N_m[i,j] = N_v[j];
L_m[i,j] = L_v[j];
end;//for j
end;//for i
da = 1.15/Size; //Шаг изменения коэффициента знаменателя
// в заполонённой матрице меняем второй коэффициент для знаменателя
// в первом звене 2-й коэффициент числителя (1 - da)
// все последующие уменьшаются с шагом da
for (i=1,Size) L_m[i,2]=1-i*da;
end; //initialization
```
Создание необходимых векторов происходит в секции инициализации, которая выполняется перед началом расчёта.
Чтобы использовать эти векторы в блоке «Передаточная функция общего вида», в свойствах в столбце «Формула» задаются имена соответствующих переменных (см. рис. 3.10.14)
Рисунок 3.10.15 Настройка свойств блока для векторной обработки 50 передаточных функций.**Создание трехмерного графика**
Поскольку мы исследуем серию передаточных функций, интересно построить трехмерный график зависимости переходного процесса от изменений исследуемого коэффициента.
Для этого используем мгновенный трехмерный график, который строится по векторам X,Y и матрице результатов Z(X,Y).
В качестве параметров используем изменение коэффициента в знаменателе – ось X, и
время переходного процесса – ось У, время дискредитировано на 100 точек. Таким образом, поверхность будет представлять собой зависимость изменения переходного процесса от изменения коэффициента. Сечение поверхности в плоскости Y-Z – это график переходного процесса при коэффициенте равном значению Х в плоскости сечения.
Для формирования матрицы и векторов используем блок «Язык программирования». Скрипт блока языка представлен ниже. На вход в каждый момент времени будет поступает вектор текущих значений выхода из блока.
В секции инициализации создаются вектора значений и матрица результатов.
В основном теле программы проверяется время, и если текущее время увеличивается на шаг дискретизации, то результаты входа присваиваются строке в матрице результата. В итоге в конце расчёта вся матрица заполонена результатами. Скрипт блока приведен ниже:
```
input Z[Size];
output X_out[Size],Y_out[100], Z_out[Size,100];
var
i,j,it: integer,
position: integer;
initialization
it = 0;
for (i=1,Size) X_out[i] = L_m[i,2]; // вектор значений 2-го коэффициента
for (i=1,100) Y_out[i] = i/(100/10); // вектор значений времени
end;
i = trunc(Time*(100/10)); //дискретизация значения по времени для графика
if i>it then
begin
it = i;
//заполнение матрицы результатов
for (j=1,Size) begin
if ((i>0) and (i<(100+1))) then Z_out[j,i] = Z[j]
end;//for
end;//if
```
Результаты моделирования в виде графика переходного процесса для 50 звеньев представлены на рисунке 3.10.16. Видно, что часть графиков представляют собой затухающие колебания, а часть – незатухающие колебания.
Рисунок 3.10.17 Переходные процессы в 50 звеньях.На трехмерном графике переход от устойчивых звенья к неустойчивым выглядит более наглядно:
Рисунок 3.10.18 Поверхность зависимости переходного процесса от коэффициента звенаЕще более заметно отличие устойчивых и неустойчивых звенев на графике частотных характеристик. При смене знака в коэффициенте знаменателя ФЧХ меняется кардинально. При этом видно, что модуль сдвига фазы неустойчивого звена больше модуля сдвига фазы устойчивого звена.
Рисунок 3.10.19 Частотные характеристика 50 звеньев.**Выводы.**
Численное исследование подтверждает свойства минимально-фазных и не минимально-фазных звеньев.
Как обычно, модели, представленные в статье, для собственных экспериментов можно взять [по ссылке](https://disk.yandex.ru/d/3qr1jltEockz5g).
Ниже – видео демонстрации модели и ее возможных изменений.
[1. Введение в теорию автоматического управления](https://habr.com/ru/post/503820/).
[2. Математическое описание систем автоматического управления 2.1 — 2.3](https://habr.com/ru/post/506984/), [2.3 — 2.8](https://habr.com/ru/post/509612/), [2.9 — 2.13](https://habr.com/ru/post/520770/).
3. ЧАСТОТНЫЕ ХАРАКТЕРИСТИКИ ЗВЕНЬЕВ И СИСТЕМ АВТОМАТИЧЕСКОГО УПРАВЛЕНИЯ РЕГУЛИРОВАНИЯ.
[3.1. Амплитудно-фазовая частотная характеристика: годограф, АФЧХ, ЛАХ, ФЧХ](https://habr.com/ru/post/526190/).
[3.2. Типовые звенья систем автоматического управления регулирования. Классификация типовых звеньев. Простейшие типовые звенья](https://habr.com/ru/post/532700/).
[3.3. Апериодическое звено 1–го порядка инерционное звено. На примере входной камеры ядерного реактора](https://habr.com/ru/post/536636/).
[3.4. Апериодическое звено 2-го порядка](https://habr.com/ru/post/541852/).
[3.5. Колебательное звено](https://habr.com/ru/post/544260/).
[3.6.](https://habr.com/ru/post/541852/) [Инерционно-дифференцирующее звено](https://habr.com/ru/post/554336/).
[3.7.](https://habr.com/ru/post/541852/) [Форсирующее звено](https://habr.com/ru/post/555818/).
[3.8. Инерционно-интегрирующее звено (интегрирующее звено с замедлением)](https://habr.com/ru/post/563950/).
[3.9. Изодромное звено (изодром)](https://habr.com/ru/post/576082/). | https://habr.com/ru/post/582164/ | null | ru | null |
# Использование фейковых функций в tSQLt для тестирования T-SQL кода
Применение практик модульного тестирования для кода базы данных улучшает качество и архитектуру кода, а также позволяет своевременно обнаруживать и устранять ошибки.
Модульные тесты характеризуются двумя моментами:
* тестирование минимального модуля, атомарной части кода;
* изоляция тестируемого кода от зависимостей (при возможности).
Изоляция зависимостей — очень важная техника, о которой мы поговорим далее в этой статье. В частности, обсудим, как использовать фейковые функции (заглушки) при тестировании T-SQL кода с использованием фреймворка tSQLt. Для решения этой задачи tSQLt предлагает хранимую процедуру FakeFunction. Давайте разберемся с этим подробнее.
Если вы не знакомы с tSQLt, то можете начать знакомство с [этой статьи](https://habr.com/ru/company/otus/blog/710934/).
### Обзор FakeFunction
Часто логика тестируемого кода может быть довольно сложной, в том числе включать в себя вызовы других функций. При этом результат вызываемой функции может влиять на результат теста, поскольку поведение тестируемого алгоритма зависит от результата функции. Это очень неприятная ситуация, которую мы хотим избежать при модульном тестировании. Происходит нарушение паттерна изоляции зависимостей модульного теста.
Давайте рассмотрим пример, как использовать функцию-заглушку (fake function) в тесте. Скалярная функция `UDefFuncOddorEven`, приведенная ниже, выполняет некоторые вычисления по модулю и возвращает четный или нечетный получился результат.
```
CREATE OR ALTER FUNCTION dbo.UDefFuncOddorEven (@n int)
RETURNS bit
AS
BEGIN
DECLARE @ModuleRes INT
SET @ModuleRes = (@n%11)
SET @ModuleRes = (@n%9)
RETURN (@ModuleRes % 2)
END
```
Далее эта функция используется в хранимой процедуре, логика работы которой зависит от значения, возвращаемого этой функцией.
```
DROP TABLE IF EXISTS OrderOnline
GO
CREATE TABLE OrderOnline
(Id INT PRIMARY KEY IDENTITY(1,1),
OrderName VARCHAR(100),
CustomerName VARCHAR(100))
GO
CREATE OR ALTER PROC SetOrders
@OName AS VARCHAR(100),
@CName AS VARCHAR(100)
AS
BEGIN
DECLARE @RandomVal AS INT
SET @RandomVal= FLOOR(RAND()*1000)
DECLARE @ufResult AS BIT
SELECT @ufResult=dbo.UDefFuncOddorEven(@RandomVal)
IF @ufResult=1
BEGIN
INSERT INTO OrderOnline (OrderName,CustomerName) VALUES (@OName,@CName)
END
END
GO
SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='OrderOnline'
SELECT * FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_NAME='SetOrders'
```
В хранимой процедуре `SetOrders` генерируется случайное число, а затем, в зависимости от результата функции `UDefFuncOddorEven`, выполняется или не выполняется операция `INSERT`. Наша цель — проверить вставку данных, но `SetOrders` сильно связана с функцией `UDefFuncOddorEven`, которая напрямую влияет на поток выполнения кода `SetOrders`. Короче говоря, мы должны решить проблему зависимости. Хранимая процедура `FakeFunction` позволяет на время теста заменить исходную функцию фиктивной для контроля значения, возвращаемого функцией. Как правило, возвращаемые значения фейковых функций могут быть жестко заданы, что делает их реализацию очень простой.
### Синтаксис FakeFunction
```
tSQLt.FakeFunction [@FunctionName = ] 'function name'
, [@FakeFunctionName = ] 'fake function name'
```
Хранимая процедура FakeFunction принимает два параметра:
* [@FunctionName](/users/FunctionName) — исходное имя функции, которую мы хотим подменить.
* [@FakeFunctionName](/users/FakeFunctionName) — имя фейковой функции, которая заменяет исходную функцию в течение работы теста.
Оба параметра типа nvarchar(max).
### Пишем фейковую функцию
Сначала создадим фейковую функцию, которую будем использовать вместо оригинальной. Сделаем ее как можно более простой, чтобы не усложнять тест. Здесь еще обратим внимание на один момент, касающийся именования фейковых функций: добавим к имени оригинальной функции "Fake" и возвращаемое значение "Return\_1", чтобы по имени можно было легко понять, что делает эта функция.
```
CREATE OR ALTER FUNCTION dbo.UDefFuncOddorEven_Fake_Return_1 (@n int)
RETURNS bit
AS
BEGIN
RETURN 1
END
```
Как видите, мы заменили сложное вычисление в исходной функции простым жестко заданным значением.Мы всегда знаем, какое значение возвращает фейковая функция.
### Используем фейковую функцию
Мы хотим проверить выполнение INSERT в хранимой процедуре `SetOrders`: вставляются ли правильные значения в таблицу `OrderOnline`? Давайте напишем тест с помощью фреймворка tSQLt. Тест будет выглядеть следующим образом.
```
EXECUTE tsqlt.NewTestClass 'TestFakeFunction'
GO
EXECUTE tSQLt.NewTestClass 'TestFakeFunction'
GO
CREATE OR ALTER PROCEDURE TestFakeFunction.[Test SetOrders_StoredProcedure_InsertFunction]
AS
BEGIN
DROP TABLE IF EXISTS expected
DROP TABLE IF EXISTS actual
EXEC tSQLt.FakeTable 'OrderOnline'
SELECT TOP(0) * INTO expected FROM OrderOnline
SELECT TOP(0) * INTO actual FROM OrderOnline
EXEC tSQLt.FakeFunction 'dbo.UDefFuncOddorEven' ,'dbo.UDefFuncOddorEven_Fake_Return_1'
INSERT INTO expected
(OrderName , CustomerName)
VALUES ('Pizza','Ryan Romero')
EXECUTE SetOrders 'Pizza' ,'Ryan Romero'
INSERT INTO actual
SELECT * FROM OrderOnline
EXEC tSQLt.AssertEqualsTable expected,actual
END
GO
EXEC tSQLt.Run 'TestFakeFunction.[Test SetOrders_StoredProcedure_InsertFunction]'
```
Далее рассмотрим этот тест построчно.
### Создание фейковой таблицы
```
EXEC tSQLt.FakeTable 'OrderOnline'
```
Здесь мы создаем фейковую таблицу `OrderOnline`, так как во время теста данная таблица должна быть пустой и содержать только строки, которые мы вставили в тесте.
Фактически мы убираем зависимость хранимой процедуры `SetOrders` от настоящей таблицы `OrderOnline`.
#### Создание таблиц для ожидаемых (expected) и фактических (actual) результатов
```
SELECT TOP(0) * INTO expected FROM OrderOnline
SELECT TOP(0) * INTO actual FROM OrderOnline
```
В конце теста мы сравниваем фактический результат с ожидаемым с помощью tSQLt.AssertTables. Для этого нам необходимо создать две таблицы: expected (ожидаемый результат) и actual (фактический результат).
Самый простой способ создать эти таблицы — взять за основу фейковую таблицу `OrderOnline`.
#### Использование фейковой функции
```
EXEC tSQLt.FakeFunction 'dbo.UDefFuncOddorEven', 'dbo.UDefFuncOddorEven_Fake_Return_1'
```
Заменяем исходную функцию фейковой, чтобы точно знать возвращаемый результат.
#### Заполняем таблицу ожидаемых значений (expected)
```
INSERT INTO expected
(OrderName , CustomerName)
VALUES ('Pizza','Ryan Romero')
```
Заполняем таблицу `expected` ожидаемыми значениями.
#### Заполняем таблицу фактических значений (actual)
```
EXECUTE SetOrders 'Pizza' ,'Ryan Romero'
INSERT INTO actual
SELECT * FROM OrderOnline
```
Здесь результат выполнения хранимой процедуры `SetOrders` вставляется в фейковую таблицу `OrderOnline`, данные из которой мы переносим в таблицу `actual` для дальнейшего сравнения.
#### Запускаем тест
```
EXEC tSQLt.Run 'TestFakeFunction.[Test SetOrders_StoredProcedure_InsertFunction]'
```
Если значения таблиц `actual` и `expected` не совпадают, то тест упадет.
Обратите внимание, если хранимая процедура `FakeFunction` не найдет оригинальную или фейковую функцию, то будет ошибка.
Еще один момент, который следует учитывать при работе с FakeFunction — должны совпадать параметры оригинальной и фейковой функций, иначе будет ошибка `"Parameters of both functions must match!"`.
### Заключение
В этой статье мы продолжили наше путешествие по модульному тестированию T-SQL и фреймворку tSQLt. Мы научились использовать фейковые функции в тестах с помощью `FakeFunction`.
---
Модульное тестирование кода бэкенда прочно вошло в нашу жизнь, но код базы данных по-прежнему мало кто тестирует. Приглашаем всех желающих на открытый урок, на котором поговорим о модульном тестировании кода SQL Server и использовании для этого tSqlt. Занятие пройдёт уже сегодня в 20:00. Записаться можно [по ссылке.](https://otus.pw/3x8Y/) | https://habr.com/ru/post/711900/ | null | ru | null |
# Cataclysm Dark Days Ahead, статический анализ и рогалики
Скорее всего, из названия статьи вы уже догадались, что в центре внимания ошибки в исходном коде. Но это вовсе не единственное, о чем пойдет речь в этой статье. Если кроме С++ и ошибок в чужом коде вас привлекают необычные игры и вам интересно узнать, что это такие за «рогалики» и с чем их едят, добро пожаловать под кат!
В своем поиске необычных игр я наткнулась на игру Cataclysm Dark Days Ahead, отличающуюся от других необычной графикой: она реализована с помощью разноцветных символов ASCII на черном фоне.
Что поражает в этой игре и ей подобных, это сколько всего в них реализовано. Конкретно в Cataclysm, например, даже для создания персонажа хочется поискать гайды, так как разных параметров, особенностей и начальных сюжетов десятки, не говоря уже о вариациях событий в самой игре.
Это игра с открытым исходным кодом, и, к тому же, написана на С++. Так что невозможно было пройти мимо и не прогнать этот проект через статический анализатор PVS-Studio, в разработке которого я сейчас принимаю активное участие. Сам проект удивил высоким качеством кода, однако, в нем все равно находятся некоторые недоработки и несколько из них я рассмотрю в этой статье.
К настоящему моменту с помощью PVS-Studio было проверено уже достаточно много игр. Например, вы можете ознакомиться с другой нашей статьей "[Статический анализ в видеоигровой индустрии: топ-10 программных ошибок](https://habr.com/ru/company/pvs-studio/blog/354808/)".
Логика
------
**Пример 1:**
Следующий пример представляет собой типичную ошибку копирования.
[V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions to the left and to the right of the '||' operator: rng(2, 7) < abs(z) || rng(2, 7) < abs(z) overmap.cpp 1503
```
bool overmap::generate_sub( const int z )
{
....
if( rng( 2, 7 ) < abs( z ) || rng( 2, 7 ) < abs( z ) )
{
....
}
....
}
```
Здесь дважды проверяется одно и то же условие. Скорее всего, выражение скопировали и забыли что-то в нём поменять. Я затруднюсь сказать, является ли эта ошибка существенной, но проверка работает не так, как задумывалось.
Аналогичное предупреждение:* V501 There are identical sub-expressions 'one\_in(100000 / to\_turns (dur))' to the left and to the right of the '&&' operator. player\_hardcoded\_effects.cpp 547
**Пример 2:**
[V728](https://www.viva64.com/ru/w/v728/) An excessive check can be simplified. The '(A && B) || (!A && !B)' expression is equivalent to the 'bool(A) == bool(B)' expression. inventory\_ui.cpp 199
```
bool inventory_selector_preset::sort_compare( .... ) const
{
....
const bool left_fav = g->u.inv.assigned.count( lhs.location->invlet );
const bool right_fav = g->u.inv.assigned.count( rhs.location->invlet );
if( ( left_fav && right_fav ) || ( !left_fav && !right_fav ) ) {
return ....
}
....
}
```
Ошибки в условии нет, но оно излишне усложнено. Стоило бы сжалиться над тем, кому придется разбирать это условие, и написать проще *if( left\_fav == right\_fav )*.
Аналогичное предупреждение:
* V728 An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. iuse\_actor.cpp 2653
Отступление I
-------------
Для меня оказалось открытием, что игры, которые на сегодняшний день называют «рогаликами» — это лишь достаточно лайтовые последователи старого жанра roguelike игр. Началось все с культовой игры Rogue 1980 года, ставшей образцом для подражания и вдохновившей множество студентов и программистов на создание собственных игр. Полагаю, многое также привнесло сообщество настольной ролевой игры DnD и её вариаций.
Микрооптимизации
----------------
**Пример 3:**
Следующая группа предупреждений анализатора указывает не на ошибку, а на возможность микрооптимизации кода программы.
[V801](https://www.viva64.com/ru/w/v801/) Decreased performance. It is better to redefine the second function argument as a reference. Consider replacing 'const… type' with 'const… &type'. map.cpp 4644
```
template
std::list use\_amount\_stack( Stack stack, const itype\_id type )
{
std::list ret;
for( auto a = stack.begin(); a != stack.end() && quantity > 0; ) {
if( a->use\_amount( type, ret ) ) {
a = stack.erase( a );
} else {
++a;
}
}
return ret;
}
```
Здесь за *itype\_id* скрывается *std::string*. Так как аргумент все равно передается константным, что не позволит его изменить, быстрее было бы просто передать в функцию ссылку на переменную и не тратить ресурсы на копирование. И хотя, скорее всего, строка там будет совсем небольшая, но постоянное копирование без видимой на то причины излишне. Тем более, что эта функция вызывается из разных мест, многие из которых, в свою очередь, также получают *type* извне и копируют его.
Аналогичные предупреждения:
* V801 Decreased performance. It is better to redefine the third function argument as a reference. Consider replacing 'const… evt\_filter' with 'const… &evt\_filter'. input.cpp 691
* V801 Decreased performance. It is better to redefine the fifth function argument as a reference. Consider replacing 'const… color' with 'const… &color'. output.h 207
* В целом, анализатор выдал 32 таких предупреждения.
**Пример 4:**
[V813](https://www.viva64.com/ru/w/v813/) Decreased performance. The 'str' argument should probably be rendered as a constant reference. catacharset.cpp 256
```
std::string base64_encode( std::string str )
{
if( str.length() > 0 && str[0] == '#' ) {
return str;
}
int input_length = str.length();
std::string encoded_data( output_length, '\0' );
....
for( int i = 0, j = 0; i < input_length; ) {
....
}
for( int i = 0; i < mod_table[input_length % 3]; i++ ) {
encoded_data[output_length - 1 - i] = '=';
}
return "#" + encoded_data;
}
```
В этом случае аргумент хоть и не константный, но в теле функции он никак не изменяется. Поэтому, для оптимизации, хорошо было бы передавать его по константной ссылке, а не вынуждать компилятор создавать локальные копии.
Это предупреждение также было не единичным, всего таких случаев нашлось 26.
Аналогичные предупреждения:
* V813 Decreased performance. The 'message' argument should probably be rendered as a constant reference. json.cpp 1452
* V813 Decreased performance. The 's' argument should probably be rendered as a constant reference. catacharset.cpp 218
* И так далее...
Отступление II
--------------
Некоторые из классических roguelike игр до сих пор активно развиваются. Если зайти в репозитории GitHub Cataclysm DDA или NetHack, то можно увидеть, что изменения активно вносятся каждый день. NetHack вообще является самой старой игрой, разработка которой идет до сих пор: её релиз произошел в июле 1987 года, а последняя версия датируется 2018 годом.
Одной из известных, однако, более поздних игр этого жанра является Dwarf Fortress, разрабатываемая с 2002 года и впервые выпущенная в 2006 году. «Losing is fun» («Проигрывать весело») — девиз игры, в точности отражающий её суть, так как победить в ней невозможно. Эта игра в 2007 году заслужила звание лучшей roguelike игры года в результате голосования, которое ежегодно проводится на сайте ASCII GAMES.
Кстати, тем, кто интересуется этой игрой, возможно будет интересна следующая новость. Dwarf Fortress выйдет в Steam с улучшенной 32-битной графикой. С обновлённой картинкой, над которой работают два опытных модера игры, премиум-версия Dwarf Fortress получит дополнительные музыкальные треки и поддержку Steam Workshop. Но если что, владельцы платной версии Dwarf Fortress смогут поменять обновлённую графику на прежний вид в ASCII. [Подробнее](https://www.patreon.com/posts/25343688).
Переопределение оператора присваивания
--------------------------------------
**Примеры 5, 6:**
Также нашлась интересная пара сходных предупреждений.
[V690](https://www.viva64.com/ru/w/v690/) The 'JsonObject' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. json.h 647
```
class JsonObject
{
private:
....
JsonIn *jsin;
....
public:
JsonObject( JsonIn &jsin );
JsonObject( const JsonObject &jsobj );
JsonObject() : positions(), start( 0 ), end( 0 ), jsin( NULL ) {}
~JsonObject() {
finish();
}
void finish(); // moves the stream to the end of the object
....
void JsonObject::finish()
{
....
}
....
}
```
Этот класс обладает конструктором копирования и деструктором, однако, для него отсутствует перегрузка оператора присваивания. Проблема здесь состоит в том, что автоматически сгенерированный оператор присваивания может лишь присвоить указатель к *JsonIn*. В результате оба объекта класса *JsonObject* указывают на один тот же *JsonIn*. Неизвестно, может ли где-то сейчас возникнуть такая ситуация, но, в любом случае, это — грабли, на которые рано или поздно кто-то наступит.
Аналогичная проблема присутствует в следующем классе.
[V690](https://www.viva64.com/ru/w/v690/) The 'JsonArray' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. json.h 820
```
class JsonArray
{
private:
....
JsonIn *jsin;
....
public:
JsonArray( JsonIn &jsin );
JsonArray( const JsonArray &jsarr );
JsonArray() : positions(), ...., jsin( NULL ) {};
~JsonArray() {
finish();
}
void finish(); // move the stream position to the end of the array
void JsonArray::finish()
{
....
}
}
```
Более подробно об опасности нехватки перегрузки оператора присваивания для сложного класса можно почитать в статье "[The Law of The Big Two](https://www.artima.com/cppsource/bigtwo.html)" (или в переводе этой статьи "[CИ++: Закон Большой Двойки](https://habr.com/ru/post/31346/)").
**Примеры 7, 8:**
Еще один пример, связанный с перегруженным оператором присваивания, но на этот раз речь о его конкретной реализации.
[V794](https://www.viva64.com/ru/w/v794/) The assignment operator should be protected from the case of 'this == &other'. mattack\_common.h 49
```
class StringRef {
public:
....
private:
friend struct StringRefTestAccess;
char const* m_start;
size_type m_size;
char* m_data = nullptr;
....
auto operator = ( StringRef const &other ) noexcept -> StringRef& {
delete[] m_data;
m_data = nullptr;
m_start = other.m_start;
m_size = other.m_size;
return *this;
}
```
Проблема в том, что данная реализация не защищена от присвоения объекта самому себе, что является небезопасной практикой. То есть, если этому оператору будет передана ссылка на *\*this*, может произойти утечка памяти.
Схожий пример ошибочной перегрузки оператора присваивания с интересным побочным эффектом:
[V794](https://www.viva64.com/ru/w/v794/) The assignment operator should be protected from the case of 'this == &rhs'. player\_activity.cpp 38
```
player_activity &player_activity::operator=( const player_activity &rhs )
{
type = rhs.type;
....
targets.clear();
targets.reserve( rhs.targets.size() );
std::transform( rhs.targets.begin(),
rhs.targets.end(),
std::back_inserter( targets ),
[]( const item_location & e ) {
return e.clone();
} );
return *this;
}
```
В этом случае точно так же отсутствует проверка на присваивание объекта самому себе. Но в дополнение заполняется вектор. Если попытаться такой перегрузкой присвоить объект самому себе, то в поле *targets* получим удвоенный вектор, часть элементов которого испорчена. Однако здесь перед *transform* присутствует *clear*, что очистит вектор объекта и данные будут потеряны.
Отступление III
---------------
В 2008 году рогалики даже обзавелись формальным определением, которое получило эпичное название «Берлинская интерпретация». Согласно этому определению, основными чертами таких игр являются:
* Случайно сгенерированный мир, что увеличивает реиграбельность;
* Permadeath: если ваш персонаж умирает — он умирает навсегда и все предметы теряются;
* Пошаговость: изменения происходят только вместе с действием игрока, пока действие не произведено — время останавливается;
* Выживание: ресурсы крайне ограничены.
Ну и самое главное: рогалики нацелены прежде всего на исследование и открытие мира, поиск новых способов использования предметов и прохождения подземелий.
Обычная ситуация в Cataclysm DDA: промерзли и голодны до смерти, вас мучает жажда, да и вообще у вас вместо ног шесть тентаклей.
Немаловажные детали
-------------------
**Пример 9:**
[V1028](https://www.viva64.com/ru/w/v1028/) Possible overflow. Consider casting operands of the 'start + larger' operator to the 'size\_t' type, not the result. worldfactory.cpp 638
```
void worldfactory::draw_mod_list( int &start, .... )
{
....
int larger = ....;
unsigned int iNum = ....;
....
for( .... )
{
if( iNum >= static_cast( start )
&& iNum < static\_cast( start + larger ) )
{
....
}
....
}
....
}
```
Похоже, программист хотел избежать переполнения. Но приведение результата сложения в таком случае бессмысленно, так как переполнение возникнет уже при сложении чисел, и расширение типов произведется над бессмысленным результатом. Для того, чтобы избежать этой ситуации, необходимо привести лишь один из аргументов к большему типу: *(static\_cast (start) + larger)*.
**Пример 10:**
[V530](https://www.viva64.com/ru/w/v530/) The return value of function 'size' is required to be utilized. worldfactory.cpp 1340
```
bool worldfactory::world_need_lua_build( std::string world_name )
{
#ifndef LUA
....
#endif
// Prevent unused var error when LUA and RELEASE enabled.
world_name.size();
return false;
}
```
Для таких случаев существует небольшая хитрость. Если переменная оказывается неиспользованной, вместо того, чтобы пытаться вызвать какой-либо метод, можно просто написать *(void)world\_name* для подавления предупреждения компилятора.
**Пример 11:**
[V812](https://www.viva64.com/ru/w/v812/) Decreased performance. Ineffective use of the 'count' function. It can possibly be replaced by the call to the 'find' function. player.cpp 9600
```
bool player::read( int inventory_position, const bool continuous )
{
....
player_activity activity;
if( !continuous
|| !std::all_of( learners.begin(),
learners.end(),
[&]( std::pair elem )
{
return std::count( activity.values.begin(),
activity.values.end(),
elem.first->getID() ) != 0;
} )
{
....
}
....
}
```
Судя по тому, что результат *count* сравнивается с нулем, идея в том, чтобы понять, есть ли хоть один требуемый элемент среди *activity*. Но *count* вынужден проходить по всему контейнеру, так как он считает все вхождения элемента. В этой ситуации будет быстрее использовать *find*, который останавливается после первого же найденного совпадения.
**Пример 12:**
Следующая ошибка легко обнаруживается, если знать об одной тонкости.
[V739](https://www.viva64.com/ru/w/v739/) EOF should not be compared with a value of the 'char' type. The 'ch' should be of the 'int' type. json.cpp 762
```
void JsonIn::skip_separator()
{
signed char ch;
....
if (ch == ',') {
if( ate_separator ) {
....
}
....
} else if (ch == EOF) {
....
}
```
Это одна из тех ошибок, которые бывает сложно заметить, если не знать, что *EOF* определен как -1. Соответственно, если пытаться сравнивать его с переменной типа *signed char*, условие почти всегда оказывается *false*. Единственное исключение, это если кодом символа будет 0xFF (255). При сравнении такой символ превратится в -1 и условие окажется верным.
**Пример 13:**
Следующая небольшая ошибка однажды может стать критической. Не зря она есть в списке CWE как [CWE-834](https://cwe.mitre.org/data/definitions/834.html). А их, кстати, было целых пять.
[V663](https://www.viva64.com/ru/w/v663/) Infinite loop is possible. The 'cin.eof()' condition is insufficient to break from the loop. Consider adding the 'cin.fail()' function call to the conditional expression. action.cpp 46
```
void parse_keymap( std::istream &keymap_txt, .... )
{
while( !keymap_txt.eof() ) {
....
}
}
```
Как сказано в предупреждении, проверки на достижение конца файла при чтении недостаточно, необходимо также проводить проверку на ошибку считывания *cin.fail()*. Изменим код для более безопасного считывания:
```
while( !keymap_txt.eof() )
{
if(keymap_txt.fail())
{
keymap_txt.clear();
keymap_txt.ignore(numeric_limits::max(),'\n');
break;
}
....
}
```
*keymap\_txt.clear()* нужен для того, чтобы при ошибке считывания из файла убрать из потока состояние (флажок) ошибки, иначе дальше считать текст будет нельзя. *keymap\_txt.ignore* с параметрами *numeric\_limits::max()* и управляющим символом перевода строки позволяет пропустить оставшуюся часть строки.
Есть и гораздо более простой способ остановки считывания:
```
while( !keymap_txt )
{
....
}
```
Если использовать поток в контексте логики, он конвертирует себя в значение эквивалентное *true*, пока не будет достигнут *EOF*.
Отступление IV
--------------
Сейчас наибольшую популярность имеют игры, которые сочетают в себе признаки roguelike игр и других жанров: платформеров, стратегий и др. Такие игры стали называть roguelike-like или roguelite. К таким играм относят такие известные тайтлы, как Don't Starve, The Binding of Isaac, FTL:Faster Than Light, Darkest Dungeon и даже Diablo.
Хотя временами разница между roguelike и roguelite столь мала, что не понятно, к какому жанру отнести игру. Кто-то считает, что Dwarf Fortress уже не roguelike, а для кого-то и Diablo — классический рогалик.
Заключение
----------
Хоть проект в целом и является примером качественного кода, и не удалось найти много серьёзных ошибок, это не значит, что использование статического анализа для него является избыточным. Суть не в разовых проверках, которые делаем с целью популяризации методологии статического анализа кода, а в регулярном использовании анализатора. Тогда многие ошибки можно выявить на самом раннем этапе и, следовательно, сократить стоимость их исправления. [Пример](https://www.viva64.com/ru/b/0606/) расчётов.
Над рассмотренной игрой и сейчас ведется активная работа, и существует активное сообщество моддеров. Причем она портирована на множество платформ, в том числе iOS и Android. Так что, если вас заинтересовала эта игра, рекомендую попробовать!
[](https://habr.com/ru/company/pvs-studio/blog/449488/) | https://habr.com/ru/post/449472/ | null | ru | null |
# NetApp ONTAP & ESXi 6.х tuning
В продолжение темы об оптимизации ESXi хоста для взаимодействия с СХД NetApp ONTAP, эта статья будет просвещена оптимизации производительности VMWare ESXi 6.X, предыдущие статьи были посвящены тюнингу ОС [Linux](http://habrahabr.ru/post/245357/), [Windows](http://habrahabr.ru/post/243153/) и [VMware ESXi 5.X](https://habrahabr.ru/post/247833/) в среде SAN. Компания NetApp давно тесно сотрудничает с VMware, подтверждением тому может стать тот факт, что нашумевшая технология [vVOL была реализована](http://community.netapp.com/t5/Tech-OnTap-Articles/NetApp-Unlocks-the-Power-of-VMware-VVOLs/ta-p/86939) одной из первых ещё в релизе Clustered Data ONTAP 8.2.1 (Август 2014), в то время как vSphere 6.0 ещё даже не был выпущен. Компания NetApp первой объявила поддержку vVol c NFS (Возможно NetApp по-прежнему здесь единственный, не слежу). В связи с чем системы хранения ONTAP крайне популярны в этом окружении.
Эта статья будет полезна владельцам систем хранения с ONTAP, а часть про [Disk Alignment](#alignment) будет полезна не только владельцам NetApp`а.
Настройки VMWare ESXi 6.X можно разделить на следующие части:
* Оптимизация гипервизора
* Оптимизация гостевой ОС (GOS)
* Оптимальные настройки SAN (FC/FCoE и iSCSI)
* Настройки NAS (NFS)
* Проверка совместимости оборудования, прошивок и ПО
Для поиска узкого места обычно выполняют методику последовательного исключения. Предлагаю перво-наперво начать с СХД. А дальше двигаться [СХД](http://habrahabr.ru/post/243045/) -> Сеть ([Ethernet](http://habrahabr.ru/post/243119/) / FC) -> Хост ( [Windows](http://habrahabr.ru/post/243153/) / [Linux](http://habrahabr.ru/post/245357/) / **VMware ESXi** ) → Приложение.
Есть пару основных документов, на которые необходимо опираться при настройке VMware + NetApp:
» [How to configure VMware vSphere 6.x on ONTAP 8.x](https://kb.netapp.com/support/index?page=content&id=1015266&pmv=print&impressions=false)
» [Virtual Storage Console 6.0 for VMware vSphere Installation](https://library.netapp.com/ecm/ecm_download_file/ECMP12405914)
» [TR-4128: vSphere 6 on NetApp MetroCluster 8.3](https://www.netapp.com/us/media/tr-4128.pdf)
#### [Hypervisor](#Hypervisor)
Отдавать гостевой ОС все ресурсы сервера не стоит, во-первых гипервизору нужно оставить минимум 4ГБ ОЗУ, во-вторых иногда наблюдается обратный эффект при добавлении ресурсов гостевой ОС, это нужно подбирать эмпирическим путём.
##### [SWAP](#SWAP)
Этот раздел вынесен в [отдельный пост](http://habrahabr.ru/post/247631/).
#### [Гостевые ОС](#GOS)
Тюнинг настроек нужен для двух целей:
* Оптимизация скорости работы гостевых ОС
* Нормальная работа в HA паре, при отказе одного контроллера (takeover) и возобновлении его работы (giveback)
##### [Disk alignment](#alignment)
Для оптимизации производительности, возможно, потребуется [устранить *disk misalignment*](https://kb.netapp.com/support/index?page=content&id=1010881). *Misalignment* можно получить в двух случаях:
1. из-за неправильно выбранной геометрии луна при его создании в СХД. Такую ошибку можно создать только в SAN окружении
2. внутри виртуальных дисков виртуальных машин. Может быть, как в SAN так и в NAS окружении
Давайте разберем эти случаи
**Полностью выровненные блоки на VMFS датасторе**Для начала рассмотрим полностью выровненные блоки по границах VMFS датастора и хранилища.
**Первый случай - Misalignment с VMFS**Первый случай — это когда есть *misalignment* VMFS датастора относительно хранилища. Для устранения первого типа проблемы необходимо создать лун с правильной геометрией и переместить туда виртуальные машины.
**Второй случай - смещение внутри гостевой ОС**Вторую ситуацию, со смещенными разделами файловой системы внутри гостевой ОС относительно файловой структуры WAFL можно получить в старых дистрибутивах Linux и ОС Windows 2003 и старее. Так как проблема «внутри виртуальной машины», она может наблюдаться как на NFS так и на VMFS датасторах, а также в RDM и vVOL. Как правило это связано с не оптимальным размещением таблицы разделов MBR или с машинами, которые были конвертированы из физических в виртуальные. Проверить это можно в [гостевых ОС Windows](https://kb.netapp.com/support/index?page=content&id=1013644&actp=search&viewlocale=en_US&searchid=1419848156220) при помощи утилиты *dmdiag.exe -v* (значение поля Rel Sec должно быть кратно 4KB на WAFL). Подробнее о [диагностике misalignment для Windows](https://kb.netapp.com/support/index?page=content&id=1010803&actp=search&viewlocale=en_US&searchid=1419848156220) машин. Подробнее как устранять такие ситуации описано в [TR-3747 Best Practices for File System Alignment in Virtual Environments](http://media.netapp.com/documents/tr-3747.pdf).
**Misalignment на двух уровнях**Ну и конечно же можно получить *misalignment* сразу на двух уровнях: как на уровне VMFS датастора, так и на уровне файловой системы гостевой ОС. Подробнее о [поиске misalignment со стороны хранилища ONTAP](http://habrahabr.ru/post/243045/#Misalignment).
В ново созданной VMFS5 (не апгрейд с VMFS3) блок имеет размер 1MB с суб-блоками 8KB.
##### [takeover/giveback](#takeover-giveback)
Для отработки при takeover/giveback в HA паре, необходимо настроить правильные таймауты гостевых ОС. Для дисковых FAS систем это время 60 секунд, а для All Flash FAS (AFF) это 2-15 секунд. Так как в кластере могут находиться СХД разных моделей, дисковые, гибридные и AFF системы, а данные могут мигрировать между этими системами, рекомендуется использовать наихудшее значение таймаутов (у дисковых систем), а именно 60 секунд:
| ОС | Updated Guest OS Tuning for SAN: ESXi 5 и новее, или ONTAP 8.1 и новее (SAN) |
| --- | --- |
| Windows | disk timeout = 60 |
| Linux | disk timeout = 60 |
| Solaris | disk timeout = 60; busy retry = 300; not ready retry = 300; reset retry = 30; max. throttle = 32; min. throttle = 8; corrected VID/PID specification |
Дефолтные значения ОС в случае использования NFS удовлетворительны, и настройки для гостевых ОС не нужно менять.
Устанавливаются эти значения вручную или при помощи скриптов доступных в составе VSC:
**Windows**Установить значение задержки доступа к диску 60 сек при помощи реестра (задаётся в секундах, в шестнадцатеричной форме).
```
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\Disk]
"TimeOutValue"=dword:0000003c
```
**Linux**Установить значение задержки доступа к диску 60 сек при помощи создания udev правила (задаётся в секундах, в шестнадцатеричной форме).
```
DRIVERS=="sd", SYSFS{TYPE}=="0|7|14", RUN+="/bin/sh -c 'echo 60 > /sys$$DEVPATH/timeout'"
```
(Linux дистрибутивы могут иметь разное расположение установки правил udev). VMware Tools для гостевой Linux ОС автоматически устанавливает udev правило со значением задержки для виртуального диска равное 180 секунд. Вы можете запустить команду *grep* для «VMware» vendor ID в папке с правилами udev чтобы найти скрипт, который устанавливает это значение и изменить его при необходимости. Не забудьте проверить это значение.
**Solaris**Установить значение 60 сек задержки (задаётся в секундах, в шестнадцатеричной форме) для диска можно в файле */etc/system*:
```
set sd:sd_io_time=0x3c
```
Дополнительные настройки могут быть внесены в файл */kernel/drv/sd.conf*:
Solaris 10.0 GA — Solaris 10u6:
```
sd-config-list="NETAPP LUN","netapp-sd-config",
"VMware Virtual","netapp-sd-config";
netapp-sd-config=1,0x9c01,32,0,0,0,0,0,0,0,0,0,300,300,30,0,0,8,0,0;
```
**Solaris 10u7 и новее и Solaris 11**
```
sd-config-list= "NETAPP LUN","physical-block-size:4096,retries-busy:300,retries-timeout:16,retries-notready:300,retries-reset:30,throttle-max:32,throttle-min:8",
"VMware Virtual","physical-block-size:4096,retries-busy:300,retries-timeout:16,retries-notready:300,retries-reset:30,throttle-max:32,throttle-min:8";
```
Обратите внимание: на два пробела между vendor ID NETAPP и ID LUN, также, как и между словами «VMware» и «Virtual» в конфиге выше.
#### [Настройки FC/FCoE Switch Zoning](#zoning)
Подробнее о рекомендациях [зонирования для NetApp в картинках](http://habrahabr.ru/post/260107/).
##### [ALUA](#ALUA)
Для ONTAP 8.X и 9.X ALUA всегда включён для всех блочных протоколов: iSCSI/FC/FCoE.
Если хост правильно определил ALUA, то *Storage Array Type plug-in* будет отображать *VMW\_SATP\_ALUA*. Для ALUA, разрешается к использованию алгоритм *Most Recently Used* или *Round Robin* — любой.
*Round Robin* будет более производительнее если путей больше чем один к контроллеру. В случае использования Microsoft Cluster + RDM дисков к применению рекомендован механизм балансировки *Most Recently Used*.
Ниже таблица рекомендуемых настроек балансировки нагрузки. Подробнее о [логике работы NetApp ONTAP, ALUA и балансировке нагрузки для блочных протоколов](http://habrahabr.ru/post/243045/#Likbez).
| Mode | ALUA | Protocol | Политика ESXi | Балансировка путей ESXi |
| --- | --- | --- | --- | --- |
| ONTAP 9.x / 8.x (Clustered) | Enabled | FC/FCoE/iSCSI | VMW\_SATP\_ALUA | Most Recently Used |
| ONTAP 9.x / 8.x (Clustered) | Enabled | FC/FCoE/iSCSI | VMW\_SATP\_ALUA | Round Robin |
**Проверим применившуюся политику к проверяемому луну/датастору**
```
~ # esxcli storage nmp device list
naa.60a980004434766d452445797451376b
Device Display Name: NETAPP Fibre Channel Disk (naa.60a980004434766d452445797451376b)
Storage Array Type: VMW_SATP_ALUA
Storage Array Type Device Config: {implicit_support=on;explicit_support=off; explicit_allow=on;alua_followover=on;{TPG_id=1,TPG_state=ANO}{TPG_id=0,TPG_state=AO}}
Path Selection Policy: VMW_PSP_RR
Path Selection Policy Device Config: {policy=rr,iops=1000,bytes=10485760,useANO=0; lastPathIndex=0: NumIOsPending=0,numBytesPending=0}
Path Selection Policy Device Custom Config:
Working Paths: vmhba2:C0:T6:L119, vmhba1:C0:T7:L119
Is Local SAS Device: false
Is USB: false
Is Boot USB Device: false
```
#### [Настройки ESXi хоста](#ESXI_configurations)
Для оптимальной работы ESXi хоста необходимо установить рекомендуемые для него параметры.
| Параметр | Протокол(ы) | ESXi 6.x с DataONTAP 8.x | ESXi 6.x с DataONTAP 9.x |
| --- | --- | --- | --- |
| Net.TcpipHeapSize | iSCSI/NFS | 32 |
| Net.TcpipHeapMax | iSCSI/NFS | 1536 |
| NFS.MaxVolumes | NFS | 256 |
| NFS41.MaxVolumes | NFS 4.1 | 256 |
| NFS.HeartbeatMaxFailures | NFS | 10 |
| NFS.HeartbeatFrequency | NFS | 12 |
| NFS.HeartbeatTimeout | NFS | 5 |
| NFS.MaxQueueDepth | NFS | 64 (если у вас только AFF, то 128 или 256) |
| Disk.QFullSampleSize | iSCSI/FC/FCoE | 32 |
| Disk.QFullThreshold | iSCSI/FC/FCoE | 8 |
Есть несколько способов это сделать:
* Используя Command Line Interface (CLI) на ESXi 6.x хостах.
* Используя vSphere Client/vCenter Server.
* Используя Remote CLI tool от VMware.
* Используя VMware Management Appliance (VMA).
* Применяя Host Profile разворачивая его с уже настроенного ESXi 6.x на другие хосты.
**Пример настройки расширенных параметров из ESX 6.x CLI**Утилита esxcfg-advcfg используемая в этих примерах располагается в /usr/sbin папке для ESXi хоста.
```
#Для протоколов iSCSI/NFS
#esxcfg-advcfg -s 32 /Net/TcpipHeapSize
#esxcfg-advcfg -s 512 /Net/TcpipHeapMax
#Для протокола NFS
#esxcfg-advcfg -s 256 /NFS/MaxVolumes
#esxcfg-advcfg -s 10 /NFS/HeartbeatMaxFailures
#esxcfg-advcfg -s 12 /NFS/HeartbeatFrequency
#esxcfg-advcfg -s 5 /NFS/HeartbeatTimeout
#esxcfg-advcfg -s 64 /NFS/MaxQueueDepth
#Для протокола NFS v4.1
#esxcfg-advcfg -s 256 /NFS41/MaxVolumes
#Для протоколов iSCSI/FC/FCoE
#esxcfg-advcfg -s 32 /Disk/QFullSampleSize
#esxcfg-advcfg -s 8 /Disk/QFullThreshold
```
**Проверяем расширенные настройки из ESX 6.x CLI**
```
#Для протоколов iSCSI/NFS
#esxcfg-advcfg -g /Net/TcpipHeapSize
#esxcfg-advcfg -g /Net/TcpipHeapMax
#Для протокола NFS
#esxcfg-advcfg -g /NFS/MaxVolumes
#esxcfg-advcfg -g /NFS/HeartbeatMaxFailures
#esxcfg-advcfg -g /NFS/HeartbeatFrequency
#esxcfg-advcfg -g /NFS/HeartbeatTimeout
#esxcfg-advcfg -g /NFS/MaxQueueDepth
#Для протокола NFS v4.1
#esxcfg-advcfg -g /NFS41/MaxVolumes
#Для протоколов iSCSI/FC/FCoE
#esxcfg-advcfg -g /Disk/QFullSampleSize
#esxcfg-advcfg -g /Disk/QFullThreshold
```
##### [HBA](#HBA)
NetApp как правило рекомендует использовать для ONTAP систем с хостом ESXi «значения по умолчанию» для HBA, устанавливаемые производителем адаптера. Если они были изменены, необходимо их вернуть к заводским настройкам. Проверьте соответствующие лучшие практики. К примеру, если речь о виртуализации DB2 в среде VMware на NetApp, то рекомендуется ([смотри стр. 21](http://www.netapp.com/us/media/wp-7109.pdf)) увеличить длину очереди до 64 на ESXi (как это сделать написано в [Vmware KB 1267](http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1267)).
**Пример настройки HBA Qlogic на ESXi**
```
# посмотреть драйвер для Qlogic на ESXi 5.5 и 6.0
# esxcli system module list | grep qln
# Установить значение для Qlogic на ESXi 5.5 и 6.0
# esxcli system module parameters set -p qlfxmaxqdepth=64 -m qlnativefc
```
##### [VSC](#VSC)
Плагин NetApp VSC (является бесплатным ПО), устанавливает рекомендуемые настройки на ESXi хосте и HBA адаптере: очередь, задержки и другие. Сам плагин интегрируется в vCenter. Экономит время и устраняет во время теста человеческий фактор при настройке параметров на ESXi хосте для более эффективной работы с NetApp. Позволяет выполнять базовые операции для управления хранилищем из vCenter, необходимые администратору виртуализированных сред. Права доступа к хранилищу при помощи VSC могут быть гибко настроены для нескольких пользователей при помощи RBAC. VSC является обязательным для настройки vVOL.
Доступна версия плагина только для веб-клиента. Поддерживается версия 6 и более новые.
#### [Ethernet](#Ethernet)
##### [Jumbo frames](#Jumbo_frames)
В случае использования iSCSI крайне рекомендуется использовать Jumbo Frames в Ethernet со скоростью выше или равно 1Gb. Подробнее в статье про [Ethernet с NetApp ONTAP](http://habrahabr.ru/post/243119/#jumboframe). Не забывайте также о рекомендациях VMware по настройкам LACP, Port-channel, Spanning Tree, PortFast, Flowcontrol.
##### [ESXi & MTU9000](#ESXi_and_MTU9000)
Не забудьте создать правильный сетевой адаптер — VMware рекомендует использовать VMXNEЕ3. Начиная с версии ESXi 5.0 VMXNET3 поддерживает Jumbo Frames. Сетевой адаптер E1000e поддерживает скорость 1GB сетей и MTU 9000 — он устанавливается для всех создаваемых VM по умолчанию (кроме Linux). Стандартный виртуальный сетевой адаптер типа «Flexible» поддерживает MTU 1500. [Подробнее.](http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1001805)
Также не забудьте, что *порт-группа* установленная для виртуального сетевого адаптера вашей виртуальной машине должна быть подключена к виртуальному свичу с установленной настройкой MTU 9000 для всего свича.
#### [NAS и VAAI](#NAS)
Системы ONTAP поддерживают примитивы VMware VAAI сгружая часть рутинных задач по управлению данными на датасторе с хоста на хранилище, где это более логично выполнять. В SAN окружении с ESXi 4.1+ и выше с системами ONTAP 8.0 и выше VAAI автоматически поддерживается и не требует каких-либо манипуляций. Для NAS окружения компания NetApp выпустила плагин, который позволяет выполнять подобную оптимизацию для протокола NFS. Это требует установки модуля ядра *NetAppNFSVAAI* для каждого ESXi хоста. [VSC](#VSC) может выполнить установку NFS VAAI плагина автоматически из vCenter. Чтобы он функционировал необходимо [правильно настроить NFS шару для VAAI](https://kb.netapp.com/support/index?page=content&id=1014234&act=SAT&impressions=false&newguid=3cfa2cb3cf9544c597c8479f7ff38ca3), для чего необходимо удовлетворить несколько требований:
* Настроить доступ ESXi сервера (RO, RW и Superuser должны быть в состоянии SYS или ANY, и должны быть активирован доступ по протоколам NFS3 **И** NFS4). Даже если NFS4 не будет использоваться, он должен быть в списке доступа.
* Все родительские вольюмы в junction path должны разрешать root read доступ и NFSv4 доступ. В большинстве случаев это означает, что root volume для Storage Virtual Server (Vserver) минимально должен иметь настройку superuser установленную в значение SYS для соответствующего клиента, который будет использовать VAAI доступ к одному из вложенных вольюмов. Рекомендуется запретить доступ на запись непосредственно в Vserver root вольюм.
* Необходимо включить поддержку vStorage на вольюме.
**Пример настройки VAAI на ONTAP**
```
cm3240c-rtp::> export-policy rule show -vserver vmware -policyname vmware_access -ruleindex 2
(vserver export-policy rule show)
Vserver: vmware
Policy Name: vmware_access
Rule Index: 1
Access Protocol: nfs3 <---- needs to be 'nfs' or 'nfs3,nfs4'
Client Match Spec: 192.168.1.7
RO Access Rule: sys
RW Access Rule: sys
User ID To Which Anonymous Users Are Mapped: 65534
Superuser Security Flavors: sys
Honor SetUID Bits In SETATTR: true
```
```
cm3240c-rtp::> export-policy rule show -vserver vmware -policyname root_policy -ruleindex 1
(vserver export-policy rule show)
Vserver: vmware
Policy Name: root_policy
Rule Index: 1
Access Protocol: nfs <--- like requirement 1, set to nfs or nfs3,nfs4
Client Match Spec: 192.168.1.5
RO Access Rule: sys
RW Access Rule: never <--- this can be never for security reasons
User ID To Which Anonymous Users Are Mapped: 65534
Superuser Security Flavors: sys <--- this is required for VAAI to be set, even in the parent volumes like vsroot
Honor SetUID Bits In SETATTR: true
Allow Creation of Devices: true
```
```
cm3240c-rtp::> nfs modify -vserver vmware -vstorage enabled
```
##### [VASA](#VASA)
VASA — это бесплатное ПО которое позволяет vCenter через API узнавать о возможностях хранилища и более разумно использовать их. VASA интегрируется в VSC и позволяет через GUI интерфейс создавать профили датасторов с определёнными возможностями хранилища (к примеру наличие/отсутствие Thing Provitioning, тип диска: SAS/SATA/SSD, наличие кэша второго уровня и т.д.) и включать уведомления по достижению некого уровня (к примеру занятое пространство или нагрузка). Начиная с версии 6.0 VASA является обязательным компонентом VSC и является важной (и обязательной) частью парадигмы VMware vVOL.
###### Space Reservation — UNMAP
Начиная с ESXi 5.0 поддерживается возврат высвобожденных блоков из тонкого луна (датастора) назад, хранилищу. В версиях ESXi 5.X/6.0 с VMFS необходим ручной запуск для возврата пространства, для ESXi 6.X с vVOL работает автоматически, а начиная с версии 6.5 работает автоматически (с задержкой) на VMFS-6 датасторах. На стороне ONTAP этот функционал всегда по умолчанию выключен, для его [включения необходимо выполнить несколько не сложных команд на СХД](https://habrahabr.ru/post/271959/).
###### vVOL
Эта тема заслуживает особого внимания и [вынесена в отдельную статью](https://habrahabr.ru/post/321366/).
#### [Совместимость](http://habrahabr.ru/post/154205/#compatibility)
Широко [применяйте матрицу совместимости](http://habrahabr.ru/post/154205/#Matrix) в вашей практике для уменьшения потенциальных проблем в инфрастурктуре ЦОД. Для траблшутинга обращайтесь в KB [NetApp](https://kb.netapp.com) и [VMware](http://kb.vmware.com).
Уверен, что со временем мне будет что добавить в эту статью по оптимизации ESXi хоста, так что заглядывайте сюда время от времени.
#### Выводы
Правильные настройки для среды виртуализации VMWare позволят не только повысить производительность вашей инфраструктуры, но и повысить её отказоустойчивость. Обязательно следуйте рекомендациям VMware и NetApp при начальном запуске вашей инфраструктуры. Во время запуска обязательно создайте план тестирования состоящий как из нагрузочного тестирования, так и тестирования отказоустойчивости, для того чтобы устранить возможные ошибки конфигурации и иметь представление о возможностях и поведении вашей инфраструктуры в режиме нормальной работы, и работы при сбоях.
Перевод на английский:
**[ONTAP & ESXi 6.х tuning](https://wp.me/p9LTcx-2B)**
Здесь могут содержаться ссылки на Habra-статьи, которые будут опубликованы позже. Сообщения по ошибкам в тексте прошу направлять в ЛС. Замечания и дополнения напротив прошу в комментарии. | https://habr.com/ru/post/314778/ | null | ru | null |
# Кража закрытых видео YouTube по одному кадру
В декабре 2019 года, спустя несколько месяцев после того, как я занялся хакингом по программе Google VRP, я обратил внимание на YouTube. Мне хотелось найти способ получать доступ к закрытым (`Private`) видео, которыми я не владею.
При загрузке видео на YouTube можно выбрать один из трёх параметров доступа. «Открытый» (`Public`) позволяет находить и просматривать видео любым пользователям, «Доступ по ссылке» (`Unlisted`) позволяет просматривать видео только пользователям, знающим ID видео (URL), «Ограниченный доступ» (`Private`) позволяет просматривать видео только вам или другим аккаунтам, которым дано на это разрешение.
Первым делом я загрузил видео на свой второй тестовый канал аккаунта YouTube и переключил параметры доступа видео на `Private`, чтобы его можно было использовать для тестирования. *(Помните, что тестирование всегда нужно проводить на тех ресурсах/аккаунтах, которыми вы владеете!)* Если я смогу найти способ получить доступ к видео с первого тестового аккаунта, то мы выявим наличие бага.
Я открыл YouTube под первым аккаунтом, проверил каждую функцию и нажал на каждую кнопку, которую смог найти. Каждый раз, когда я видел HTTP-запрос с указанием ID видео, я заменял его на тестовое видео с доступом `Private`, надеясь, что так утечёт какая-нибудь информация о нём, но успеха не добился. Похоже, что основной веб-сайт YouTube (по крайней мере, все его конечные точки, которые я протестировал) всегда проверяет, находится ли видео в состоянии `Private`, и когда пытается выполнить запрос к целевому закрытому видео, он всегда возвращает ошибки наподобие `This video is private!`.
Мне нужно найти другой способ.
В подобной ситуации отличным решением может быть проверка других продуктов/сервисов, не являющихся нашей основной целью, но каким-то образом взаимодействующих внутри с её ресурсами. Если они имеют доступ к ресурсам сайта, то есть вероятность, что у них не реализованы все уровни защиты, которые имеются у основного продукта.
Интересной целью, соответствующей этим требованиям, стал Google Ads. Это продукт, который рекламодатели используют для создания рекламы во всех сервисах Google, *в том числе и на YouTube*. То есть реклама, которую вы смотрите перед видео на YouTube, настраивается рекламодателями здесь, на платформе Google Ads.
Итак, я зарегистрировал аккаунт Google Ads и создал новую рекламу, которая должна воспроизводить для всех пользователей YouTube видео как рекламу с возможностью пропуска. Во время процесса создания рекламы я также повсюду пытался использовать ID целевого закрытого видео, но без малейшего успеха.
После создания рекламы я начал изучать различные функции Google Ads. Это очень масштабный продукт, и он имеет множество различных параметров и инструментов. Я пытался найти что-нибудь связанное с YouTube.
На платформе я нашёл страницу под названием `Videos`, где увидел список видео, используемых для моей рекламы. При нажатии на видео открывается раздел аналитики (`Analytics`) этого видео. В нём я нашёл встроенный проигрыватель, статистику и интересную функцию под названием `Moments`. Она позволяла рекламодателям «помечать» конкретные моменты видео, чтобы, видеть, когда происходят разные вещи (например, метка времени момента появления логотипа компании). Честно говоря, я не совсем понял, зачем рекламодатели используют эту функцию, однако она показалась интересной:
Посмотрев на логи прокси, я заметил, что каждый раз, когда я «помечал момент», передавался `POST`-запрос к конечной точке `/GetThumbnails`. Тело этого запроса содержало ID видео:
> `POST /aw_video/_/rpc/VideoMomentService/GetThumbnails HTTP/1.1
>
> Host: ads.google.com
>
> User-Agent: Internet-Explorer-6
>
> Cookie: [удалено]
>
>
>
> __ar={"1":"kCTeqs1F4ME","2":"12240","3":"387719230"}`
Где в параметре `__ar` значение `1` было идентификатором видео, а значение `2` — временем момента в миллисекундах. В качестве ответа возвращалось изображение в кодировке base64, представлявшее собой миниатюру, используемую платформой Ads.
Я повторил то, что делал уже много раз: заменил в запросе ID на идентификатор закрытого видео второго аккаунта, и, к моему удивлению, **получил в ответ изображение base64**!
Я загуглил «base64 to image» и вставил данные base64 в первый найденный декодер. На изображении **оказалась миниатюра целевого закрытого видео**! Сработало! Я нашёл работающий баг IDOR *(Insecure Direct Object Reference, «незащищённая прямая ссылка на объект»)*, благодаря которому я мог получать кадр из любого видео на YouTube с ограниченным доступом!
Но я подумал: «Хм, это всего лишь один кадр». Мы можем добиться большего.
Я хотел написать скрипт на Python с proof of concept, генерирующий настоящее движущееся «видео». Поискав информацию, я понял, что если видео записано с частотой 24 FPS, то один кадр находится на экране в течение `33` миллисекунд. То есть мне достаточно скачивать каждое изображение, начиная с `0` и выполняя инкремент на `33`, а затем собрать из всех полученных кадров своего рода видео.
Я быстро написал POC, которое скачивает кадры для первых трёх секунд видео, декодирует их, а затем генерирует GIF. Чтобы протестировать код, я запустил его со своим старым видео, к которому заранее ограничил доступ, потому что мне было за него стыдно:
Итак, при помощи этого бага злоумышленник может скачать любое закрытое видео на YouTube, что, на мой взгляд, является достаточно серьёзной угрозой. Но, разумеется, она имеет некоторые ограничения, которые я не смог преодолеть:
* В реальной ситуации вам нужно знать ID целевого видео. Их массовая утечка сама по себе будет считаться багом.
* Так как мы получаем только изображения, доступа к звуку получить не удастся.
* Разрешение очень низкое (но его достаточно, чтобы понять происходящее в видео).
Можно сделать вывод, что всегда стоит обращаться внимание на ситуации, когда два различных продукта имеют внутреннее взаимодействие друг с другом, так как команды разработчиков обоих продуктов лучше знают свою систему и могут упустить важные подробности при работе с ресурсами другого продукта.
Поиск подобных IDOR может быть очень монотонным и кропотливым трудом, и теперь я пытаюсь избегать простых слепых замен ID в надежде на лучшее. Если какое-то время потестировать продукт и понять его внутреннее устройство, то будет эффективнее (и интереснее) попытаться подумать о различных неожиданных действиях, о которых могли не подумать разработчики, или сделать упор на недавно реализованных функциях, или просто заняться чем-то, требующим продуманных действий. Возможно, в долговременной перспективе вам это принесёт больше удовольствия. На мой взгляд, чем больше вы понимаете систему, тем больше идей о её взломе приходит в голову естественным образом.
Но даже в самых надёжных и тщательно протестированных системах есть вероятность того, что простая замена ID в запросе позволит получить критически опасный баг.
### Как развивалась ситуация
[11 декабря 2019 года] — отправлен отчёт о баге
[12 декабря 2019 года] — первоначальный триаж
[20 декабря 2019 года] — баг принят (P4 -> P1)
[08 января 2020 года] — предприняты шаги по устранению бага при помощи временного отключения функции `Moments`
[17 января 2020 года] — выписана награда в размере [5000 долларов](https://www.google.com/about/appsecurity/reward-program/)
[??? ?? 2020 года] — функция `Moments` снова включена, теперь она проверяет наличие доступа к видео.
---
#### На правах рекламы
VDSina предлагает [VDS](https://vdsina.ru/cloud-servers?partner=habr433) с посуточной оплатой, возможностью в пару кликов создать собственную конфигурацию сервера, установить любую операционную систему. Каждый сервер подключён к интернет-каналу в 500 Мегабит и бесплатно защищён от DDoS-атак!
Подписывайтесь на [наш чат в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/cloud-servers?partner=habr433) | https://habr.com/ru/post/562748/ | null | ru | null |
# Обзор языка Idris
> [Agda is too mainstream!](https://twitter.com/puffnfresh/status/409021679398952960)
**«Предвидение»** 
([источник](http://chrisdone.com/posts/prescience))
Материалов о языке Idris на русском практически нет, попробую это исправить кратким обзором. Также постараюсь сделать текст понятным для начинающих, не-функциональных и незнакомых с зависимыми типами программистов, и потому тем, кто знаком с подобными языками, может быть проще отмотать в конец или сразу прочесть официальную документацию. Писать серьёзное введение в язык и теорию не берусь, но надеюсь показать, о чём это вообще.
Итак, Idris — чистый функциональный язык программирования общего назначения с зависимыми типами.
#### Зачем это?
Для краткого ответа подойдёт известная цитата Дейкстры; хотя подход и изменился с тех пор, цель осталась та же:
> Глубоко ошибается тот, кто думает, что изделиями программистов являются программы, которые они пишут. Программист обязан создавать заслуживающие доверия решения и представлять их в форме убедительных доводов, а текст написанной программы является лишь сопроводительным материалом, к которому эти доказательства применимы.
Если же быть более точным, то причин для создания и использования может быть несколько: автор, Edwin Brady, использует его для исследования прикладного программирования с зависимыми типами; многим, как и мне, нравится возможность составления точных спецификаций программ; также я надеюсь на значительное сокращение времени отладки прикладных программ посредством формальной верификации оных. И здесь напрашивается вторая цитата:
> Тестирование программы может весьма эффективно продемонстрировать наличие ошибок, но безнадежно неадекватно для демонстрации их отсутствия.
#### Статическая типизация и зависимые типы
Один из способов классификации типизации языков программированния — разделение на статическую и динамическую. При динамической типизации, типы неизвестны во время компиляции, и потому не могут быть проверены; это помогает писать программы быстрее, но в то же время и добавляет класс ошибок, связанных с типизацией, которые выявляются во время выполнения программы, что обычно не очень приятно. Idris использует статическую типизацию, так что дальше речь пойдёт только о ней; но чтобы не пугать людей, привыкших к динамической типизации, сразу замечу, что используется также и [вывод типов](https://ru.wikipedia.org/wiki/Вывод_типов), т.е. типы можно не указывать явно, если они очевидны компилятору из контекста.
Типизация может ограничиваться несколькими примитивными типами — например, строки, числа, числа с плавающей запятой; тогда всё, что мы можем «сказать» о типе некоторого значения (например, аргумента функции, или возвращаемого ею значения) — *«строка»*, *«число»*, *«число с плавающей запятой»*. Но обычно это дополняется чем-то вроде структур: простые C-подобные структуры, классы, (обобщённые) алгебраические типы данных и пр., и заодно синонимами типов (`typedef` в C, `type` в Haskell), что уже позволяет «сказать», например, *«дата»*, предварительно определив структуру, класс или тип «дата».
Можно дополнить это фразой *«указатель на»*, что заодно позволяет использовать массивы, но в высокоуровневых языках чаще поддерживается [обобщённое программирование](https://ru.wikipedia.org/wiki/Обобщённое_программирование) (шаблоны в C++, generics в Java), что уже позволяет строить для описания типов фразы вида *«список дат»*, *«граф дорог»*, *«дерево событий»*. Другими словами, типы могут быть параметризованы другими типами.
И, наконец, можно параметризовать типы значениями, что даёт возможность сказать *«список, состоящий из пяти строк»*, *«сообщение, подписанное Василием»*; типы функций тогда могут принимать вид *«функция, принимающая сообщение, подписанное некоторым пользователем, и возвращающая данные этого пользователя»*, вместо более распространённого *«функция, принимающая сообщение и возвращающая данные пользователя»*, что ведёт к намного более точным спецификациям. Более того, это даёт возможность, так сказать, перейти от подлежащих к сказуемым, использовать принцип «высказывания как типы»: *«5 больше 3»*, *«неверно, что 5 больше 3»*, *«7 является простым числом»*, *«Василий получил 2 сообщения»*. Это и есть [зависимые типы](https://ru.wikipedia.org/wiki/Зависимый_тип), которые реализованы в Idris, как, впрочем, и в нескольких других языках (Agda, Coq, Epigram и т.д.), но от них Idris отличает стремление быть современным прикладным языком.
Также это, в условиях total functional programming, позволяет пользоваться соответствием между компьютерными программами и математическими доказательствами ([соответствием Карри – Ховарда](https://ru.wikipedia.org/wiki/Соответствие_Карри_—_Ховарда)): типом функции может быть, например, *«А меньше Б, Б меньше В, значит А меньше В»* или *«сообщение отправлено некоторому пользователю, значит данному пользователю доступно данное сообщение»*; доказательством тогда становится тело функции, которое просто должно вернуть значение заданного типа, а проверка доказательства — это и есть проверка типов.
#### Total functional programming
Как было сказано, Idris — [чистый функциональный язык](https://ru.wikipedia.org/wiki/Чистота_языка_программирования). Но также поддерживается опциональное требование свойства totality функций, под которым подразумевается два свойства:
1. Определённость всюду: функция должна быть определена для любых входных данных. В чистых языках отсутствие этого свойства — едва ли не единственная возможность для программы «упасть» (другие — IO, в частности убийство процесса системой вследствие каких-то его действий, и возможные баги компилятора).
2. Строгая нормализация: при рекурсивных вызовах функции, хотя бы один из её аргументов должен строго уменьшаться (структурно), либо функция должна быть продуктивна на каждой итерации — т.е. возвращать какую-то часть результата, и обещание просчитать следующую итерацию. В первом случае это гарантирует завершаемость функции, обходя проблему остановки, а во втором — возможность считать конечный префикс любой длины за конечное время.
Важно это, в первую очередь, для построения доказательств, но и корректности обычных программ идёт на пользу, судя по моим наблюдениям. К слову, наличием этого свойства гарантируется, что результат ленивых и жадных вычислений данной функции будет одинаков, а вычисления в Idris по умолчанию жадные, но любой аргумент можно сделать ленивым.
Включать эту опцию можно для отдельных функций, для файлов, или флагом компилятора.
#### Примеры
Непривычный синтаксис, похоже, сильно отвлекает внимание от сути описываемого, и потому описывать синтаксис не буду; примеры кода приводятся для людей, знакомых с языками семейства ML, а для остальных приводятся текстовые описания перед этими примерами.
##### Деление
Знакомая всем операция, которая есть практически во всех языках программирования (или в их стандартных библиотеках) — деление. Но деление на 0 запрещено, что ведёт к различным спорным решениям:
* Вернуть что-нибудь специальное, вроде Infinity: тогда мы должны определить и правила для работы всех остальных функций/операций с Infinity, что усложняет арифметику в целом, но, например, простое свойство a / b = c → b \* c = a будет утеряно, и далее попытка его использования запросто приведёт к результатам, отличным от ожидаемых.
* Породить исключение: это не только приводит к нарушению нормального потока выполнения программы, заодно опять-таки создавая почву для багов при непойманных исключениях, но и значительно затрудняет рассуждение (в частности, формальное) о функциях, если не делает его невозможным.
* Обернуть результат в [Maybe](https://en.wikipedia.org/wiki/Option_type), возвращая Nothing при попытке деления на 0: чем-то лучше предыдущих двух, разве что сама функция не будет стимулировать программиста писать корректные программы, а формулы могут стать менее аккуратными и/или излишне насыщенными теорией категорий, попутно затрудняя рассуждения о функциях, использующих такую реализацию деления.
В языках с зависимыми типами, и в Idris в частности, появляется ещё один вариант: запретить деление на 0. Другими словами, деление на 0 запрещено — и мы просто делаем его невозможным; тип функции тогда описывается как «функция, принимающая два числа, второе из которых не равно 0, и возвращающая число». При желании, можно дополнить эту спецификацию свойством, говорящим о связи возвращаемого значения с аргументами функции, т.е. "… такое, что...", но проще это оставить для отдельных теорем, а пока вернёмся к описанию типа функции деления: к обычным двум аргументам, нам нужно добавить третий — доказательство того, что второй аргумент не равен нулю.
Теперь рассмотрим три случая использования деления (напомню, что речь идёт о времени компиляции):
1. Делитель известен: доказательство тривиально, поскольку эквивалентность натуральных чисел разрешима (другими словами, компилятор сам видит, равен делитель нулю или нет), и потому мы можем, при желании, обернуть такую функцию деления в функцию с обычными двумя аргументами, подставляющую один и тот же простой третий аргумент.
2. Делитель неизвестен, но о нём известно что-то, что позволяет убедиться в том, что он не равен нулю: например, что он больше некоторого неотрицательного числа. Тогда нужно или написать доказательство на месте, или воспользоваться функцией, принимающей то, что у нас есть (доказательство того, что число больше некоторого неотрицательного числа), и возвращающей то, что нам нужно (доказательство того, что это число не равно нулю). Такие функции можно называть как просто функциями, так и леммами или теоремами, но, как уже было упомянуто, в данном контексте это одно и то же.
3. Мы сами не уверены в том, что делитель не будет равен нулю (после внимательного рассмотрения ситуации в попытке доказать неравенство, предыдущий случай может переходить в этот): только в этом случае нам действительно нужно ввести проверку перед делением; если делитель равен нулю, то использовать альтернативное решение, а в противном случае — воспользоваться полученной информацией и выполнить деление.
Такой подход, конечно, необязателен и в Idris, но заставляет программиста убедиться в том, что он выполняет расчёты корректно.
И, наконец, пример кода — каркас для функции деления:
```
-- (total) функция деления для натуральных чисел
-- "==" - функция проверки разрешимой эквивалентности, возвращающая Bool
-- "=" - эквивалентность высказываний, тип
total div : (n, m: Nat) -> ((m == Z) = False) -> Nat
-- деление на 0 - невозможно; просто показываем это компилятору
-- с тем же успехом, впрочем, можно и вернуть любое число
div n Z f = FalseElim $ trueNotFalse f
-- деление на положительное число
div n (S k) f = {-todo-}?div_rhs
```
Поскольку это только каркас, здесь использована мета-переменная, `div_rhs`; людям, знакомым с Agda, уже знакомы «дырки» (holes), более слабой версией которых мета-переменные в Idris являются, а для остальных поясню: Idris позволяет посмотреть её контекст (переменные, которые видны из её позиции) и цель (что должно быть сконструировано/возвращено из данной позиции), что заметно облегчает написание как доказательств, так и программ. Вот так он выглядит в данном случае:
```
n : Nat
k : Nat
f : S k == 0 = False
--------------------------------------
div_rhs : Nat
```
Также есть возможность заполнять их полу-автоматически: имея цель вернуть `Nat`, можно воспользоваться командой (REPL/IDE) «refine», передав ей, например, имя функции `plus`, и если функция `plus` в состоянии вернуть значение требуемого типа, то она будет подставлена вместо этой мета-переменной, а для её аргументов будет подставлено две новых меты. Процесс это тот же, который используется и для другой функции — полностью автоматической замены мета-переменных, т.е. поиском доказательства: в некоторых случаях требуемое доказательство может быть найдено автоматически.
Типы (немного подредактированы для читабельности):
```
λΠ> :t div
div : Nat -> (m : Nat) -> (m == 0 = False) -> Nat
```
```
λΠ> :t div 1 2
div 1 2 : (2 == 0 = False) -> Nat
```
```
λΠ> :t div 1 2 refl
div 1 2 refl : Nat
```
```
λΠ> :t div 1 0 refl
(ошибка, программа с подобным вызовом не пройдёт проверку типов)
```
Теперь отвлечёмся от реализации функции деления и посмотрим, что такой подход нам даёт. Начнём с вышеупомянутой корректности: функция работает именно так, как должна. Мы можем думать о функции так, как обычно думаем о том, что ею реализуется (арифметическое действие, в данном случае: мы не можем делить на ноль, но в процессе деления никакие концепции наподобие исключений не участвуют, а результатом является число). Можем рассуждать о функции так же, как о самой представляемой ею концепции, в том числе и формально, т.е. записывая рассуждения кодом. В функциях, использующих её, рассуждения и выводы теперь могут переплетаться с вычислениями и быть проверены, а не оставаться в голове программиста или текстовых комментариях. И программа становится конструкцией из корректных рассуждений и решений, а не просто рецептом для вычислений.
##### Списки
Работа со списками (или массивами) — ещё одна частая задача, приводящая примерно к тому же набору спорных решений и последующих ошибок. В частности, рассмотрим функцию, возвращающую энный элемент списка: проблема при её реализации состоит в том, что мы можем запросить элемент с позиции, которой нет в списке. Обычные решения — падать с «access violation» или «segmentation fault», порождать исключение (и, возможно, потом падать с ним), использовать Maybe.
В языках с зависимыми типами появляется ещё пара возможных решений. Первое — аналогично решению проблемы деления на ноль, т.е. последним аргументом функции становится доказательство того, что запрашиваемая позиция меньше длины списка.
Здесь можно заметить, что различные числа, списки, «if-then-else» и т.п. определяются на самом языке. Натуральные числа, реализованные в библиотеке, заменяются на GMP числа при компиляции в C, а такие функции, как сложение и умноженние — на соответствующие функции GMP, что даёт и быстрые расчёты в скомпилированных программах, и возможность рассуждать о них. Теперь взглянем на код:
```
data Nat = Z | S Nat
data List a = Nil | (::) a (List a)
length : List a -> Nat
length [] = 0
length (x::xs) = 1 + length xs
index : (n : Nat) -> (l : List a) -> (ok : lt n (length l) = True) -> a
index Z (x::xs) p = x
index (S n) (x::xs) p = index n xs ?indexTailProof
index _ [] refl impossible
indexTailProof = proof {
intros;
rewrite sym p;
trivial;
}
```
`indexTailProof` — доказательство с использованием тактик, в стиле Coq, но можно (и мне чем-то больше нравится) писать их и в стиле Agda, т.е. более привычными функциями (говорят, правда, что скоро тактики будут и в Agda).
Второе решение — использовать не просто список, а список фиксированной длины: вектор, как его называют в контексте языков с зависимыми типами. Пример был упомянут выше: это то, что позволяет сказать «список из пяти строк». Также нам может помочь т.н. конечный тип — то есть тип, количество различных значений которого конечно: можем рассматривать его как тот же тип натуральных чисел, но с верхней границей. Удобен этот тип в частности тем, что с ним проще сказать «число, меньшее n», чем с натуральными числами, где это скорее «число, и оно меньше n». Тип функции получения энного элемента вектора тогда читается как «функция, принимающая число, меньшее чем n, и список из n элементов типа a, и возвращающая элемент типа a».
В таком случае, задачей становится не предоставить доказательство, а сконструировать число нужного типа (т.е. меньшее, чем n). К слову, логика в доказательствах здесь отличается от классической (является интуиционистской), и заключается в конструировании доказательств, то есть доказательством высказывания/типа является любое значение данного типа, так что некоторое сходство с предыдущим подходом проследить можно, но в то же время подход к написанию программы в целом это меняет.
Код:
```
data Fin : (n : Nat) -> Type where
fZ : Fin (S k)
fS : Fin k -> Fin (S k)
data Vect : Nat -> Type -> Type where
Nil : Vect Z a
(::) : (x : a) -> (xs : Vect n a) -> Vect (S n) a
index : Fin n -> Vect n a -> a
index fZ (x::xs) = x
index (fS k) (x::xs) = index k xs
-- запросить что-либо из пустого вектора невозможно, в данном случае
-- компилятор это "видит" сам
index fZ [] impossible
```
Так мы уходим ещё дальше от явных доказательств, но строим, тем не менее, корректные программы.
Ну а раз уж добрались до векторов, то вот и функция их объединения, часто приводимая в пример для демонстрации зависимых типов:
```
(++) : Vect m a -> Vect n a -> Vect (m + n) a
(++) [] ys = ys
(++) (x::xs) ys = x :: xs ++ ys
```
Тело то же, что и для обычных списков, но тип поинтереснее: обратите внимание на `m + n`.
#### Примеры побольше
Выше приведены примеры отдельных небольших функций, которые Idris помогает сделать корректными, но вот несколько более крупных вещей навскидку:
* Протоколы: есть библиотека [Protocols](https://github.com/edwinb/Protocols), позволяющая описывать протоколы с использованием DSL, а затем реализовывать их; несоответствие реализации описанию протокола приведёт к ошибке.
* [Физика](https://github.com/timjb/quantities) и [игры](https://github.com/edwinb/idris-demos): не только поддерживается корректность вычислений, но и полезно доказывать теоремы уже после написания основных программ.
* Законы функторов, аппликативных функторов и монад [могут быть включены в код](https://github.com/reynir/Verified), в сами тайпклассы.
* [Криптография](https://github.com/idris-hackers/idris-crypto): очевидный пример того, корректность чего важна.
* Разбор и составление текстовых/бинарных форматов: может быть формально доказано, что любые составленные строки разбираются в исходные данные, а разобранные данные — составляются в исходные строки. Примерно это я и выбрал в качестве первого проекта на Idris.
* Системы прав доступа, базы данных, драйверы устройств — реализаций на Idris пока не видел, но тоже вещи, которые хочется видеть надёжными.
Пишется на нём и [веб-фреймворк](https://github.com/idris-hackers/IdrisWeb), и [библиотека для взаимодействия с DOM](https://github.com/idris-hackers/iQuery) (кстати, на момент написания статьи компилятор поддерживает компиляцию в C, LLVM, Java и JavaScript), и всяческие парсеры ([раз](https://github.com/ziman/lightyear), [два](https://github.com/tauli/idris-monadic-parser)), и на системное программирование он нацелен. Переписываются программы с Haskell на Idris достаточно просто.
Не используется Idris пока на производстве — по крайней мере, широко (слышал, что в Potsdam Institute for Climate Impact Research он активно используется, но это, возможно, не совсем то, что обычно понимается под производством). Основная техническая преграда — «необкатанность», которая должна решиться «обкатыванием».
#### Заключение
Язык это новый, и потому «сырой», но современный, использующий современную теорию и накопленную другими языками практику.
Позволив себе немного помечтать о будущем использовании Idris (и языков, которые появятся после него), можно представить, помимо общего повышения надёжности программ, технические задания, сопровождаемые формальными спецификациями или даже состоящие из них; рост сервисов наподобие [Proof Market](https://proofmarket.org/); библиотеки физических, математических, да и любых других теорий, и языков наподобие Lojban; статьи и книги как списки формальных спецификаций доказанных теорем; общение, выстраиваемое из автоматически проверяемых реплик и пар вопрос-ответ в частности.
#### Ссылки и книги по теме
* [Официальный сайт](http://www.idris-lang.org/) с документацией и ссылками;
* [github wiki](https://github.com/idris-lang/Idris-dev/wiki);
* [Скринкасты](http://www.youtube.com/watch?v=0eOY1NxbZHo&list=PLiHLLF-foEexGJu1a0WH_llkQ2gOKqipg&feature=share) с использованием [idris-mode](https://github.com/idris-hackers/idris-mode) (есть, кстати, и [idris-vim](https://github.com/idris-hackers/idris-vim));
* [Software Foundations](http://www.cis.upenn.edu/~bcpierce/sf/current/index.html) — хорошее введение в языки с зависимыми типами, но использующее Coq;
* [Type Theory and Functional Programming](https://www.cs.kent.ac.uk/people/staff/sjt/TTFP/) — описание теории, лежащей в основе подобных языков;
* TaPL, книги по Haskell и документация Agda могут дополнить картину.
#### P.S.
Спасибо тем, на ком этот обзор тестировался, за их комментарии и идеи. | https://habr.com/ru/post/228957/ | null | ru | null |
# Symfony 2.0 краткий обзор, часть 2
Итак, продолжаю осмотр фреймворка Symfony 2.0. В [первой части](http://habrahabr.ru/blogs/symfony/89134/) я описал содержимое приложения symfony-sandbox созданного на базе Symfony 2.0. В этой части я загляну в содержимое самого фреймворка.
Перейдя в директорию `src/vendor/symfony/src/Symfony` приложения, увидим три директории:
* Components
* Foundation
* Framework
В первой части я писал, что сам фреймворк — это набор «бандлов» в этом легко убедиться заглянув в директорию `Framework`, в которой находятся:
* `Framework/DoctrineBundle`: это Doctrine ORM
* `Framework/ProfilerBundle`: это друг разработчика — toolbar
* `Framework/SwiftmailerBundle`: Swift mailer
* `Framework/WebBundle`: web, templating, user
* `Framework/ZendBundle`: Zend library, сейчас используется Zend\_Log
WebBundle пожалуй самый большой «бандл» из доступных на данный момент. Здесь и Controller от которого наследуется контроллер приложения, и класс User и сессии и templating и util и skeleton для приложения и для «бандла». В общем интересно в него заглянуть, но не в этот раз.
Содержимое `Foundation` похоже на базовую библиотеку кода, т.е. здесь содержится код, позволяющий всему этому чуду работать как надо. В частности базовый класс ядра, «бандл» ядра, EventDispatcher, универсальный автозагрузчик классов, абстрактный класс Bundle реализующий интерфейс BundleInterface, от которого неследуются все «бандлы».
Ну и содержимое `Components` — это те самые [компоненты](http://components.symfony-project.org/), но написанные в стиле PHP 5.3. На данный момент доступны:
* Components/Console
* DependencyInjectionContainer
* EventDispatcher
* OutputEscaper
* RequestHandler
* Routing
* Templating
* Yaml
Вот чего пока нет из нужного, так это суб-фреймворка Forms.
Итак, если кратко, то работает это примерно так: при обращении к фронт контроллеру `web/index.php` создается экземпляр класса ядра приложения в нашем случае `HelloKernel`, который расширяет класс `Symfony\Foundation\Kernel`. При создании объекта в конструктор класса передаются два параметра название окружения и флаг включения отладки true или false. В конструторе класса вызываются методы регистрации «бандлов», регистрации путей поиска «бандлов», регистрации корневой директории приложения и определяется имя самого приложения. После чего во фронт контроллере вызывается метод `run()` в котором и происходит основная работа. И опять же если кратко, то основная работа выглядит так: выполняется метод `boot()` в котором инициализируется DI контейнер (Dependency Injection Container), при инициализации вызываются методы построения контейнера всех подключенных «бандлов». После этого вызывается метод загрузки настроек приложения. Затем весь этот построенный и сформированный контейнер записывается в кеш в виде класса, чтобы не строить его при каждом запросе, подключается файл из кеша и создается экземпляр этого сформированного класса контейнера.
После этого вызывается метод `boot()` всех подключенных «бандлов». Затем из контейнера вытаскивается объект запроса, по дефолту это объект класса `Symfony\Components\RequestHandler\Request`. А затем из контейнера вытаскивается объект обработчика запроса, по дефолту это объект класса `Symfony\Components\RequestHandler\RequestHandler`, у которого вызывается метод `handle()` и в качестве параметра ему передается уже полученный объект запроса. Метод `handle()` должен вернуть объект ответа `Symfony\Components\RequestHandler\Response` у которого в свою очередь вызывается метод `send()`, который отвечает за отправку ответа (заголовков и тела). Вот если коротко и грубо, то этим и ограничивается работа ядра. Все остальное лежит на плечах «бандлов».
Каждый «бандл» должен иметь класс реализующий интерфейс `Symfony\Foundation\BundleInterface` в котором определено всего два метода `buildContainer(ContainerInterface $container)` регистрирующий в контейнере параметры и сервисы и `boot(ContainerInterface $container)` который отвечает за загрузку «бандла», загрузка осуществляется уже после того как все параметры и сервисы всех «бандлов» определены в DI контейнере. Большинство «бандлов», а именно все «бандлы» из `Symfony/Framework` расширяют класс `Symfony\Foundation\Bundle` и перекрывают лишь метод `builderContainer` для определения в контейнере своих настроек и сервисов.
Для примера как можно использовать метод `boot()` класса `Bundle`. По дефолту в «бандле» WebBundle используется шаблонный движок на базе `Symfony\Components\Templating`. Но сервис `templating.engine` в WebBundle определен таким образом, что не позволяет передать в конструктор свои классы Renderer'а, в то время как `Symfony\Components\Templating\Engine` в конструкторе вторым параметром принимает массив кастомных Renderer'ов. Но благодаря использованию Dependency Injection Container это легкое недоразумение легко исправляется. Для этого в нашем приложении в файле `src/Application/HelloBundle/Bundle.php` в классе `Bundle` определим метод:
```
public function boot(ContainerInterface $container)
{
$container->getTemplatingService()->setRenderer('name', new Renderer());
}
```
где класс `Renderer` — наш кастомный рендерер, а `'name'` имя этого рендерера. Теперь при отображении шаблонов можно использовать свой собственный рендерер.
Во всем этом обзоре, я практически не затронул работу из консоли. Внешне все осталось почти так же, за тем исключением, что теперь консольный контроллер создается на уровне приложения, а не на уровне всего проекта, как это было в Symfony 1.x. Но внутри произошли серьезные перемены, появились дополнительные возможности, подробнее с которыми можно познакомиться изучая `Components/Console`. Появилась и еще одна интересная возможность — Symfony shell. Достаточно запустить `hello/console -s` и запустится интерактивный консольный сеанс, проще говоря **Symfony shell** позволяющий выполнять теже самые команды.
Вот в общем и завершился краткий обзор Symfony 2.0. Фреймворк конечно еще сырой, в некоторых ситуациях возникают неожиданные ошибки, некоторых вещей еще нет. Но разработчики фреймворка призывают попробовать и высказать свои пожелания, мнения ну и баг-репорты конечно тоже. Так что велкам!
Ну а я попробую сделать краткие обзоры о Symfony/Components. | https://habr.com/ru/post/89157/ | null | ru | null |
# Как провести Testing Dojo
Есть такая штука — Testing Dojo. Это соревнования, где участники ищут баги в приложениях. Кто больше найдёт — тот и победил. Обычно соревнуются командами. Если баги приходится искать вручную, участвуют только тестировщики. Если в бой идут автотесты, подключаются разработчики.
В 2ГИС Testing Dojo уже давно стал доброй традицией: проводим его третий год подряд. За это время мы много поняли о том, как делать лучше. Под катом поделимся опытом: вдруг и вы захотите сделать свой Testing Dojo.
### Правила
Есть N команд по 2—3 человека. Каждая команда сидит за компьютером: один кодит, а другие помогают советами. Все участники тестируют одно и то же приложение при помощи автотестов.
Соревнования делятся на шесть сессий по тридцать минут. Каждая «сессия» имитирует релиз приложения. В каждом релизе есть новые фичи и новые и/или старые баги: всё как в реальном продукте.
Тесты команд выполняются в конце сессии на Continous integration сервере. По результатам тестов жюри подсчитывает баллы. За каждый баг, который найдёт команда, жюри начисляет очки. За каждый пропущенный — вычитает. Победителя выбирают по сумме баллов за все шесть сессий.
По таким правилам «играем» мы. Для своего Testing Dojo меняйте правила как захочется. Главное, чтобы все их понимали и, желательно, были с ними согласны.
### Что подготовить
1. Тестовое приложение.
2. Рабочие места участников с ПО, на котором пишут и запускают тесты.
3. Репозитории команд.
4. CI сервер для автоматизированных сборок.
Теперь расскажем обо всем по порядку и приведём примеры с Testing Dojo, который мы провели [6 июня](http://techno.2gis.ru/event/testingdojo).
### Тестовое приложение
Когда мы подбирали тестовое приложение, руководствовались несколькими принципами.
1. Приложение простое.
Чрезмерная сложность сильно замедляет разработку тестов: участники тратят много времени, чтобы разобраться с функционалом. Поэтому для нашего Testing Dojo не подходил вариант «взять какой-нибудь продукт 2ГИС и добавить в него багов».
2. Функционал приложения хорошо разделяется на отдельные фичи.
Каждую фичу описываем в виде очень короткой спецификации.
3. Некоторые баги встречаются только в одной сессии, а другие повторяются.
Так уже готовые тесты приносят баллы в последующих сессиях.
4. Приложение с нужным функционалом быстро собирается и обновляется.
Функционал соответствует номеру релиза.
Для последнего Testing Dojo мы написали достаточно примитивный каталог товаров. В его первой версии был только строгий поиск по части названия. В последней — управление товарами.
Актуальную версию приложения собирали и деплоили на тестовые ноды сервера Jenkins в конце каждой сессии. В начале следующей сессии участники обновляли приложение до последней релизной версии.
Скрипт для обновления:
```
$appLink = 'http://opensource-ci.2gis.ru/view/Testing%20Dojo/job/td-tested-application/lastSuccessfulBuild/artifact/TestingDojo2015.exe'
$outFolder = $env:UITestApps
if ($outFolder -eq $null) { $outFolder = 'C:\app' }
$outFile = (Join-Path $outFolder 'TestingDojo2015.exe')
if (Test-Path $outFolder)
{
Remove-Item $outFile -Force
}
else
{
New-Item -ItemType directory -Path $outFolder | Out-Null
}
try
{
Invoke-WebRequest $appLink -OutFile $outFile
Write-Host 'Update successful!'
}
catch
{
Write-Error $_.Exception.ToString()
Write-Host 'Update failed!'
}
Write-Host "Press any key to exit.."
$Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyUp") > $null
```
Информация о фичах текущей версии (размещали её на страничке мероприятия):
> Версия 5. Фичи
>
> Добавлена возможность одновременного удаления несколько записей. Выбрать несколько записей одновременно можно удерживая клавишу Ctrl или Shift. Удаление происходит по нажатию кнопки “Удалить несколько”, которая появляется при одновременном выборе более одного элемента.
>
> Сортировать записи можно как по идентификатору, так и по названию. Нужное поле сортировки можно выбрать из выпадающего списка. Порядок сортировки изменяется с помощью переключателя.
Информация для жюри о новых и исправленных багах:
> Версия 5. Баги
>
> Починился баг с сортировкой
>
> Починился поиск
>
> Если через Ctrl выделить несколько записей то удаляются все кроме последней
Выбирайте для соревнований простое приложение с понятным функционалом. Позаботьтесь о том, чтобы большую часть времени участники искали баги и писали автотесты, а не читали документацию.
### Рабочие места
Если вы правильно обустроили рабочие места — считайте, что уже наполовину сделали хорошее мероприятие. Любые проблемы с техникой или ПО сдвигают старт соревнований и действуют участникам на нервы.
Для последнего Testing Dojo мы подготовили аудиторию на 10 рабочих мест. Рассчитывали на 20 тестировщиков и разработчиков из разных компаний Новосибирска.
Соревнования мы посвятили тестированию desktop-приложений для Windows, поэтому предложили участникам писать на Selenium-based драйвере [Winium.Desktop](http://github.com/2gis/Winium.Desktop). Это обёртка над нашим opensource-инструментом [Cruciatus](http://habrahabr.ru/company/2gis/blog/220337/), расскажем о ней в отдельной статье.
Благодаря Winium.Desktop, мы пишем тесты на разных языках программирования. Для Testing Dojo выбрали C# и Python 3.x и подготовили для них среду. На каждый компьютер с Windows 8 поставили Visual Studio (+ Resharper) и PyCharm.
С особым вниманием настраивали профиль пользователя системы. На рабочем столе и стартовой странице разместили ярлыки на IDE, тестируемое приложение, скрипт по автоматическому обновлению приложения и инструменты анализа пользовательского интерфейса desktop-приложений. В браузере вбили стартовые страницы на самые необходимые ресурсы.
Пользователей создавали скриптом:
```
# Set-ExecutionPolicy -ExecutionPolicy Unrestricted
$hostName = [System.Net.Dns]::GetHostName()
$cultureLCID = (Get-Culture).LCID
$userName = "testingdojo"
$userPassword = "2gisTD2015"
# 1033 - English, 1049 - Russian
# https://msdn.microsoft.com/en-us/goglobal/bb964664.aspx?f=255&MSPPError=-2147217396
if ($cultureLCID -eq 1049) { $rdpGroupName = "Пользователи удаленного рабочего стола" }
elseif ($cultureLCID -eq 1033) { $rdpGroupName = "Remote Desktop Users" }
else { Write-Host "Unknown LCID:"$cultureLCID; return }
# add user
# http://blogs.technet.com/b/heyscriptingguy/archive/2014/10/01/use-powershell-to-create-local-users.aspx
# https://msdn.microsoft.com/en-us/library/aa772300%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396
$comp = [ADSI] "WinNT://$hostName"
$user = $comp.Create("user", $userName)
$user.SetPassword($userPassword)
$user.UserFlags = 64 + 65536 # ADS_UF_PASSWD_CANT_CHANGE + ADS_UF_DONT_EXPIRE_PASSWD
$user.SetInfo()
# add user to Remote Desktop Users group
# http://blogs.technet.com/b/heyscriptingguy/archive/2014/10/03/adding-local-users-to-local-groups.aspx
$group = [ADSI] "WinNT://$hostName/$rdpGroupName,group"
$group.Add("WinNT://$hostName/$userName, user")
```
За каждым рабочим местом закрепили название команды. Чтобы быстрее подготовить рабочее окружение на компьютерах и облегчить жизнь участникам, названия команд придумали сами.
Для этого заглянули на полки IKEA и нашли забавные ничего не значащие (надеемся) слова: «duken», «kokbanan», «risdal», «morvik»…
Итак, проследите за рабочими местами участников. Убедитесь, что установили необходимое ПО, вбили пароль от Wi-Fi и поставили тестовое приложение.
### Репозитории команд
Для командных репозиториев мы подготовили шаблоны проектов и powershell-скрипт, который пушит их во все репозитории автоматически. Оба шаблона попадали в репозиторий, так как мы не знали, какой язык выберет команда.
Репозитории склонировали на компьютеры соответствующих команд, настроили глобальный конфиг и проверили, что есть права на push.
Если интересно, гляньте репозитории команд на [Гитхабе](https://github.com/2gistestingdojo).
### Автоматизированные сборки
Для каждой команды мы настроили сборку на [Jenkins](http://opensource-ci.2gis.ru/).
Тут же выполнялась сборка тестируемого приложения. При необходимости команды прогоняли тесты и узнавали, в каком они состоянии. Но независимо от состояния тестов, мы запускали сборку в конце сессии и считали баллы.
### Что в итоге
Если планируете провести Testing Dojo, определитесь с темой мероприятия. После этого решите, какое приложение и каким инструментом протестируют участники. Выбирайте простое приложение с понятным функционалом.
Подготовьте для участников рабочие места: настройте права доступа для пользователей на компьютерах, установите необходимое ПО, разместите на рабочем столе ярлыки, дайте доступ к системе контроля версий.
Чтобы исключить человеческий фактор, автоматизируйте ручные операции: подготовку репозиториев для тестов, сборку и деплой приложения на тестовые сервера, обновление приложения в каждой сессии.
Эти правила — неплохая база для хорошего мероприятия. Используйте их, чтобы сделать свой Testing Dojo. Уверена, у вас всё получится! | https://habr.com/ru/post/263157/ | null | ru | null |
# Веб-технологии, которые могут работать не так, как ожидается
Веб-технологии постоянно развиваются, а у разработчиков появляется возможность создавать всё более качественные и совершенные онлайн-проекты. Правда, бывает так, что какие-то новые веб-возможности работают не так, как того можно было бы ожидать. Это может касаться сфер юзабилити, безопасности, приватности.
[](https://habr.com/ru/company/ruvds/blog/575350/)
Я попадал в такие ситуации. Например, при использовании механизма [ленивой загрузки](https://css-tricks.com/a-native-lazy-load-for-the-web-platform/) в HTML. Соответствующий атрибут очень легко добавить в разметку, описывающую изображение, сделав это только для того, чтобы понять… что для работы ленивой загрузки нужно и кое-что ещё. Здесь мы поговорим и об этой проблеме, и ещё о некоторых возможностях, доступных веб-разработчику, которые могут работать не совсем так, как ожидается.
Ссылки с псевдоклассом :visited обладают ограниченными возможностями стилизации, а getComputedStyle сообщает недостоверные сведения об их стилях
------------------------------------------------------------------------------------------------------------------------------------------------
Это ограничение существует уже довольно давно, но оно является хорошим примером того, как злоумышленники могут эксплуатировать возможности браузеров в своих целях. Один из вариантов такой эксплуатации заключался в следующем. Тегу назначался стиль ссылки с псевдоклассом `:visited` и соответствующий элемент выводился за пределами видимой области страницы. После этого можно было воспользоваться JavaScript для изменения атрибута `href` данного элемента и для проверки того, приводит ли конкретное значение `href` к изменению внешнего вида ссылки на такой, каким бы он был, если бы пользователь уже посещал соответствующую страницу. Эти действия позволяли реконструировать историю посещённых страниц.
Было время, когда эта проблема, известная как «[CSS History Leak](https://blog.mozilla.org/security/2010/03/31/plugging-the-css-history-leak/)», распространилась настолько широко, что Федеральная торговая комиссия (Federal Trade Commission, FTC — агентство правительства США, призванное защищать права потребителей), ввела серьёзные [штрафы](https://www.ftc.gov/news-events/press-releases/2012/12/ftc-settlement-puts-end-history-sniffing-online-advertising) за эксплуатацию данной уязвимости.
В наши дни попытка использования `getComputedStyle` для ссылки с псевдоклассом `:visited` возвращает не `:visited`-стиль, соответствующий посещённой ссылке, а стиль обычной ссылки (`:link`). Это — лишь один из примеров особенностей веб-технологий, о которых нужно знать, так как реальное поведение элементов отличается от того, которого можно было бы ожидать на чисто интуитивном уровне.
[Вот](https://codepen.io/faraixyz/pen/zYwBoMK) пример, демонстрирующий факт возврата одних и тех же вычисленных стилей для непосещённой и посещённой ссылки.
*Вычисленные стили непосещённой и посещённой ссылки выглядят одинаково*
Есть два подхода, которые можно попытаться использовать для того чтобы обойти это ограничение, но ни тот ни другой, на практике, не работают.
1. Можно сделать так, чтобы применение стиля к посещённой ссылке приводило бы к побочным эффектам (например — к сдвигу макета).
2. Можно задействовать CSS-селекторы для выбора смежных элементов (`~` или `+`) или дочерних элементов (`>`) и их стилизации.
Существуют остроумные (но ненадёжные) [способы](https://josephpetitti.com/blog/how-css-can-leak-your-browser-history) воспользоваться побочными эффектами, но доступные [способы стилизации :visited-ссылок](https://developer.mozilla.org/en-US/docs/Web/CSS/Privacy_and_the_:visited_selector#limits_to_visited_link_styles) ограничены, а некоторые стили (вроде `background-color`) сработают лишь при их применении к непосещённым ссылкам. А если говорить об использовании смежных или дочерних элементов, то надо начать с того, что `getComputedStyle` в применении к ним возвращает стиль, который соответствует непосещённой ссылке.
Браузеры больше не поддерживают общий кеш для одних и тех же ресурсов, используемых на разных сайтах
----------------------------------------------------------------------------------------------------
В недалёком прошлом один из плюсов использования CDN заключался в том, что это позволяло кешировать в браузере различные ресурсы (вроде шрифтов из библиотеки Google Fonts), которыми могли пользоваться различные сайты. Хотя это даёт большой выигрыш в производительности, применение такого механизма кеширования ресурсов может иметь плохие последствия для приватности пользователей.
Учитывая то, что на загрузку кешированного ресурса уйдёт меньше времени, чем на загрузку ресурса, которого пока нет в кеше браузера, некая веб-страница может выполнить [атаку по времени](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%D0%BF%D0%BE_%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8), позволяющую ей не только восстановить историю посещённых сайтов, но и узнать о том, кто именно работает за компьютером, и о том, чем он занимается в интернете. Вот что об этом пишет [Джефф Кауфман](https://www.jefftk.com/p/shared-cache-is-going-away):
*Общий кеш, к сожалению, ведёт к уязвимости в сфере приватности. Вот как выглядит простейший вариант соответствующей атаки:*
* Я хочу узнать, являетесь ли вы модератором сайта `www.forum.example`.
* Мне известно, что файл `www.forum.example/moderators/header.css` загружают только страницы, находящиеся в директории, доступной по адресу `www.forum.example/moderators/private/`.
* Когда вы посещаете мою страницу, я загружаю файл `www.forum.example/moderators/header.css` и выясняю, загружается ли он из кеша или нет.
Возможность подобных атак привела к тому, что браузеры больше не предлагают сайтам возможности использования общего кеша.
Метод performance.now() может возвращать неточные результаты
------------------------------------------------------------
Пару лет назад была обнаружена группа аппаратных уязвимостей, одна из которых получила название [Spectre](https://meltdownattack.com). Если вас интересуют подробности о Spectre — рекомендую обратиться к ресурсу Google [leaky.page](https://leaky.page/) (для работы с ним лучше всего подходит Chromium). На этом ресурсе имеется JavaScript-реализация эксплойта, основанного на Spectre, подтверждающая работоспособность соответствующей концепции.
*Прототип эксплойта Spectre на leaky.page*
Правда, нам, для целей данной статьи, достаточно знать о том, что атака базируется на использовании чрезвычайно точных отметок времени (именно их возвращает метод `performance.now()`) для получения доступа к произвольным местам памяти.
Для снижения риска реализации атак с применением Spectre разработчики браузеров уменьшили точность `performance.now()` и, кроме того, могут добавить к показателям, возвращаемым этим методом, «шум». Точность временных показателей, возвращаемых `performance.now()`, может варьироваться в достаточно широких пределах и зависит от различных факторов вроде HTTP-заголовков и настроек браузера.
Ленивая загрузка ресурсов с использованием атрибута loading не работает при отключённом JavaScript
--------------------------------------------------------------------------------------------------
[Ленивая загрузка данных](https://css-tricks.com/the-complete-guide-to-lazy-loading-images/) — это механизм, который позволяет браузеру загружать ресурсы страницы только тогда, когда они понадобятся пользователю. Например — тогда, когда они окажутся в области просмотра страницы. До недавних пор реализовать этот механизм можно было лишь средствами JavaScript с использованием API [IntersectionObserver](https://css-tricks.com/an-explanation-of-how-the-intersection-observer-watches/) или задействовав событие `onscroll`. Атрибут `loading` (это справедливо для всех браузеров кроме Safari) можно назначать изображениям и элементам `iframe` (в Chromium). Всё остальное браузер сделает самостоятельно.
Обратите внимание на то, что механизм ленивой загрузки [нельзя реализовать с помощью полифилла](https://www.smashingmagazine.com/2019/05/hybrid-lazy-loading-progressive-migration-native/), так как изображение, возможно, уже будет загружаться в момент проверки поддержки браузером атрибута `loading`.
То, что для ленивой загрузки изображений достаточно воспользоваться атрибутом HTML-тега, может навести на мысль о том, что работоспособность этого атрибута совершенно не зависит от JavaScript. Но, на самом деле, это не так. Взглянем на соответствующий раздел спецификации [WHATWG](https://html.spec.whatwg.org/#lazy-loading-attributes):
*Если для элемента отключено выполнение скриптов — вернуть false.*
***Примечание***
*Это — мера противодействия отслеживанию деятельности пользователей. Дело в том, что если пользовательский агент поддерживает ленивую загрузку ресурсов при отключённом выполнении скриптов, отключение скриптов не помешает некоему сайту выяснить приблизительную глубину скроллинга страницы в течение сессии. Сделать это можно, размещая в разметке страницы изображения в соответствии с определённой стратегией. Сервер, в результате, может узнать о том, сколько изображений было загружено, и о том, когда именно они загружались.*
Мне попадались статьи, в которых говорится, что атрибут `loading` — это инструмент для организации ленивой загрузки ресурсов «без использования JavaScript». Но это неправда. Правда заключается в том, что при использовании этого атрибута не нужно писать JavaScript-код.
Браузеры могут ограничивать возможности, доступные веб-страницам, основываясь на установках пользователя
--------------------------------------------------------------------------------------------------------
Некоторые пользователи могут решить жёстко ограничить функционал браузера, поступая так ради повышения уровня безопасности и улучшения защиты приватности. В Firefox и Tor это делается с помощью системы защиты от отслеживания. Она, кроме прочего, защищает пользователя от сборщиков [цифровых отпечатков](https://wiki.mozilla.org/Security/Fingerprinting). В частности, речь идёт о понижении точности некоторых показателей (связанных с размерами элементов и с временем) или об их полной блокировке, об ограничении или отключении некоторых Web API, об исправлении ошибок, позволяющих сайтам выяснять различные сведения о браузерах. Среди материалов, имеющих отношение к WebKit, есть [документ](https://trac.webkit.org/wiki/Fingerprinting), посвящённый защите пользователей от сборки цифровых отпечатков.
Обратите внимание на то, что защита от сборщиков цифровых отпечатков подразумевает применение гораздо более радикальных мер, чем те, которые используются в стандартных системах защиты от отслеживания пользователей. Маловероятно то, что пользователь включит систему защиты от сборщиков цифровых отпечатков, так как к этому его должна подвести весьма специфическая модель угроз. Некоторые из защитных мер могут помешать вполне мирным сайтам реализовывать стратегии прогрессивного улучшения проекта или его постепенного ухудшения. Они могут помешать разработчикам сайтов глубоко изучать своих пользователей. Вышеописанные ограничения могут стать большой проблемой в том случае, если сайту действительно нужно собирать цифровые отпечатки пользователей. Например — если это делается в рамках системы обнаружения мошенничества. В результате, если вашему проекту по-настоящему нужно собирать достаточно подробные сведения о пользователях, формировать их цифровые отпечатки, поищите альтернативные способы для решения этих задач.
Иногда средства для чтения с экрана не передают семантику некоторых элементов
-----------------------------------------------------------------------------
Семантический HTML-код — это, по многим причинам, прекрасное явление. Самое главное — его применение позволяет наделять разметку смыслом, который специальное ПО, вроде средств для чтения с экрана, способно передать пользователям, полагающимся на такое ПО при работе в вебе. Семантический HTML — это важнейший инструмент, применяемый при разработке сайтов, доступных людям с ограниченными возможностями. Но иногда смысл элементов пользователям не передаётся, по крайней мере — в том виде, в котором его передачи ожидает разработчик сайта. В результате доступность сайта может и не пострадать, а вот его юзабилити ухудшится.
Например, такое происходит в WebKit. Если [убрать маркеры списка](https://yatil.net/posts/2019/01/13/much-ado-about-no-lists/), то, при использовании VoiceOver, теряется семантический смысл списка. Это — весьма распространённый паттерн, в частности — используемый для оформления навигационных элементов сайта. Джеймс Крэйг, который занимается в Apple стандартами доступности контента, [говорит](https://twitter.com/cookiecrook/status/1337226933822603270) о том, почему это — проблема юзабилити, [цитируя](https://www.w3.org/TR/html-design-principles/#priority-of-constituencies) текст документа W3C «HTML Design Principles»:
*В случае конфликта нужно отдавать приоритет пользователям перед программистами, программистам — перед разработчиками реализаций стандартов, разработчикам реализаций стандартов — перед создателями спецификаций, создателям спецификаций — перед поборниками теоретической чистоты. Другими словами — стоимость или сложность применения готового продукта пользователем должны иметь большее значение, чем стоимость или сложность его создания программистами.*
Ещё один случай, когда семантические значения элементов могут быть утрачены, касается различных способов выделения текста. Возьмём, например, встроенные элементы, такие, как `strong`, `em`, `mark`, `ins`, `del` и `data`. Это — элементы, которые имеют семантическое значение, но они [вряд ли будут озвучены](https://www.tempertemper.net/blog/bold-and-italics-arent-read-by-screen-readers) средствами для чтения с экрана, так как иначе пользователь услышит слишком много «шума». Это можно изменить, прибегнув к настройкам программ для чтения с экрана, но если есть действительно сильная необходимость машинного озвучивания таких элементов, к ним можно применить класс `.visually-hidden`, описываемый в [этом](https://www.a11yproject.com/posts/2013-01-11-how-to-hide-content/) материале, можно прибегнуть к свойству `content` псевдо-элемента `:before` или `:after`.
Для того чтобы проиллюстрировать эту проблему — я подготовил небольшой [пример](https://codepen.io/faraixyz/full/wvdWgpB), с помощью которого исследовал то, как NVDA в Firefox 89 и VoiceOver в Safari 14.6 озвучивают семантические элементы.
Вот видеозаписи моих экспериментов
*NVDA в Firefox 89*
*VoiceOver в Safari 14.6*
NVDA, в отличие от VoiceOver, озвучивает некоторые семантические элементы (`del`, `ins` и `mark`) и пытается обозначить факт выделения текста постепенным повышением громкости. При этом обе системы не испытывают трудностей при озвучивании содержимого псевдо-элементов `:before` и `:after`. VoiceOver, кроме того, озвучивает скобки тегов (произнося «greater than» и «less than»). Обе системы поддерживают настройку озвучивания знаков препинания.
Для того чтобы понять, стоит ли в некоем конкретном проекте обратить особое внимание на озвучивание выделенного текста, нужно провести испытания с участием реальных пользователей и узнать о том, что им нужно. Я не углублялся в вопросы внешнего вида выделенных элементов, но могу сказать, что стандартная стилизация таких элементов в разных браузерах может выглядеть по-разному. Поэтому при использовании подобных элементов стоит подготовить и подходящие стили для них.
Может оказаться, что веб-хранилище хранит данные лишь временно
--------------------------------------------------------------
Спецификация WHATWG, посвящённая [веб-хранилищу](https://html.spec.whatwg.org/#webstorage), включает в себя раздел, посвящённый приватности, в котором рассматриваются возможные способы предотвращения использования хранилища в роли механизма отслеживания деятельности пользователей. Один из таких способов заключается в том, чтобы ограничить срок хранения данных. Именно поэтому Safari, что может показаться спорным решением, [ограничивает](https://webkit.org/tracking-prevention/) срок хранения данных, записанных в хранилище скриптами, периодом в 7 дней. Обратите внимание на то, что это не относится к «установленным» веб-сайтам, добавленным на домашний экран.
Итоги
-----
Интересно — правда? Некоторые веб-технологии, от которых мы ожидаем определённого поведения, на самом деле, ведут себя не так. Это не значит, что такие технологии реализованы с ошибками, и что их нужно исправлять. Речь скорее идёт о том, что программистам во время работы нельзя терять бдительности.
Если сделано некое предположение — его стоит проверить во время разработки проекта. Нужно критически анализировать нужды пользователей и учитывать их при разработке сайтов. Конечно, некоторые из вышеописанных особенностей веб-технологий можно обойти, и это совершенно нормально, но в тех случаях, когда сделать ничего нельзя, стоит позаботиться о поиске и реализации качественных механизмов прогрессивного улучшения или постепенного ухудшения проекта. Вполне нормальна ситуация, когда пользователи различных браузеров воспринимают сайт немного по-разному, но — лишь до тех пор, пока они в состоянии решать с помощью сайта те задачи, на решение которых он рассчитан.
Автор этого материала рассказал о веб-технологиях, которые работают не так, как он ожидал. А что вы внесли бы в собственный список таких технологий?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=veb-texnologii,_kotorye_mogut_rabotat_ne_tak,_kak_ozhidaetsya) | https://habr.com/ru/post/575350/ | null | ru | null |
# Упаковка N кругов различных диаметров на X листов (прямоугольников), заданных габаритов
Другими словами мы имеем частный случай задачи по раскрою материала.
Немного предыстории: в одном из своих проектов у меня появилась задача по расчету необходимого количества листов металла для производства деталей круглой формы. В моем случае это листы металла стандартного габарита 6000x1500 миллиметров.
Поискав готовые решения этой задачи, я решил написать свой вариант.
Не судите строго это все родилось за несколько часов :)
Постановка задачи
-----------------
Найти наименьшее количество листов металла, заданного габарита для производства заданного списка деталей круглой формы, заданных своими диаметрами.
Описание алгоритма
------------------
Из полученного на входе словаря, содержащего радиусы кругов и их количества мы формируем массив, вида:
```
# Словарь на входе от пользователя
user_circles = {
830 : 1,
730 : 2,
490 : 4,
360 : 6,
280 : 8,
150 : 12,
100 : 16,
50 : 18,
}
# Массив упорядоченных по убыванию радиуса объектов-кругов
self.circles = [
Circle(830),
Circle(730),
Circle(730),
Circle(490),
Circle(490),
Circle(490),
Circle(490),
...
]
```
Далее мы создаем новый лист (прямоугольник) заданных пользователем размеров:
```
self.sheets.append(Sheet(self.sheet_w, self.sheet_h))
```
Организуем цикл по массиву с упорядоченными объектами-кругами и для каждого круга используем метод поиска наилучшей координаты Y:
```
for i in self.circles:
i.cx, i.cy = self.find_best_packing_start_point(current_sheet, i)
```
Вот небольшая иллюстрация этого алгоритма:
Для каждого следующего круга ищется наилучшая координата YЕсли очередной круг был успешно помещен на текущий лист (прямоугольник) то из словаря кругов, заданного пользователей вычитается круг данного радиуса:
```
self.user_circles[i.r] -= 1
```
Если текущий круг не входит в лист (прямоугольник) по габаритам, то он добавляется в переменную:
```
self.circles_excluded[i.r] += 1
```
Когда для текущего листа (прямоугольника) мы попробовали разместить все круги из массива `self.circles` мы генерируем заново массив `self.circles` из оставшихся для размещения кругов:
```
# Убираем круги, которые уже размещены
def clean_circles(self):
circles_cleaned = []
for i in self.user_circles.keys():
for k in range(self.user_circles[i]):
circles_cleaned.append(Circle(i))
self.circles = circles_cleaned
```
Далее мы добавляем следующий лист и повторяем алгоритм пока не останется кругов для размещения.
Исходный код на Python
----------------------
```
import svgwrite
import math
class Sheet:
def __init__(self, w, h):
self.w = w
self.h = h
self.circles = []
class Circle:
def __init__(self, r, cx=None, cy=None):
self.cx = cx
self.cy = cy
self.r = r
@staticmethod
def two_circle_intersections(c1, c2):
x0, y0, r0 = c1.cx, c1.cy, c1.r
x1, y1, r1 = c2.cx, c2.cy, c2.r
d = math.sqrt((x1-x0)**2 + (y1-y0)**2)
if d > r0 + r1 :
return False
if d < abs(r0-r1):
return False
if d == 0 and r0 == r1:
return False
else:
return True
class CirclePacking:
ACCURACY = 20 # На сколько частей делим высоту для поиска наилучшей позиции по вертикали для текущего круга
def __init__(self, sheet_w, sheet_h, circles, cut_border):
self.sheet_w = sheet_w
self.sheet_h = sheet_h
self.user_circles = circles
self.circles = []
self.sheets = []
self.circles_excluded = {}
self.cut_border = cut_border
def create_circles_sorted(self):
self.circles = []
for i in reversed(sorted(self.user_circles.keys())):
for k in range(self.user_circles[i]):
self.circles.append(Circle(i))
# Убираем круги, которые уже размещены
def clean_circles(self):
circles_cleaned = []
for i in self.user_circles.keys():
for k in range(self.user_circles[i]):
circles_cleaned.append(Circle(i))
self.circles = circles_cleaned
def packing(self):
self.create_circles_sorted()
while sum(self.user_circles.values()) > 0:
#print(self.user_circles, self.circles)
self.sheets.append(Sheet(self.sheet_w, self.sheet_h))
current_sheet = self.sheets[-1]
for i in self.circles:
i.cx, i.cy = self.find_best_packing_start_point(current_sheet, i)
if i.cx is None and i.cy is None:
if i.r not in self.circles_excluded:
self.circles_excluded[i.r] = 1
else:
self.circles_excluded[i.r] += 1
self.user_circles[i.r] -= 1
else:
# Проверка что мы не вышли за длину листа
if i.cx > current_sheet.w - i.r - self.cut_border:
pass
else:
self.user_circles[i.r] -= 1
current_sheet.circles.append(i)
self.clean_circles()
# Ищем наилучшую позицию по вертикали для размещения круга
def find_best_packing_start_point(self, s, c):
try_results = {}
N = CirclePacking.ACCURACY
step = int((s.h -c.r) / N)
# Формируем массив координат по вертикали для попыток
try_y = [c.r, s.h-c.r, s.h/2]
for i in range(int((s.h - c.r) / step)):
try_y.append(c.r + step * i)
# Пробуем все координаты из массива попыток
for i in try_y:
c.cx = s.w + c.r
c.cy = i
self.move_circle(s, c)
# Проверяем что мы вошли на лист
if c.cy >= c.r + self.cut_border and c.cy <= s.h - c.r - self.cut_border:
try_results[c.cx] = c.cy
if try_results == {}:
cx = cy = None
else:
cx = sorted(try_results.keys())[0]
cy = try_results[cx]
return cx, cy
def move_circle(self, s, c):
while c.cx > c.r + self.cut_border:
if self.check_intersections(s, c):
return
c.cx -= 1
def check_intersections(self, s, c):
for i in s.circles:
i.r += self.cut_border
if Circle.two_circle_intersections(i, c):
i.r -= self.cut_border
return True
i.r -= self.cut_border
return False
def draw_sheet_with_circles(self, sheet_idx, scale, filename):
sheet = self.sheets[sheet_idx]
w = sheet.w * scale
h = sheet.h * scale
border_x = 150 * scale
border_y = 150 * scale
svg = svgwrite.Drawing(filename = filename, size = (str(w+border_x*2)+'px', str(h+border_y*2)+'px'))
svg.add(svg.line(stroke='red', start=(str(0+border_x)+'px', str(0+border_y)+'px'), end=(str(w+border_x)+'px', str(0+border_y)+'px')))
svg.add(svg.line(stroke='red', start=(str(0+border_x)+'px', str(0+border_y)+'px'), end=(str(0+border_x)+'px', str(h+border_y)+'px')))
svg.add(svg.line(stroke='red', start=(str(0+border_x)+'px', str(h+border_y)+'px'), end=(str(w+border_x)+'px', str(h+border_y)+'px')))
line1 = svg.add(svg.line(stroke='red', start=(str(w+border_x)+'px', str(0+border_y)+'px'), end=(str(w+border_x)+'px', str(h+border_y)+'px')))
line1.dasharray([5, 10])
for i in sheet.circles:
cx = i.cx * scale
cy = i.cy * scale
r = i.r * scale
svg.add(svg.circle(center=(str(cx+border_x)+'px', str(cy+border_x)+'px'), r=str(r)+'px', stroke='black', fill='white', stroke_width=1))
svg.save()
```
Пример работы алгоритма
-----------------------
Ниже приведен пример работы алгоритма:
```
circles = {
830 : 1,
730 : 2,
490 : 4,
360 : 6,
280 : 8,
150 : 12,
100 : 16,
50 : 18,
}
cp = CirclePacking(sheet_w=6000, sheet_h=1500, circles=circles, cut_border=20)
cp.packing()
```
Пример упаковки кругов на листы (прямоугольники)Обратите внимание на то, что круг с радиусом 830 не вошел на листы 6000x1500 и он помещен в атрибут: cp.circles\_excluded:
```
cp.circles_excluded
# {830: 1}
```
Оставшиеся вопросы:
-------------------
* Как ускорить работу алгоритма не выходя за возможности стандартного Python (не использовать библиотеки ускорения кода Python)?
* Как еще повысить плотность заполнения листов?
Ссылки
------
Github: <https://github.com/tau15/python_circle_packing_in_rectangle>
Google Colab: <https://colab.research.google.com/drive/1e-RoNHStyqdyROZNPHga_vvrIKyRy3ZR?usp=sharing>
Вопросы и предложения на алгоритму пишите мне: [@TAU15](/users/tau15) | https://habr.com/ru/post/708810/ | null | ru | null |
# Как программируют слабовидящие программисты?
**От переводчика**
#### Что это за пост? Он не похож на статью
Это действительно не статья. Это компиляция самых интересных, на мой взгляд, ответов на заглавный вопрос: «[Как программируют слабовидящие программисты?](http://www.quora.com/How-does-a-visually-impaired-computer-programmer-do-programming)» из обсуждения на Quora.com.
#### Почему я сделал перевод?
Ответы людей меня сильно впечатлили. Я никогда не думал, что люди сталкиваются с *такими* проблемами и не только не отчаиваются, а мужественно и смело эти проблемы преодолевают, сохраняя при этом оптимизм и радость к жизни. Это поразительно.
Как веб-разработчик, я, конечно, слышал о таинственных экранных дикторах и полумифических дисплеях Брайля. Кто-то там ими пользуется, но ведь это всё не в моём, а в каком-то совсем другом, особом, вебе, где специально обученные разработчики всё для них подготовили и по вечерам все вместе танцуют под луной.
Это не так. *Совсем* не так.
Нет никаких специально обученных разработчиков.
Нет никакого особого веба.
Веб один и он общий для всех. И никаких других разработчиков, кроме нас с вами, в нём нет. И именно мы с вами несём за него ответственность.
Именно мы с вами — те люди, которые делают его таким, как он есть. Именно из наших с вами рук пользователи получают веб-страницы. Разработчик — последний, кто вносит в веб-страницу правки и определяет, насколько она будет доступной для людей, которые вынуждены пользоваться вебом иначе — слепые ли они, парализованные ли, или их возможности каким-то иным образом ограничены. Это — социальная ответственность, хотим мы этого или нет.
Давайте же делать веб чуточку лучше, доступнее для всех и каждого, и пусть никто не уйдёт обиженным.
#### Пархам Даустэр, PHP-программист
> Я — слепой PHP-программист. Способ, которым я пишу код, пожалуй, отличается от способов, упомянутых в других ответах. Прежде чем начать, давайте я немного расскажу о себе.
>
>
>
> Я слеп от рождения. У меня никогда не было проблемы «потери зрения»: я им никогда не обладал. Это многое упрощает.
>
>
>
> Лично я, в отличие от многих других незрячих, использую среду разработки. Мы пользуемся экранными дикторами, а интерфейсы сред разработки в большинстве своём для них плохо доступны. Например, экранным дикторам недоступны [все среды разработки компании JetBrains](https://youtrack.jetbrains.com/issue/IDEA-111425). Это — один из минусов конкуренции в нашем обществе: люди слишком заняты заботой о большинстве, чтобы прислушиваться к меньшинству.
>
>
>
> Я использую Zend Studio, основанную на всем известном Eclipse. Eclipse — приятное исключение: доступность реализована очень хорошо. Он доступен не полностью, но и 80% мне вполне хватает. Слепому выбирать не приходится.
>
>
>
> Среда разработки эффективно избавляет от рутины вроде запоминания сигнатур методов, документации и множества других вещей, оставляя мне заботу о более насущных вещах (например, почему легаси-код — такой отстой).
>
>
>
> Я не пользуюсь клавиатурой Брайля. Использовать всего лишь 6 клавиш, которые ещё и нужно нажимать одновременно для каждого символа — это слишком медленно. Сотня клавиш, которые можно очень быстро нажимать друг за другом — это намного, намного быстрее.
>
>
>
> Дисплеем Брайля я тоже не пользуюсь. Вместо этого у меня стоит экранный диктор, настроенный на 420 слов в минуту. Это намного быстрее, чем читать с брайлевского дисплея.
>
>
>
> Самое важное, по моему мнению, — быть впереди конкурентов. Для незрячего это уже само по себе сложно. Мы вынуждены конкурировать, не имея одного из чувств, которое есть у большинства людей в мире. Это не было бы большой проблемой, если бы не упоминавшийся мной выше конфликт интересов большинства с меньшинством. Находясь в меньшинстве, нужно находить способы получить то, что многие люди воспринимают как само собой разумеющееся. В этом, мне кажется, заключается сила, приходящая от слабости: приходится импровизировать, заставлять себя, достигать невозможного каждый день всего лишь чтобы не остаться безработным.
#### Томми Маквильям, мобильный инженер в Quora
> Вы слышали про Python Bee? Теперь представьте что так выглядит ваш обычный день.
>
>
>
> Одному из моих лучших друзей в старшей школе поставили диагноз «наследственная оптическая нейропатия Лебера», когда он учился в выпускном классе. НОНЛ постоянно снижала его зрение и на первом году обучения в колледже мой друг почти полностью ослеп. Его специализацией была информатика, и то, как он программировал, было одной из самых невероятных вещей, которые я видел в жизни.
>
>
>
> В колледже он использовал комбинацию экранной лупы и экранного диктора. Экранная лупа называлась [MAGic](http://www.freedomscientific.com/Products/LowVision/MAGic) и позволяла ему увеличивать текст так, что на монитор умещалось всего лишь несколько символов. Сам монитор был огромным экраном свыше 30 дюймов, оптимизированным для слабовидящих. Экранным диктором был [JAWS](http://www.freedomscientific.com/Products/Blindness/JAWS), хотя мой друг перепробовал множество других программ. Он говорил, что существующие программы с открытым кодом выглядят жалко в сравнении с очень дорогими программами, которыми он пользовался благодаря помощи нашей школы.
>
>
>
> Мой друг всегда ставил экранный диктор на максимальную скорость чтения (наверное, свыше 300 слов в минуту). Для сравнения, аудиокниги обычно звучат вдвое медленнее. Для меня это звучало как совершенно другой язык, но он его отлично понимал. Мой друг предпочитал использовать абсурдно старую версию Firefox (3.5 или вроде того), потому что она лучше всего поддерживала его экранный диктор. Практически все действия он выполнял горячими клавишами, передвигаясь по приложениям и окнам с ошеломляющей скоростью. Всё это, вкупе с 40-кратным увеличением, делало практически невозможными попытки проследить за его действиями. При этом он работал эффективнее многих виденных мной программистов.
>
>
>
> ##### О том, как именно мой друг программировал.
>
>
>
> Как редактор кода он использовал Emacs (думаю, из-за того, что наловчился с сумасшедшими горячими клавишами). Экранный диктор читал код, который он проматывал. Точно так же экранный диктор читал вывод терминала, так что исключалась любая возможность того, что что-то не будет озвучено. Как вы догадываетесь, программный код понять сложнее, чем английские слова. Хотя языки, не злоупотребляющие символами в синтаксисе, понимать проще. Более доступны те языки, которые «выглядят» похожими на английский, как Python, Ruby и подобные. Тем не менее, использование отступов вместо скобок довольно-таки усложняет жизнь — приходится внимательно выслушивать количество табов на каждой строке.
>
>
>
> Чтобы вы лучше себе представляли общую картину, я расскажу забавный случай, случившийся на втором курсе. Мы изучали OCaml, функциональный язык с забавным синтаксисом. Мой друг был вынужден слушать чушь вроде `let rec fib n равно return match n with return вертикальная черта один дефис больше, чем… точка с запятой точка с запятой` и тому подобное. В этот день он работал с очень большим куском кода, который никак не компилировался. Он прослушивал этот нелепый синтаксис снова и снова, но не мог найти ни одной ошибки. Ничего не изменилось, пока он не пришёл в класс, где зрячий помощник преподавателя заметил, что по какой-то причине экранный диктор произносит цифру «`0`» как букву «`О`». Это был совершенно новый вид багов, с которыми не сталкиваются зрячие программисты.
>
>
>
> Стоит также отметить, что он увлечён спецификацией доступности HTML, в особенности [ARIA](http://www.w3.org/TR/wai-aria/). Большинство сайтов в интернете её полностью игнорируют, несмотря на то, что она очень просто внедряется. То, как он пользуется сайтами с ARIA-атрибутами и без них — это небо и земля.
>
>
>
> Сейчас он работает разработчиком ПО на полной ставке.
#### Стив Дони
> Рон Морфорд — один из самых талантливых программистов, с которыми мне приходилось работать. У него было что-то под названием «[синдром Марфана](http://en.wikipedia.org/wiki/Marfan_syndrome)», из-за которого он полностью потерял зрение, когда ему было чуть больше двадцати. Я работал на него в начале 90-х, разрабатывая экранный диктор для Windows 3.1. Рон владел компанией Automated Functions, Inc, которая разрабатывала программы и железо для слепых. Одним из его первых продуктов был VERT. Это был ящик размером с обычный ПК, разработанный как посредник между компьютером и терминалом. Он отслеживал проходящий между ними трафик и преобразовывал его в речь. VERT мог произносить до 400 слов в минуту, а Рон их запоминал.
>
>
>
> У Рона было невероятная память. Одним из первых проектов, которые я для него делал сразу после колледжа, был экранный диктор для DOS. Иногда я возился с ним полдня и, если у меня ничего не получалось, я шёл к Рону и спрашивал — «Что делает вот эта функция?». Рон помнил её построчно, хотя, возможно, не заглядывал в неё несколько месяцев.
>
>
>
> До того, как Рон основал AFI, он был специалистом по компьютерной безопасности в NASA. Он рассказывал отличные истории о том, как тамошние программисты постоянно пытались хакать друг друга, чтобы найти дыры в ранних версиях Unix.
>
>
>
> Я работал в области доступности около 8 лет, потом устроился в Microsoft и работая над реализацией доступности в Windows. За это время я видел множество слепых программистов. Они пользовались множеством разнообразных техник и инструментов, но, в основном это была стандартная клавиатура и речевой вывод. Были и клавиатуры Брайля, но мало кто пользовался ими ежедневно. На клавиатуре Брайля девять основных клавиш — по четыре для каждой руки и пробел; буквы вводятся комбинациями клавиш, составляющими алфавит Брайля. Как уже упоминали другие участники, ещё существует дисплей Брайля, с выдвигающимися и втягивающимися пластиковыми палочками. Но такие дисплеи невероятно дороги: 80-колоночный дисплей продавался за 8 000 $, хотя, я думаю, что он мог подешеветь за последние 20 лет.
#### Лукас Радэлли
> Я абсолютно слеп. Я работаю на Google, участвую в разработке алгоритма ранжирования. По моему опыту и по тому, что я слышал от многих других слепых программистов, наш способ программирования не сильно отличается от способа наших зрячих коллег. Я пользуюсь в основном текстовым редактором (Emacs с расширением Emacspeak, озвучивающим текст) и браузером для просмотра внутренних страниц Google с документацией и прочим.
>
>
>
> Главное отличие в том, что мы или слушаем то, что на экране, или читаем на дисплее Брайля. Ничего не могу сказать про использование этого дисплея, потому что у меня его никогда не было (слишком дорого), но могу поделиться некоторыми мыслями о том, как программировать на слух.
>
>
>
> Самое трудное в программировании на слух в том, что нужно запоминать кучу всего. Вы двигаетесь от строки к строке, прослушивая их целиком. Можно прослушивать код пословно или же посимвольно. Отличие, как видите, в том, что одновременно доступна лишь малая часть кода. Вы не можете начать программировать, посмотрев имена входящих аргументов функции. Вы их помните. Если вам понадобится свериться с объявлением функции, то вы ставите закладку, переходите к объявлению, читаете его и возвращаетесь назад к закладке. Как можно заметить, это вовсе не мгновенный процесс, поэтому тренировка памяти становится необходимым навыком
>
>
>
> Мне нравится программировать с помощью Emacspeak, потому что он хорошо подходит для программирования на C++. Например, в этой программе есть голосовые стили: она читает переменные, функции и другие части языка с разной интонацией. Это помогает разобраться, что есть что. Можно считать это аудиоподсветкой кода.
>
>
>
> ##### Напоследок, из интересного
>
>
>
> Слепые программисты не используют выравнивание кода. Обычно мы расставляем отступы уже после написания. Нам они не приносят никакой пользы.
>
>
>
> ##### Вы можете спросить: а как же Python?
>
>
>
> Мне очень правится Python и даже необходимость выравнивать код не меняет этого. Я придумал некоторые техники: например, сдвигать строку в конец каждого блока отступов — так я могу очень быстро узнать, где блок заканчивается. При чтении чужого кода можно настроить диктор, чтобы он проговаривал глубину отступов, но меня слегка раздражает выслушивать, сколько пробелов на каждой строке.
#### Флориан Бэйджерс
> Я пришёл сюда из уведомления Slack в коммьюнити Free Code Camp и вижу что моя блогозапись упомянута дважды. Спасибо. Я это ценю и очень рад, что она оказалась полезной для стольких из людей. К сожалению, из-за каких-то проблем с доступностью, я не могу прочитать комментарии с её упоминанием. Тем не менее, я прошу всех, у кого есть вопросы, стукнуть мне в твиттер [Zersiax](https://twitter.com/zersiax). Обычно я отвечаю сразу же, если не сплю :-) Это обсуждение показывает, что слепые тоже пишут программы и некоторым это даже нравится.
>
>
>
> Возвращаясь к некоторым вопросам, которые упомянуты конкретно в этом обсуждении:
>
>
>
> Как я уже упоминал в своём блоге, я стараюсь пользоваться средой разработки. В основном это среды, основанные на Eclipse и Visual Studio, которая, по ироничному стечению обстоятельств, довольно хорошо подходит для визуально ограниченных людей, в то время как Microsoft Access совершенно не accessible *(англ. accessible — «доступность», примечание переводчика)*. Не ирония ли это? :)
>
>
>
> Использовать старый браузер (Firefox 3.5) просто глупо, если вы хоть немного кодите для веба. Это может быть грубо с моей стороны, но он всё равно лучше, чем IE. Вещи вроде этого — причина того, что я сейчас стремлюсь работать с экранным диктором NVDA с открытым исходным кодом. Он просто отлично работает с последним Firefox`ом.
>
>
>
> Хотя я с радостью поучился бы работать в Vim и Emacs, мне некогда этим заниматься. Кроме того, я стараюсь работать в среде, где зрячие разработчики (в основном студенты) могут со мной взаимодействовать. Как правило, Linux их отпугивает, «Vim» для них — средство для чистки, а «Emaсs» звучит как какой-то вид магии. Поэтому я вынужден работать в редакторах с графическим интерфейсом, даже если командная строка была бы эффективнее.
>
>
>
> Ладно, хватит на этот раз:) Спасибо за чтение.
[Более развёрнутый ответ Флориана](http://habrahabr.ru/post/260463/) | https://habr.com/ru/post/262363/ | null | ru | null |
# Быстрое вычисление точной 3D карты расстояний с использованием технологии CUDA
Карта расстояний (Distance Map) — это объект, позволяющий быстро получить расстояние от заданной точки до определенной поверхности. Обычно представляет собой матрицу значений расстояний для узлов с фиксированным шагом. Часто используется в играх для определения «попадания» в игрока или предмет, и для оптимизационных задач по совмещению объектов: расположить объекты максимально близко друг к другу, но так, чтобы они не пересекались. В первом случае качество карты расстояний (то есть точность значений в узлах) не играет большой роли. Во втором — от нее могут зависеть жизни (в ряде приложений, связанных с нейрохирургией). В этой статье я расскажу как можно достаточно точно обсчитать карту расстояний за разумное время.
##### Основные объекты
Пусть у нас имеется некоторая поверхность S, заданная набором вокселей. Координаты вокселей будем считать на регулярной сетке (т.е. шаги по X, Y и Z одинаковы).
Требуется вычислить карту расстояний M[X,Y,Z] для всех вокселей, которые лежат в кубе, содержащем поверхность; M[x,y,z] = d((x,y,z), S) = min( d((x,y,z), (Snx, Sny, Snz) ) = sqrt( min( (x-Snx)2 + (y-Sny)2 + (z-Snz)2) ). Последнее равенство верно только для регулярной сетки, остальное должно быть очевидно.
##### Откуда берутся данные
Для нашей задачи данные поступают с аппарата [МРТ](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%B3%D0%BD%D0%B8%D1%82%D0%BD%D0%BE-%D1%80%D0%B5%D0%B7%D0%BE%D0%BD%D0%B0%D0%BD%D1%81%D0%BD%D0%B0%D1%8F_%D1%82%D0%BE%D0%BC%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F). Напомню, что мы работаем с 3D изображениями, так что весь 3D образ представляет собой набор плоских картинок для разных срезов по Z, которые я, разумеется не могу все здесь представить; их немногим меньше, чем разрешение по X и Y. Типичный размер томографии порядка 625x625x592 вокселей.
В результате довольно хитрых преобразований выделяется граница поверхности головы. Сама суть этих преобразований сводится к разнообразным фильтрам, убирающим «шум» и функции, определяющей по градиенту собственно границу. Здесь ничего нового нет, про подобные вещи рассказывалось в тематике «Обработка изображений», [в частности](http://habrahabr.ru/blogs/image_processing/114489/). Собственно граница и есть то целевое множество, до которого мы будем считать расстояния и строить карту.
##### Прямой перебор
Прикинем для начала, почему бы не заполнить карту расстояний значениями «по определению» — минимумами расстояний до точек границы. Всего точек карты: X\*Y\*Z, точек поверхности порядка max(X,Y,Z)2. Вспомним размеры исходных данных и получим что-то порядка 592\*6254 арифметико-логических операций. Калькулятор подскажет, что это более чем 90000 миллиардов. Мягко говоря, многовато, отложим пока прямой перебор.
##### Динамическое программирование
Напрашивается использование того, что данные представляются в трехмерном массиве; можно как-то рассчитать значение в каждой точке, используя ее соседей, и разумеется мы не первые, кто этим занимался. Несколько отталкивает факт, что держать в памяти структуру размером 592\*625\*625\*sizeof(float), что около 1 Гигабайта, несколько ресурсоемко. Ну и ладно, забудем пока что томография может сниматься и с двойным разрешением (еще в 8 раз больше) — 640Кбайт давно уже никому не хватает.
Самый тривиальный метод заполнения (city-block), похожий на [алгоритм для обхода лабиринта](http://habrahabr.ru/blogs/algorithm/113108/), отрабатывает за считанные секунды, но максимальная ошибка на трехмерной сетке может составить 42 шага сетки для максимально обсчитываемого расстояния в 50 шагов. Насколько это плохо? Полный провал.
Единственный алгоритм из класса ([central point](http://www.merl.com/papers/docs/TR99-26.pdf)) дает почти удовлетворительную точность (ошибка не более 0.7 шага сетки), но работает минуты.
Мы пытались найти компромисс, реализовав chessboard distance (описание в той же статье, что и central point), но итоговая точность не могла устроить, а время его работы — десятки секунд.
[](http://dl.dropbox.com/u/243445/dmap/visual_comparison.png) Картинка — ссылка на полноразмерную, но даже на превью видно «странное» поведение достаточно далеко от точек поверхности, и особенно если нужно обсчитывать еще и внутренние объекты. Слева chessboard, а справа то, что было получено прямым перебором. И еще раз напомню, для тех, кто смотрит только картинки — речь идет о 3D изображениях, поэтому странные «проколы» внутри объяснимы — они вызваны близостью к поверхности на следующих или предыдущих слайдах по Z. В общем, провал.
##### Опять прямой перебор
Да, слово CUDA на картинке как бы намекает. Может быть 90000 миллиардов — не так уж и много, а может это число можно как-то уменьшить, без потери точности. В любом случае, middle-end видеокарта справляется с примитивными вычислительными операциями в 80-120 раз быстрее процессора аналогичного класса. Попробуем.
Да и у прямого перебора есть существенное преимущество — нет необходимости держать всю карту расстояний в памяти, и как следствие — линейная масштабируемость.
##### Сокращение перебора
Тезис: нет смысла для каждой точки проверять расстояние до каждой точки границы. В действительности, карта расстояний обязана обеспечивать хорошую точность только в непосредственной близости к границе, достаточно далекие точки можно вообще не считать, а промежуточные промаркировать приблизительным расстоянием.
Критерий корректности — абсолютная точность вблизи границы (на расстоянии до 10 (GUARANTEED\_DIST) шагов сетки), хорошая точность на расстоянии до 36 (TARGET\_MAX\_DIST) шагов, и визуальная адекватность (без артефактов — зачем смущать хирургов). Числа 10 и 36 взялись непосредственно из нашей задачи (у нас вообще это значения в миллиметрах и сетка миллиметровая).
##### Кубический индекс
Для каждой точки хотелось бы определить — насколько точно ее значение нужно вычислять. Очевидно, что размер такой структуры совпадет с размером исходного изображения, а это много, и считаться будет долго.
Будем объединять точки в «кубики». Пусть размер кубика — 32 (CUBE\_SIZE), тогда индекс будет иметь размерности 20 x 20 x 19.
Маркируем кубик по типу «лучшей» точки, лежащей в нем. Если хоть одна точка требует точного обсчета — считаем весь кубик точно. В худшем случае — не считаем вообще.
Как быстро промаркировать кубики? Начнем с точек границы: прибавим к каждой из них смещение GUARANTEED\_DIST во всех 27 направлениях ((-1,0,1)x(-1,0,1)x(-1,0,1)), получим индекс соответствующего кубика, делением на 32 (CUBE\_SIZE), и пометим его как «точный» — ведь в нем лежит по крайней мере одна точка, требующая точного обсчета. Задача: объяснить почему этого достаточно, и все кубики содержащие точки для точного обсчета будут помечены верно.
На всякий случай довольно тривиальный код, который это выполняет:
> `for (size\_t t = 0; t < borderLength; t++)
>
> {
>
> for (int dz = -1; dz <= 1; dz++)
>
> for (int dy = -1; dy <= 1; dy++)
>
> for (int dx = -1; dx <= 1; dx++)
>
> {
>
> float x = border[t].X + (float)dx \* GUARANTEED\_DIST;
>
> float y = border[t].Y + (float)dy \* GUARANTEED\_DIST;
>
> float z = border[t].Z + (float)dz \* GUARANTEED\_DIST;
>
> if (x >= 0 && y >= 0 && z >= 0)
>
> {
>
> size\_t px = round(x / CUBE\_SIZE);
>
> size\_t py = round(y / CUBE\_SIZE);
>
> size\_t pz = round(z / CUBE\_SIZE);
>
> size\_t idx = px + dim\_X \* (py + skip\_Y \* pz);
>
> if (idx < dim\_X \* dim\_Y \* dim\_Z)
>
> {
>
> markedIdx[idx] = true;
>
> }
>
> }
>
> }
>
> }`
На практических данных эта идея позволила сократить порядок перебора «всего» в 4-5 раз. Все равно получается очень много, но идея с кубиками нам еще пригодится.
##### Кубический контейнер
В действительности, нет смысла считать расстояние ко всем точкам границы, достаточно посчитать его только для ближайших точек; а теперь мы знаем, как организовать такую структуру.
Раскидаем все воксели границы S по кубикам (про индексные кубики с настоящего момента забудем; мы их построили, поняли как применять, и теперь больше с ними не работаем). В каждый кубик будем класть те точки границы, которые достижимы (лежат на расстоянии TARGET\_MAX\_DIST и меньше). Для этого достаточно посчитать центр кубика, и отложить от него расстояние sqrt(3)/2\*CUBE\_SIZE (это диагональ кубика) + TARGET\_MAX\_DIST. Если точка достижима из вершины кубика или любой точки стороны, то она достижима из его внутренности.
Я думаю, приводить код смысла нет, он очень похож на предыдущий. И корректность идеи тоже очевидна, но остается один существенный момент: фактически мы «размножаем» точки границы, число которых может увеличиться до 27 раз при разумном TARGET\_MAX\_DIST (меньше размера кубика) и даже в большее число раз иначе.
Оптимизации:
* Первая (вынужденная) — размер кубика подбирается так, чтобы итоговое число «размноженных» точек не было больше максимального объема памяти на них (мы брали 512 мегабайт). Подобрать размер кубика можно быстро (немного математики).
* Вторая (разумная) — использовать индексы на начальное и конечное размещение точек для каждого кубика, эти индексы могут пересекаться, и за счет грамотного их вычисления можно сэкономить еще в 2 раза по объему памяти.
Я сознательно не буду приводить точные алгоритмы для обоих пунктов (а вдруг вы реализуете их лучше и станете нашими конкурентами? ;) ), там слов больше, чем идеи.
В целом кубики сокращают порядок перебора в X/CUBE\_SIZE \* Y/CUBE\_SIZE \* Z/CUBE\_SIZE раз, но надо помнить, что уменьшение размера кубика потребует существенно больше памяти, и пороговое значение для наших изображений оказывалось в районе 24-32.
Таким образом, задача свелась к порядка 100-200 миллиардов вещественных операций. Теоретически, это вычислимо на видеокарте за десятки секунд.
##### Ядро CUDA
Оно получилось такое простое и красивое, что не поленюсь его показать:
> `\_\_global\_\_ void minimumDistanceCUDA( /\*out\*/ float \*result,
>
> /\*in\*/ float \*work\_points,
>
> /\*in\*/ int \*work\_indexes,
>
> /\*in\*/ float \*new\_border)
>
> {
>
> \_\_shared\_\_ float sMins[MAX\_THREADS]; // max threads count
>
>
>
> for (int i = blockIdx.x; i < BLOCK\_SIZE\_DIST; i += gridDim.x)
>
> {
>
> sMins[threadIdx.x] = TARGET\_MAX\_DIST\*TARGET\_MAX\_DIST;
>
>
>
> int startIdx = work\_indexes[2\*i];
>
> int endIdx = work\_indexes[2\*i+1];
>
>
>
> float x = work\_points[3\*i];
>
> float y = work\_points[3\*i+1];
>
> float z = work\_points[3\*i+2];
>
>
>
> // main computational entry
>
> for (int j = startIdx + threadIdx.x; j < endIdx; j += blockDim.x)
>
> {
>
> float dist = (x - new\_border[3\*j] )\*(x - new\_border[3\*j] )
>
> + (y - new\_border[3\*j+1])\*(y - new\_border[3\*j+1])
>
> + (z - new\_border[3\*j+2])\*(z - new\_border[3\*j+2]);
>
> if (dist < sMins[threadIdx.x])
>
> sMins[threadIdx.x] = dist;
>
> }
>
>
>
> \_\_syncthreads();
>
>
>
> if (threadIdx.x == 0)
>
> {
>
> float min = sMins[0];
>
> for (int j = 1; j < blockDim.x; j++)
>
> {
>
> if (sMins[j] < min)
>
> min = sMins[j];
>
> }
>
> result[i] = sqrt(min);
>
> }
>
>
>
> \_\_syncthreads();
>
> }
>
> }`
Мы загружаем блок координат точек distance map для перебора (work\_points), соответствующие начальные и конечные индексы для перебора точек границы (work\_indexes) и границу, оптимизированную алгоритмом с «кубиками» (new\_border). Результаты забираем в одинарной вещественной точности.
Собственно, сам код ядра, что приятно очень понятен, даже без тонкостей CUDA. Главной его особенностью является использование переменных gridDim.x и threadIdx.x обозначающих индексы текущего потока из набора запущенных потоков на видеокарте — все делают одно и то же, но с разными точками, а потом результаты синхронизируются и аккуратно записываются.
Осталось только грамотно организовать вычисление work\_points на CPU (но это же так просто!) и запустить вычислитель:
> `#define GRID 512 // calculation grid size
>
> #define THREADS 96 // <= MAX\_THREADS, optimal for this task
>
> minimumDistanceCUDA<<>>(dist\_result\_cuda, work\_points\_cuda, work\_indexes\_cuda, new\_border\_cuda);`
На Core Duo E8400 и видеокарте GTX460 средняя томография обрабатывается за время **в пределах минуты**, расход памяти лимитирован 512Мб. Распределение процессорного времени составляет примерно процентов 20 на CPU и файловые операции, и оставшиеся 80 на вычисление минимумов на видеокарте.
А вот так выглядит картинка посчитанная с «загрублением» далеких точек:
Как-то так, надеюсь что-нибудь Вам пригодится. Большая просьба, не копировать картинки и не делать ре-публикации без моего разрешения (автор метода я, хотя «методом» это сложно назвать).
Удачного дня! | https://habr.com/ru/post/119603/ | null | ru | null |
# «Раз, два, три – ёлочка гори!» или мой первый взгляд на контроллер CANNY 3 tiny
«Новый год» это мандарины, оливье, выходные и конечно же подарки.
Как вы, уже наверняка догадались я неожиданно стал обладателем микроконтроллера CANNY 3 Tiny. Правда я особо DIY электроникой не увлекаюсь и последний раз сам пытался что-то подключить к контроллеру почти семь лет назад, когда делал подсветку [для петрушки с помощью клона Arduino](https://habr.com/ru/post/184144/). Но не пропадать же добру? Надо-таки посмотреть, что же это за зверь такой.
Итак, если верить сайту разработчиков – их продукция широко применяется и даже устанавливается в КАМАЗы, участвующие в ралли «Дакар». При этом основная особенность их контроллеров в том, что для программирования не придется написать ни одной строчки кода. Вся программа разрабатывается в виде блок схемы. Как человек далекий от мира DIY я был весьма заинтригован.
И всё бы хорошо, но есть одна загвоздка. Я в прошлом году честно хотел прикупить себе пару «Дакаровских» КАМАЗов, но не успел взять их со скидкой в «Черную пятницу». Так что нам придется как-то просто и элегантно выкручиваться из этой ситуации.
В данной статье мы подключим к контроллеру кнопку и красный светодиод «пиранья», после чего запрограммируем их так, чтобы светодиод включался и отключался по нажатию на кнопку.
Хотите присоединится к моему безудержному новогоднему веселью? Тогда милости прошу под кат.
Кстати, на «Хабре» уже была [статья про контроллеры CANNY](https://habr.com/ru/post/369429/), но во-первых там был другой контроллер, а во вторых ПО для разработки программ с того момента устарело. В итоге, чтобы просто разобраться как поморгать встроенным в контроллер зеленым светодиодом у меня ушел примерно час. Отчасти именно поэтому я решил поделиться с вами моими попытками «обуздать» контроллер. *А еще отчасти просто потому, что я люблю писать на «Хабр», когда есть свободное время.*
Прежде чем мы пойдем дальше, считаю своим долгом предупредить читателей. Несмотря на то, что эта статья представлена как «туториал», я не являюсь экспертом ни в микроэлектронике, ни в программировании. Просто поделюсь тем, в чем сам успел разобраться, чтобы сэкономить вам время.
Вот о чем пойдет в статье речь:
[Часть I: Распаковка и знакомство](#I)
[Часть II: Подключение схемы](#II)
[Часть III: Программирование](#III)
[Часть IV: Заключение](#IV)
Часть I: Распаковка и знакомство
---------------------------------
Для начала, необходимо сказать хотя бы пару слов о нашем герое статьи. Контроллер CANNY 3 tiny является самым бюджетным в семействе контроллеров CANNY. Старшие братья CANNY 3 tiny – контроллеры серий CANNY 7 и CANNY 5 умеют работать с шиной CAN автомобиля. Наш младший брат, также как и мой старенький автомобиль марки «Жигули», знать не знает ничего о шине CAN и спокойно себе живет.
Более подробно информация о контроллере представлена в соответствующем [разделе Wiki](https://wiki.canny.ru/index.php?title=CANNY_3_tiny). Еще у разработчиков есть раздел на [форуме](https://forum.canny.ru/viewforum.php?id=12), благодаря которому я в итоге разобрался, как настраивать регистры контроллера на вход и выход.
Но к вопросам программирования мы вернемся, позже. Давайте наконец, посмотрим, на нежданный подарок.
Открыв коробку, я испытал короткое чувство умиления. Контроллер реально маленький. Да простят мне фанаты неуместное сравнение, но он — почти как «малыш Йода».
Если верить интернет-магазинам у контроллера есть два варианта комплектации: без клеммной колодки и жгута, а также с ними. Учитывая мою криворукость в плане «припаять что-нибудь» я очень рад тому, что мне досталась версия с клеммной колодкой и жгутом.
Еще несколько фотографий контроллера и жгута спрячу под спойлером.
**Больше фотографий**
Часть II: Подключение схемы
----------------------------
Как я уже сказал, мы будем подключать к контроллеру светодиод (в нашем случае «пиранью»), но можно любой (просто у меня не было другого). Управлять светодиодом мы будем при помощи кнопки. Алгоритм работы такой: один раз нажал на кнопку и светодиод – горит, еще раз нажал – не горит.
Давайте кратко опишем особенности контроллера важные дня нашего случая:
1. Питать контроллер будем от microUSB зарядника (в моем случае 5В, 1 А);
2. У контроллера есть 6 программируемых выводов, а также выводы «+» и «-»;
3. Программируемые выводы могут быть настроены как в качестве «входа», так и в качестве выхода;
4. Максимальный ток на выходе управляемых выводов – 100 мА;
5. У выводов есть разные режимы, включая ШИМ, но мы сегодня так глубоко вдаваться не будем.
Я постарался, сделать, так чтобы вам была понятна, моя простенькая задумка и даже поставил KiCad, чтобы начертить хоть какую-то схемку.
*Если честно я не силен в таких вопросах, да и KiCad вижу первый (или второй) раз в жизни, поэтому если найдете ошибки, обязательно скажите, чтобы я смог поправить.*
Как вы надеюсь поняли из схем, в нашем проекте мы будем использовать: сам контроллер, макетную плату, токоограничивающий резистор на 80 Ом, кнопку похожую на KLS7-TS6601-5.0-180 и светодиод похожий на BL-FL7600UEC, но на самом деле вы можете их заменить на то, что будет у вас под рукой.
Логика подключения такая:
1. Выход «-» контроллера соединяем с шиной минус;
2. Выход «2» будет служить нам «плюсом», подключим его к соответствующей шине на макетной плате;
3. Вывод «1» Будет работать на вход и получать сигнал в случае, если кнопка замкнет цепь (при нажатии);
4. Выход «4» будет питать наш светодиод, для удобства я его подключил к другой шине «+» на макетной плате, но это делать не обязательно.
5. Ёлочка является атрибутом нового года и всячески оправдывает название данной статьи.
Часть III: Программирование
----------------------------
Чтобы запрограммировать контроллер нам понадобится среда разработки CannyLab, скачать её можно с сайта разработчика. На момент написания статьи актуальная версия была 1.41. Среда разработки не требует установки, надо просто распаковать архив в какую-нибудь папку.
Прежде чем писать код для нашей схемы, давайте убедимся, что у нас все работает.
В моем случае перво-наперво надо было записать системное ПО в контроллер.
Подключаем контроллер через microUSB кабель к компьютеру. В моем случае на Windows 10 никаких драйверов вроде отдельно ставить не пришлось.
Убеждаемся, что контроллер подключен, если нет жмем на кнопку «Подключить» (выглядит как два звена цепочки)
Далее надо вызвать диалог по адресу «Устройство -> Системное ПО -> Записать» и выбрать подходящий файл (в моем случае «c3tinyv00108.ccx»). На всякий случай ниже оставлю скриншот.
Теперь можно формировать программу.
Программа формируется путем перетаскивания элементов слева на белое поле рабочего пространства и последующего соединения элементов между собой.
Для того, чтобы поморгать встроенным светодиодом в режиме ШИМ нам понадобится 3 константы, блок генератор сигнала ШИМ и регистр записи.
Соединяем все как на картинке.
Значения константам и регистрам можно задать если сделать по ним двойной клик ЛКМ.
Что же это за загадочные значения констант?
* «3000» – период в 3 секунды;
* «1500» – говорит нам что наш светодиод из трех секунд будет светиться лишь полторы;
* «1» – просто запускает генератор.
*Чтобы долго не искать нужное значение регистра введите в окошке «Фильтр», строку «светодиод»*
Запишем программу в память контроллера.
Далее отсоединим контроллер от компьютера и переключим провод в USB зарядку.
Зеленый огонек моргает с периодом в три секунды, значит все работает как мы и хотели.
Еще пара слов про среду разработки, во-первых она проводит проверку ошибок в диаграмме перед её заливкой в контроллер, а значит есть некоторая «защита от дурака». Во-вторых если нажать на кнопку в виде «жука», то откроется эмулятор работы диаграммы, но об этом как-нибудь в другой раз.
Перейдем к программе для схемы.
Соберите диаграмму как на картинке.
Чтобы не искать долго названия регистров и констант пользуйтесь фильтром по аналогии со скриншотом.
Кратко объясню блоки.
```
«Плюс / подтянут к минусу» - Рег конфиг. вых. потенциалов канал 2»
```
Настраивает нам выход 2 на подачу +5В, аналогично и для четвёртого канала
Поскольку канал 2 фактически используется как «+ 5 В» мы просто запишем в него константу «1» (думаю можно любое число больше нуля).
*Примечание: Напряжение на выходах контроллера зависит от питающего напряжения и может измениться в зависимости от того, как вы его запитаете*
А вот канал 4 у нас то дает +5В, то не дает, в зависимости от нажатия на кнопку.
Канал 1 по умолчанию настроен на вход и ничего не надо настраивать отдельно, берем его входное значение с помощью блока:
```
«Рег вх. знач. канал 1»
```
И передаем на блок логического отрицания («Не»).
Блок «Не» нужен для того, чтобы по умолчанию при включении схемы наш светодиод сразу светился. Если этот блок убрать и соединить регистр 1 канала напрямую с детектором переднего фронта, то светодиод по умолчанию будет отключен.
Детектор переднего фронта срабатывает, когда мы нажимаем кнопку и не будет подавать больше сигналов до тех пор, пока мы снова не решим на неё нажать.
Для сохранения текущего состояния используются «Т» триггер. Если ему на вход «Т» подать единицу, а на вход «С» подавать единичный импульс с выхода детектора, то наш триггер будет на выходе чередовать состояние «0» и состояние «1». Как раз именно то, что нам нужно.
Далее сигнал с выхода триггера идет на регистр выхода канала 4, который в свою очередь питает светодиод.
Обе диаграммы можно скачать с [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/5.Canny).
Часть IV: Заключение
---------------------
На снимках ниже видно, что все работает (и еще видно мой палец).
*Вначале статьи я упоминал про жгут, но мне было лень его зачищать и лудить, поэтому я пока использовал отдельные провода, которые у меня остались еще от опытов с Craftduino.*
«А что у нас с кроссплатформенностью?» – спросите вы. Я попробовал записать код в контроллер запустив среду разработки в Linux через Wine. В итоге среда разработки запустилась, но компьютер сам контроллер не видит (возможно нужно «поколдовать» с Wine). Так, что пока нельзя говорить о кроссплатформенности решения «из коробки».
Еще одним из минусов контроллера можно назвать высокую стоимость по сравнению с некоторыми «Китайскими» подделками под Arduino, однако это отчасти компенсируется качеством. Контроллер приятно держать в руках, да и упаковано все в коробочке было очень аккуратно. Контроллер у меня даже один раз упал, но пока все работает.
Правда в оценках контроллера я, наверное, слегка субъективен. Просто мне приятно, что изделие отечественное и что разработчики пусть хоть чуть-чуть, но причастны к победам КАМАЗов на ралли «Дакар».
В целом подарком я остался доволен, визуальный стиль программирования для меня очень непривычен, но при этом у него есть свои достоинства. Думаю, больше всего он понравиться людям, учившим электронную технику и информатику еще по советским учебникам и знающим, что такое регистры, триггеры, мультиплексоры и т.д.
*UPD: Друзья, я немного отстал от жизни и слегка нарушил правила «Хабра», поэтому я удалил прямые ссылки на сайт разработчиков контроллера, чтобы статья не выглядела рекламной и соответствовала правилам. Я думаю, что ссылку на скачивание среды разработки CannyLab, и «пруфы» про КАМАЗ вы легко найдете самостоятельно.*
*UPD2:
Похоже, что у меня получился небольшой цикл статей, поэтому для вашего удобства я оставлю ссылки на другие статьи по теме:*
1. [«У Предназначения масса обличий...» или автоматизируем управление автолампой с помощью CANNY 3 tiny и фоторезистора](https://habr.com/ru/post/489764/).
2. [«Как зеницу ока...» или делаем простенькую охранную систему на базе микроконтроллера (CANNY или Arduino) и Raspberry PI](https://habr.com/ru/post/497324/).
3. [«Каких Марин?» или управляем контроллером через bluetooth с помощью мобильного приложения на Xamarin (Android)](https://habr.com/ru/post/500454/). | https://habr.com/ru/post/482948/ | null | ru | null |
# Пишем панельный менеджер для сертификатов на linux shell
Привет Хабр!
Многие разработчики недооценивают shell скрипты, пытаясь сравнивать их с другими скриптовыми языками. Но ведь linux shell - в первую очередь оболочка операционной системы, сделанная системными инженерами для системных инженеров. И если для других языков нужно знать библиотеки, то для shell - огромное количество консольных утилит. А также понимание основных принципов работы архитектуры Линукс заметно повысит ваши навыки работы с shell скриптами.
О сертификатах
--------------
С момента популяризации https, работа с сертификатами теперь есть практически в каждом проекте.
Сертификаты, которые любой может сгенерировать сам;
Сертификаты которые выдает местный СА в компании, доверие к которому есть только внутри компании;
Бесплатный публичный let's encrypt,
Платные сертификаты от крупных центров авторизации (Digicert, iDenTrust и др), с дополнительными услугами, типа проверки компании или государственной аккредитацией
Сертификаты для tls/ssl, сертификаты для авторизации, сертификаты для подписи - даже в пределах одного небольшого проекта с десятком микросервисов и несколькими тестовыми окружениями - сертификатов набирается уйма.
При работе с множеством сертификатов, их удобно хранить не отдельными файлами, а складывать в хранилища (keystore). Самые популярные keystore форматы на сегодня - JKS (java keystore, который считается legacy с выходом 9-й джавы) и PKCS12. Последний вышел уже около 20 лет назад, и несмотря на некоторую критику, является одним из самых надежных, открытых и популярных форматов, который в скором будущем должен уже полностью вытеснить JKS.
Я много работал в проектах, где основным языком разработки был java, поэтому при работе с keystore основной инструмент для меня это консольная утилита keytool, которая поставляется с JDK. И для большинства популярных действий у меня конечно есть микро-шпаргалка:
Посмотреть список сертификатов:
```
keytool -list -v -keystore "файл.jks" -storepass "пароль"|grep -P '(Alias name:|Entry type:|Serial number:|Owner:|Valid from:)'
```
Скопировать сертификат из одного keystore в другой keystore:
```
keytool -importkeystore -srckeystore "откуда.jks" -srcstorepass "пароль" -destkeystore "куда.jks" -deststorepass "пароль" -srcalias "имя сертификата" [ -destalias "новое имя" ]
```
Импортировать сертификат в keystore из PEM файла:
```
keytool -import -file "откуда.pem" -keystore "куда.jks" -storepass "пароль" -noprompt -alias "имя_сертификата"
```
Экспортировать сертификат из keystore в файл:
```
keytool -exportcert -v -alias "alias" -keystore "keystore.jks" -storepass "storepassword" -rfc -file "exportedcert.cer"
```
Но однажды мне пришлось поработать в проекте, где сертификатов оказалось мягко говоря много. Плюс несколько сотен виртуалок и контейнеров, где все сертификаты обновлялись вручную. Перед тем как подойти к вопросу автоматизации, было необходимо все это разобрать и причесать. Но долгое время руки просто не доходили - с одной стороны были вещи более приоритетные а сертификаты в общем напрягали нечасто. С другой стороны, опыта разгребания такого объема у меня раньше не было, и навскидку казалось, что в лоб задача решается слишком уныло и кропотливо, браться за нее по своей инициативе не хотелось - задача чисто техническая, никакие менеджеры и представители бизнеса такое перед нашей командой не ставили. Но где-то в подсознании желание все это перебрать и привести в порядок крутилось. Изредка я почитывал статьи, просматривал certificate explorer и его аналоги, но все они были под графическую оболочку Windows, а политика безопасности не позволяла ставить в компании неодобренный софт на десктопы.
Возможно, я бы собрался силой воли, помучился бы недельку, сделал бы все стандартными однострочниками+notepad+excel, но тут внезапно у меня случился больничный отпуск, а когда температура меня попустила, а на работу еще можно было не выходить, я случайно вспомнил, что считаю себя спецом по bash.
И пусть я не хватаю лавры [автора](https://habr.com/ru/users/vaniacer) [PIUPIU](https://habr.com/ru/post/504462/), но тем не менее встречайте:
#### Консольный двух-панельный keystore менеджер на Linux shell
Что умеет менеджер вкратце можно наглядно увидеть на скриншотах.
В одно-панельном режиме:
В двух-панельном режиме:
Для поклонников панельных менеджеров (NC, VC, MC, FAR и др), функциональные клавиши и навигация должны быть интуитивно понятны.
Весьма важным плюсом я считаю, что **jks\_mgr.sh** - это просто шелл скрипт, одним файлом размером ~~20 килобайт~~ *(update: уже 30+ кб)* *(update2: уже 35+ кб)*.
Никаких обсфукаций, код максимально простой - проверить на отсутствие закладок может в принципе любой джуниор - то есть такой скрипт можно использовать в любом проекте, не нарушая никаких требований по безопасности, требований по лицензионности, лоялен к производительности, установка не нужна - лишь бы на целевой машине был доступен шелл, keytool, sed и grep.
Сперва я написал рабочий вариант на bash, но в какой-то момент подумал и переписал все башизмы в пользу POSIX совместимости. Код стал выглядеть более громоздко, зато скрипт проверенно работает в bash/ksh без проблем.
Если я что-то пропустил - напишите в комментариях, ну или форкайте на здоровье.
Некоторое сожаление: привычка работы с java *keytool* вынудила меня всю работу с хранилищами выполнять именно через *keytool*, который должен быть доступен в PATH (а может быть стоило разобраться и сделать все через openssl?).
#### Что было самое интересное во время разработки
Довольно много времени потратил на подстройка панелей под высоту/ширину экрана.
Так как экран у меня перерисовывается почти с каждым нажатием, то менять ширину экрана (например если сидеть через графический ssh клиент) можно на ходу - после первого же нажатия любой клавиши экран перерисуется и все адаптируется. Пару вечеров ушло на опции отображения/скрытия столбцов - нужно было высчитать и отладить подстройку для одно-панельного и двух-панельного режима, плюс заголовки и текст считается разными формулами. Вот кусочек для определения насколько надо обрезать Alias, если экран слишком узкий и затем пример вывода заголовка:
```
WindowWidth="$(tput cols)"
if [ -n "$RFILE" ]; then # two-panel
used=24
[ -n "$SHOW_TYPE" ] && used=$(( $used+34 ))
localWidth=$(( ( $WindowWidth - $used ) / 2 - 1 ))
if [ $localWidth -ne $aliasWidth ]; then
aliasWidth=$localWidth
[ $aliasWidth -lt 1 ] && aliasWidth=1
clear
fi
..................................
headerWidth=$(( $aliasWidth + 5 ))
[ -n "$SHOW_TYPE" ] && headerWidth=$(( $headerWidth + 17 ))
printf " store: ${blue}%-$(( $headerWidth ))s${rst}" "$LFILE"
printf "| store: ${blue}%-$(( $headerWidth -1 ))s${rst}\n" "$RFILE"
printf " %-10s" "Valid to"
[ -n "$SHOW_TYPE" ] && printf " %-16s" "Storetype"
printf " %-${aliasWidth}s |" "Alias"
printf " %-10s" "Valid to"
[ -n "$SHOW_TYPE" ] && printf " %-16s" "Storetype"
printf " %-${aliasWidth}s\n" "Alias"
```
#### Определение нажатия функциональных клавиш
Специальные клавиши представляют собой строку произвольной длины, поэтому просто считать символ или два через read было некорректно. Но после некоторых эксприментов и гугления, я обнаружил что команда read знает что такое миллисекунда. Сейчас процедура выглядит вот так:
```
# Special keypress could take variable amount of characters
keypress=""
read -rsN1 keytap
while [ -n "$keytap" ]; do
keypress="${keypress}${keytap}"
read -sN1 -t 0.01 keytap
done
```
Теперь можно сравнивать **$keypress** с комбинациями:
`F1_KEY=$'\e[11~'
F3_KEY=$'\e[13~'
F10_KEY=$'\e[21~'
UP_KEY=$'\e[A'
DOWN_KEY=$'\e[B'
TAB_KEY=$'\t'
DEL_KEY=$'\e[3~'`
Я все еще не уверен, что мой вариант будет работать идеально везде - поэтому на всякий случай почти все хоткеи продублированы обычными буквами.
В упрощенном виде я подобную навигацию уже копирую в другие свои велосипеды - в некоторых случаях это гораздо удобнее, чем стандартный **select** благодаря наглядности и возможности делать хоткеи.
На текущий момент все самые часто используемые мной функции уже воплощены, и я взял передышку, да и собственно сам скрипт я начал писать чтобы получить еще немного практики с tput и навигацией, но немного увлекся.
Я догадываюсь, что можно заметно ускорить навигацию - производительность в git-bash ужасна - мне быстрее скопировать keystore на ближайшую виртуалку, поковырять там менеджером и скопировать исправленный keystore назад. Но нужно будет переписывать много вычислений, делать независимую пагинацию для каждой панели, а на Linux все работает отлично, поэтому в текущем варианте скрипт меня устраивает и дойдут ли руки до переделки - не уверен.
В конце нужно написать какой-то умный итог и заключение… ну он простой:
Хочешь получить от практики удовольствие - придумай задачу, результат которой будет полезен для тебя.
Хочешь получить от практики двойное удовольствие - придумай задачу, результат которой будет полезен и для тебя и для кого-нибудь еще.
Сейчас моим скриптом пользуется небольшой круг людей в компании, и то, что я, не разработчик, смог написать нечто полезное и востребованное, меня очень радует.
*P.S. На фоне некоторых проблем с nginx, Wargaming и др., сразу хочу уточнить, что* ***jks\_mgr.sh*** *был написан ИСКЛЮЧИТЕЛЬНО в* ***нерабочее*** *время на* ***личном*** *компьютере.*
P.P.S. Совсем забыл: <https://github.com/sfkulyk/jks-manager> | https://habr.com/ru/post/539612/ | null | ru | null |
# Объединяем две локальные сети через интернет. Vpn lan to lan. Asus wl520gu+dd-wrt и FreeBSD+mpd5
**Введение.**
Мне повезло работать в организации которая развивается, и время от времени возникают новые задачи, позволяющие и мне расти. На этот раз мне было необходимо объединить головной офис и второй филиал. Задача для меня не новая, но к её решению я решил подойти иначе нежели раньше.
На текущий момент в головном офисе установлена FreeBSD + mpd5 в качестве PPTP сервера. В первом филиале аналогично(за исключением того что используется как vpn клиент). Так же есть 8 точек где установлено по одному компьютеру с ОС Windows XP «цепляющихся» к головному стандартным клиентом этой ОС.
Мне необходимо создать еще один туннель между двумя сетями, но любимую ОС FreeBSD я использовать не могу, в силу ограниченного места для установки роутера во втором филиале(это магазин розничной торговли, все оборудование приютилось на узеньком стелаже). К тому же хотелось попробовать прошивку dd-wrt, о которой так много слышал, в деле.
**Начало.**
Итак мы имеем:
VPN сервер: FreeBSD 7.3(Release i386) + mpd5(Version 5.3)
VPN клиент: Asus wl520gu + dd-wrt(DD-WRT v24-sp2 (10/10/09) vpn)
\*таки прошивка пока что стандартная, а dd-wrt еще только предстоит «навернуть», чем и займемся.
**Прошивка роутера.**
Во многих статьях, найденных мною, авторы почему-то опускали описание процесса прошивки маршрутизатора, ссылаясь на простоту этого действа. Я потратил около получаса на чтение документации на официальном сайте, написано весьма доходчиво. Но я все таки опишу, по шагам, то что я делал.
1.Необходимо выполнить аппаратный сброс, так называемый 30/30/30. Это необходимо для того чтобы попасть в инженерный режим. Получить возможность «залить» прошивку.
При включенном питании роутера нажимаем кнопку reset, держим 30 секунд, не отпуская кнопку отключаем питание и держим еще 30 секунд, не отпуская кнопки включаем питание и вновь удерживаем кнопку reset 30 секунд.
Хинт: по умолчанию ip роутера 192.168.1.1. Если «пингануть» его до аппаратного сброса 30/30/30 то ttl будет равен 64, после сброса ttl становится равным 100.
2.Качаем прошивку [dd-wrt.v24\_mini\_asus.trx](http://dd-wrt.com/routerdb/de/download/Asus/WL520GU/-/dd-wrt.v24_mini_asus.trx)
\*другие прошивки/прошивки для других моделей роутеров доступны на [dd-wrt.com/site/support/router-database](http://dd-wrt.com/site/support/router-database)
3.Следующим шагом у нас идет заливка скачанной прошивки. Для этого нам понадобится утилита tftp(tftp — trivial file transfer program). Поскольку у меня на нетбуке установлена Ubuntu, то установка сводится к одной команде
`sudo aptitude install tftp`
переходим в папку с файлом прошивки
`cd Загрузки`
подключимся к роутеру
`tftp 192.168.1.1`
выбираем бинарный режим
`mode binary`
отправляем файл с прошивкой
`put dd-wrt.v24_mini_asus.trx`
Теперь **ВНИМАНИЕ**, после того как программа проинформирует вас о окончании процесса передачи файла, включите секундомер и **ЖДИТЕ РОВНО ПЯТЬ ЗЕМНЫХ МИНУТ**.
4.По прошествии 5 минут, отключаем железяку от питания, и ждем 30-40 секунд. Включаем, проверяем, если при «пинговании» видим ttl=64, то можно уже чуть-чуть радоваться =)
5.Идем на [192.168.1.1](http://192.168.1.1), нас попросят изменить имя пользователя и пароль. Меняем и вновь перезагружаем маршрутизатор(этот шаг я выполнил больше из-за перестраховки).
Теперь можно полазить по web интерфейсу, поверьте он весьма и весьма приятен и интересен
Далее можно залить какую-то другую прошивку от dd-wrt используя уже web интерфейс. В моем случаем это dd-wrt.v24\_vpn\_generic.bin. Тут уже точно ничего сложного, но не забывайте про **ПЯТЬ ЗЕМНЫХ МИНУТ** =)))
\*здесь заботливые создатели покажут нам таймер отсчитывающий секунды с 300
После чего настраиваем под себя. Повторюсь, web интерфейс весьма хорош. На каждой страничке есть подсказка, не примените воспользоваться!
**Настройка VPN**
В результате экспериментов конфиг mpd5 принял следующий вид
`pptp_vpn_filial2:
create bundle static pptp1
set ipcp ranges 10.255.255.11/32 10.255.255.12/32
set ipcp dns 192.168.0.5
set iface route 192.168.4.0/24
set iface enable proxy-arp
set iface enable on-demand
set bundle enable compression
set ccp yes mppc
set mppc yes e128
set mppc enable compress
set bundle enable crypt-reqd
set mppc yes stateless
create link static lpptp1 pptp
set link action bundle pptp1
set link no pap
set link yes chap
set auth authname "onotole"
set auth password "ololololo"
set link mtu 1460
set link keep-alive 0 0
set link max-redial -1
set pptp peer 172.17.59.12
set link enable incoming`
настройки ASUS'а на скрине
Вот пожалуй и все. Трафик из сети в сеть бегает и шифруется.
— НЕБОЛЬШОЙ АПДЕЙТ---
После установления соединения dd-wrt'овый pppd(в соответствии со соим конфигом /tmp/pptpd\_client/options.vpn) шлет каждые две секунды lcp эхо реквесты(подробнее смотрите в rfc 1661 ppp) и после того как сервер ему не ответит в третий раз пресылает Terminate-Request в итоге соединение рвется. За такое поведение отвечают параметры lcp-echo-interval и lcp-echo-failure в конфиге. Их нам и нужно ~~убрать к чертям~~ исключить, для этого идем на веб интерфейс Administration --> Commands и вбиваем такой скрипт:
`(while [ ! -f /tmp/pptpd_client/options.vpn ]; do sleep 10; done
sed /lcp/d /tmp/pptpd_client/options.vpn > /tmp/pptpd_client/temp.vpn
cp /tmp/pptpd_client/temp.vpn /tmp/pptpd_client/options.vpn )&`
Жмем Save startup, после чего ребутим роутер. | https://habr.com/ru/post/99925/ | null | ru | null |
# Измерение веса руды по току статора. Практика. Часть 2. Программная реализация на МК
Последняя часть из цикла **«Измерение веса полезных ископаемых»**. В данной статье будет показана программная реализация на МК.
Вспомним основы данного метода измерение веса полезных ископаемых по току статора шахтной подъемной установки (ШПУ), оборудованной высоковольтным асинхронным двигателем с фазным ротором.
* [Теоретические основы. Формулы расчета.](https://habrahabr.ru/post/275141/)
* [Практика. Часть 1. Алгоритм обработки сигналов в МК.](https://habrahabr.ru/post/275459/)
#### **Вместо предисловия**
Так как реальное устройство не проектировалось и не изготавливалось, то для симулирования данного процесса использовался программный комплекс Proteus. Данный симулятор поддерживает множество различных МК и из списка им поддерживаемых выбиралась аппаратная платформа для реализации алгоритма и проверки всего метода.
#### **Предисловие**
Для удобства проведения испытаний при симулировании, исходная схема в протеусе, показанная в [первой части](https://habrahabr.ru/post/275141/), претерпела изменения. Рассмотрим изменения.
[](https://habrastorage.org/files/c06/5b9/034/c065b90344904f41b22a60125c18505b.JPG)
*Первый лист схемы. Картинка кликабельна.*
Изменения коснулись в размножение сигнала напряжения, разрыва токовой цепи, введения индуктивной составляющей в цепь нагрузки.
[](https://habrastorage.org/files/77b/b53/d11/77bb53d1187f484db109d1009cc616dd.JPG)
*Второй лист схемы. Картинка кликабельна.*
Используется компонент ComPim, для связи с ком портом системы. МК фирмы Microchip. Входные сигналы с первого листа. Приборы (вольтметр, амперметр) для визуального контроля параметров напряжения и тока. Переключатели, используются для проведения автоматического вычисления средней точки каналов тока и напряжения.
#### **Введение**
При написании программы для МК PIC18F2580 использовалась бесплатная IDE MpLab X v 2.26, компилятор XC8 v1.20.
Во время разработки программы, пришлось написать собственные математические функции:
* извлечение квадратного корня из целого 32-х битного числа,
* извлечение квадратного корня из числа с плавающей точкой одинарной точности,
* умножение целых беззнаковых чисел 16 бит,
* умножение целых знаковых чисел 16 бит.
Стандартные функции, которые компилятор использует, не подходили в плане быстродействия, это касается умножения 16х16. А библиотечной функции извлечения квадратного корня из целого 32-х битного числа вообще не нашлось.
Также в проекте использовались пользовательские типы переменных. Они введены для удобства использования.
Пользовательские типы переменных описаны в хидере user\_type.h
#### **Инициализация МК**
Инициализация МК вынесена в отдельный модуль в проекте. Производится согласно даташиту на МК. В хидере модуля инициализации включены конфигурационные биты (фьюзы). Для данных МК эти фьюзы можно зашить в прошивку, в .hex файл.
Вот хидер.
```
#include
/\*
Установка конфигурационных битов МК
\*/
#pragma config IESO = OFF
#pragma config OSC = HSPLL //HS oscillator, PLL enabled (Clock Frequency = 4 x FOSC1)
#pragma config MCLRE = ON //MCLR pin enabled; RE3 input pin disabled
#pragma config XINST = OFF //Instruction set extension and Indexed Addressing mode disabled (Legacy mode)
#pragma config PBADEN = OFF //PORTB<4:0> pins are configured as digital I/O on Reset
/\*
Прототипы функций инициализация периферии МК
\*/
void INT\_init(void);
void T0\_init(void);
void ADC\_init(void);
void USART\_init(int BAUD);
void T2\_init(void);
void PIC\_init(void);
```
Инициализируем необходимую периферию собственной функцией.
Прерывания в данном МК имеют приоритет. Уровней всего два: высокий и низкий. Прерывание от таймера 0, по которому отсчитываем временные интервалы (семплы) для измерений сигналов напряжения и тока, имеет высокий приоритет, так как он критичный ко времени, остальные низкий.
#### **Обработка сигналов с АЦП**
По прерыванию от детектора, который заведен на внешнее прерывание INT1, запускаем таймер с отсчетом 200 мкс интервала. По прерыванию таймера, загружаем в него предустановленное значения, для точного отсчета, и производим считывание значений АЦП с обоих каналов и выполняем предварительные вычисления.
```
if (Count_sample=SAMPLE){ //Завершаем измерения, останавливаем таймер
Count\_sample=0;
Flag\_izm=1;
T0CONbits.TMR0ON=0;
}
```
В основном цикле, по флагу **Flag\_izm** производим дополнительные промежуточные вычисления.
```
if (Flag_izm){ //Производим расчеты
Flag_izm=0;
if (Count_main_sample
```
#### **Протокол ModBus RTU**
В данной реализации связь с «внешним» миром осуществляется с использованием USART МК, поверх данного интерфейса применен промышленный протокол ModBus RTU. Реализация данного протокола довольна проста и не ресурсоемка. Прием сообщений производится в прерывании от приемника USART.
```
/*обработчик прерывания от приемника уарт*/
if (PIR1bits.RCIF){
if (RCSTAbits.FERR || RCSTAbits.OERR) { /*В случае ошибки приемника*/
RCSTAbits.CREN=0; /*Отключаем приемник для сброса ошибки*/
RCSTAbits.CREN=1; /*Включаем приемник для продолжения работы УАРТ*/
}
MODBUS.rxtimer=0; /*Сбрасываем таймер конца фрейма по приему очереднего байта*/
if(MODBUS.rxcnt>(BUF_SZ-2)) MODBUS.rxcnt=0;
MODBUS.buffer[MODBUS.rxcnt++]=RCREG1; /*Записываем очередной байт в массив данных ModBus*/
PIR1bits.RCIF=0; /*Сбрасываем флаг прерывания от приемника УАРТ*/
}
```
Обработка сообщений от мастера происходит в основном цикле, когда критичные ко времени измерения закончены.
```
if (Flag_izm){ //Производим расчеты
…
if (MODBUS.rxgap){ //Если пришло сообщение
MODBUS_SLAVE(&MODBUS); //обрабатываем его
MODBUS.rxgap=0;
}
}
```
Передача по USART организована не совсем оптимальным, блокирующим способом.
```
/*
* Функция отправки сообщения мастеру
*/
void TX_FRAME(UART_DATA *MODBUS)
{
RCSTAbits.CREN=0;
TXSTAbits.TXEN=1;
INTCONbits.GIEH=0; /* во время передачи отключим прерывания*/
INTCONbits.GIEL=0;
while(MODBUS->txcnttxlen){
TXREG=MODBUS->buffer[MODBUS->txcnt++];
while(!PIR1bits.TXIF) NOP();
}
INTCONbits.GIEH=1;
INTCONbits.GIEL=1;
MODBUS->txlen=0;
RCSTAbits.CREN=1;
}
```
#### **Заполнение таблицы регистров ModBus**
Протокол ModBus позволяет разработчику оборудования самому определять, какие регистры в карте за какой параметр будут отвечать. Нет каких то жестких правил в этом деле. Так что мы не будем придумывать что-то сложное и не разумное.
Начнем с первого регистра (нулевого). В него положим значение действующего напряжения в формате Real, то есть значение будет занимать два 16-ти битных регистра Modbus. Далее значение тока, активной мощности, полной мощности, косинуса.
```
res_table[0].Val=U_real.word.LW; //Заполняем таблицу регистров
res_table[1].Val=U_real.word.HW; //Модбас, для ответа мастеру
res_table[2].Val=I_real.word.LW;
res_table[3].Val=I_real.word.HW;
res_table[4].Val=P_real.word.LW;
res_table[5].Val=P_real.word.HW;
res_table[6].Val=P_pol.word.LW;
res_table[7].Val=P_pol.word.HW;
res_table[8].Val=Cos_p.word.LW;
res_table[9].Val=Cos_p.word.HW;
```
Теперь при запросе мастера значений данных регистров, устройство ответить вполне адекватными данными.
Для отображения данных от устройства, на данном этапе, воспользуемся OPC сервером. Его внутренних инструментов достаточно для отображения данных, записи значений в регистры и т.д.
#### **Автоматическое определение средней точки каналов и расчет коэффициентов**
Для проведения измерений, нам необходимо вычислять среднюю точку синусоиды сигналов напряжения и тока. В данном случае, мы будем использовать алгоритм, расписанный в [прошлой статье](https://habrahabr.ru/post/275459/).
Для автоматического вычисления АЦП0 каналов, необходимо снять с них полезный сигнал, т.е. разорвать токовую петлю, в которую включен датчик тока ACS712 и подключить на вход напряжения среднюю точку с ОУ. Далее алгоритм, произведет вычисление среднеквадратичного значение сигнала, и по команде от мастера, мы вычисленные значения занесем в АЦП0 для каждого канала и запишем эти значения в EEPROM. После этого, подключим исследуемые сигналы напряжения и тока.
```
if (MODBUS.write){
if (res_table[10].Val==1){ //Команда на автоматическое
U_0.Val=(WORD)U_real.Val; //вычисление АЦП0
I_0.Val=(WORD)I_real.Val;
eeprom_write(0,U_0.byte.HB); //Записываем в еепром значения
eeprom_write(1,U_0.byte.LB); //АЦП0 по каналам
eeprom_write(2,I_0.byte.HB);
eeprom_write(3,I_0.byte.LB);
}
}
```
Для вычисления коэффициентов воспользуемся следующим порядком действий. После вычисления средней точки каналов, подключения реальных сигналов на аналоговые входы, алгоритм вычисляет среднеквадратичное значение напряжения и тока в единицах АЦП. Для перевода их в физические величины необходимо измерить данные сигналы приборами, вольтметром и амперметром. Измеренные приборами значения записываем в нужные регистры Модбас, и по команде от мастера производим вычисление коэффициентов. Для уменьшения длины посылки по Модбас, в данной реализации, значение с приборов переводится к целочисленному значению путем умножения значения напряжения на 10, а значение тока на 100. Полученные данные записываются в регистры, и по команде от мастера производится расчет коэффициентов. Рассчитанные коэффициенты записываются в EEPROM.
```
if (MODBUS.write){
if (res_table[10].Val==2){ //Команда на вычисление коэффициентов
K_u.Val=U_real.Val/res_table[11].Val; //тока и напряжения
K_u.Val*=10.0;
K_i.Val=I_real.Val/res_table[12].Val;
K_i.Val*=100.0;
eeprom_write(4,K_u.byte.MB); //Записываем коэффициенты
eeprom_write(5,K_u.byte.UB);
eeprom_write(6,K_u.byte.HB);
eeprom_write(7,K_u.byte.LB);
eeprom_write(8,K_i.byte.MB);
eeprom_write(9,K_i.byte.UB);
eeprom_write(10,K_i.byte.HB);
eeprom_write(11,K_i.byte.LB);
}
res_table[10].Val=0;
MODBUS.write=0;
}
```
#### **Расчет веса**
Вес руды можно высчитывать непосредственно из формулы, приведенной в [первой части](https://habrahabr.ru/post/275141/) повествования.
Где:
* F0 – сила развиваемая двигателем при подъеме пустого сосуда,
* F – сила, измеренная при подъеме груженного сосуда,
* g – ускорение свободного падения в точки взвешивания.
В данной реализации измерение массы не производится, так как симулирование в Протеусе не предусматривает такую возможность.
Симуляция в протеусе позволяет понять жизнеспособность основной идеи: «Измерение веса руды во время транспортировки в подъемном сосуде по току статора».
Архив с проектом в MpLab X и файлом проекта протеуса находится [здесь](https://yadi.sk/d/XvW-fu1YnrHKZ).
***Видео, наглядно показывающее обработку сигналов напряжения и тока, вычисление активной мощности, косинуса фи и полной мощности показано ниже.***
#### **Заключение**
Измерение веса добытых полезных ископаемых в промышленности имеет большое значение в технологическом учете, оценки эффективности производимых работ и т.д.
Для измерения массы руды используется много различных видов и типов весовых устройств.
В данном цикле статей была рассмотрена возможность измерения веса руды, по измерению развиваемого момента приводного двигателя ШПУ во время транспортировки груза в подъемном сосуде. Данный способ используется в ШПУ снабженными двигателями постоянного тока, где вычисление массы производится по току якоря при постоянном возбуждении.
**P.S.**
Так как добыча полезных ископаемых в мире производится в больших объемах, и предпосылок на снижение нет, то этот способ измерения весы руды для технологического учета имеет право на жизнь. И может в недалеком будущем мы увидим промышленные устройства для измерения массы груза в подъемном сосуде, основанные на данном принципе. | https://habr.com/ru/post/276051/ | null | ru | null |
# Доступ к SOAP веб-сервисам 1С из JavaScript и Html
Описанный метод позволяет обратиться к веб-сервисам 1С из html-страницы через JavaScript. В качестве примера выводится список справочников. При нажатии на любой справочник выводятся первые буквы наименований. При нажатии на букву выводятся данные с наименованиями, начинающимися на эту букву.
Способ применим для случаев, когда веб-сервис и html-страница опубликованы на одном сервере. В этом случае не возникает кросс-доменных проблем. Например, если домены будут отличаться, то Chrome выдаст ошибку:
`Failed to load resource: Origin localhost:3299 is not allowed by Access-Control-Allow-Origin`
Не вдаваясь в подробности публикации веб-сервисов, предположим, что на стороне 1С создан и опубликован веб-сервис catalogs с операцией Execute. На входе — параметр script типа string, на выходе тип string. Операция запускает на стороне произвольный код script из параметра и возвращает JSON-сериализацию от переменной result.
```
Функция ExecuteCommands(script)
result = null;
Execute(script);
return JSON(result);
КонецФункции
```
С JSON-сериализацией удобно работать средствами JavaScript и преобразовать строку в объект/массив одной командой eval(resultText). В Интернете можно найти несколько JSON-сериализаторов для 1С.
Удостоверимся, что веб-сервис отвечает, введя его адрес:
Проект Html-файла лучше начать с готового шаблона, где прописаны стили на все случаи браузеров. Весьма достойный шаблон находится по адресу [html5boilerplate.com](http://html5boilerplate.com/) В шаблон включен jQuery 1.9.1.
На форме сверху разместим элементы настройки веб-сервера: wsUrl — адрес веб-сервиса, wsUser — логин, wsPassword — пароль. На стороне веб-сервиса 1С включена basic autherization. Логин и пароль соответствуют пользователю, прописанному в 1С.
Левая панель отвечает за отображение доступных справочников catalogsList, правая — за отображение букв (letters) и данных (catalogRecords).
JavaScript
----------
Функция обращения к SOAP веб-сервису определена следующим образом:
```
function executeSoap(script, successHandler) {
var wsUrl = $("#wsUrl").val();
var soapRequest =
'xml version="1.0" encoding="utf-8"?' +
'' +
'' +
'' +
'<' + 'script xsi:type="xsd:string">' + script + '' +
'' +
'' +
'';
$.ajax({
type: "POST",
url: wsUrl,
contentType: "text/xml",
dataType: "xml",
username: $("#wsUser").val(),
password: $("#wsPassword").val(),
data: soapRequest,
success: successHandler,
error: processError
});
}
```
На входе в executeSoap подается скрипт 1С, который выполняется на стороне 1С, и обработчик для удачного исполнения. В случае ошибки вызовется обработчик processError, который выведет сообщение об ошибке.
Код 1С записан в html-коде через script-тэг. Получить текст каждого куска кода для выполнения можно через jQuery $("#enumerate1CCatalogs").text().
Получение списка наименований каталогов.
```
result = Новый Массив();
Для Каждого СправочникИзМетаданных Из Метаданные.Справочники Цикл
структура = Новый Структура("name, synonym");
структура.name = СправочникИзМетаданных.Имя;
структура.synonym = СправочникИзМетаданных.Синоним;
result.Добавить(структура);
КонецЦикла;
```
Получение первых букв наименований справочника {catalog}
```
запрос = Новый Запрос();
запрос.Текст = "ВЫБРАТЬ РАЗЛИЧНЫЕ Подстрока(Наименование, 0, 1) КАК letter ИЗ Справочник.{catalog} УПОРЯДОЧИТЬ ПО Подстрока(Наименование, 0, 1)";
result = запрос.Выполнить().Выгрузить();
```
Получение данных для каталога {catalog}, где первая буква входит в условие {condition}.
```
запрос = Новый Запрос();
запрос.Текст = "ВЫБРАТЬ Ссылка as ref, Наименование as name ИЗ Справочник.{catalog} ГДЕ Подстрока(Наименование, 0, 1) В ({condition})";
result = запрос.Выполнить().Выгрузить();
```
При нажатии на кнопку Обновить происходит вызов функции
`executeSoap($("#enumerate1CCatalogs").text(), processSuccess);`
и при успешном выполнении вызывается обработчик processSuccess
```
function processSuccess(data, status, req) {
var resultText = $(req.responseText).find("m\\:return").html();
result = eval(resultText);
$("#catalogRecords").empty();
catalogsList = $("#catalogsList");
catalogsList.empty();
$(result).each(function (index, item) {
var li = '- ' + item.synonym + '
';
catalogsList.append(
$(li).addClass("catalogTitle")
);
});
}
```
Веб-сервис возвращает xml, где значимым является содержимое m:return-тэга — JSON-сериализация. Перевести его в объекты JavaScript можно через eval-вызов. Обработчик очищает перечень справочников и заново его формирует через li-тэги с атрибутом catalog. Каждому элементу устанавливается класс catalogTitle.
Веб-сервис возвращает xml, где значимым является содержимое m:return-тэга — JSON-сериализация. Перевести его в объекты JavaScript можно через eval-вызов. Обработчик очищает перечень справочников и заново его формирует через li-тэги с атрибутом catalog. Каждому элементу устанавливается класс catalogTitle.
Аналогично обрабатываются нажатия на все управляющие элементы. Нажатие на справочник очищает буквы и данные, перезаполняет буквы. Нажатие на букву перезаполняет данные из справочника. За обработку кода на 1С отвечают куски кода в script-блоках с типом «text/1c».
Приложение выглядит так:
Нерешенная проблема авторизации на браузере IE
----------------------------------------------
Существует проблема авторизации на IE. На IE 8/9 не удалось решить проблему basic authorization аналогичным для остальных браузеров методом.
На IE Ajax не работает с использованием user/password — свойств $.ajax. На FF и Chrome все работает нормально. По какой-то причине на сервер в случае с IE не передается заголовок
`Authorization: Basic 0JHQsNGF0YjQuNC10LLQn9CYICjRgNGD0LrQvtCy0L7QtNC40YLQtdC70YwpOg==`
**Если кто-нибудь знает причину и как обойти, пожалуйста, напишите в комментариях.**
Выводы
------
Предложенный подход на основе SOAP имеет право на существование для несложных задач, так как сопровождается достаточно большим числом JavaScript кода. Возможно, в будущем удастся создать JavaScript фреймворк для упрощения процесса создания приложений.
Разработчики в этом способе самостоятельно отвечают за безопасность. Необходимо проверять входные параметры при записи, не позволять запуск произвольных скриптов, переданных с клиента. В статье выполнение произвольного кода показано только для примера. Унифицировать можно выполнение произвольного запроса, но это связано с опасностью SQL-инъекций.
Внешние компоненты Native API от 1С не будут работать в данной среде. Это значит, что нужно дополнительно решать проблему с написанием драйверов для оборудования.
Пример веб-сайта: [web-site.zip (81,76 kb)](http://www.richmedia.us/file.axd?file=2013%2f6%2fweb-site.zip) | https://habr.com/ru/post/184540/ | null | ru | null |
# Вытаскиваем кучу паролей из пиринговых сетей
[](http://habrastorage.org/storage/habraeffect/8d/f1/8df190601ff2e5b90fc80a9741070f04.png "95 wand.dat всего с восьми хабов; скриншот сделан в 8:30 MSK 29 апреля 2010")Появилась эта задумка уже давно — с тех самых пор, когда узнал про wand.dat. До недавнего времени всё никак не доходили руки.
Итак, что у нас есть1. Браузер Opera. Хранит он все запомненные пароли от сайтов в файле wand.dat в открытом виде. Правда в открытом только в том случае, если не стоит мастер-пароль, который конечно же никто не ставит. Что заставило разработчиков сохранять пароли в незашифрованном виде, если нет мастер-пароля? Неизвестно. Логичней было бы форсированно не сохранять пароли вообще, пока пользователь-таки не установит мастер-пароль.
2. Direct Connect. «Частично централизованная файлообменная (P2P) сеть». Пользователь расшаривает папки/файлы на своём компьютере, заходит на хабы, качает/раздаёт. Поиск работает в пределах подключенных хабов. Уникальность файлов определяется через Tiger Tree Hashing. Люди, которым нечего расшаривать (на многие хабы не пускают без минимальной шары в 10-15 ГБ), расшаривают Program Files, Windows, ну и иже с ними.
3. /dev/hands. Ну а без этого никак.
В чём состояла задумка: написать бота, сидящего на хабах и регулярно ищущего **и качающего** wand.dat. Писал я программу на любимом Delphi.
Собственно, алгоритм работы бота:1. Бот сканирует папку для сохранённых файлов, перебирает файлы по заданному паттерну имён, сохраняет TTH файлов (модуль для снятия TTH для Delphi написан MetalFan’ом и взят [отсюда](http://forum.vingrad.ru/topic-139574/kw-tth.html)) в памяти. Заодно создаётся batch-скрипт для обработки всех существующих wand’ов за один двойной клик. В качестве парсера используется, например, [вот это](http://www.virustotal.com/ru/analisis/cfe79acf9235a8621e6aeec62a7f261dfe7f79654e4dfd22b0a172ff4ca04374-1272301955).
2. Открывается заранее приготовленный список хабов в формате «одна строчка — один хаб». На каждый хаб создаётся отдельный тред.
3. Откуда брать список хабов? Качается [bz2-файл с хабами](http://dchublist.com/hublist.xml.bz2), распаковывается, парсится чем угодно (внизу пример парсера на php).
4. Заходим на хаб. Ищем wand.dat размером не меньше килобайта. Повторяем поиск каждые 20-ь минут.
5. Качаем каждый найденный wand.dat, если такого TTH ещё нет во внутренней базе программы. Сохраняем в папку к остальным. Добавляем TTH нового файла к своему списку, обновляем batch-скрипт для обработки накаченного.
6. Когда надоест качать, выключаем бота, запускаем скрипт, Получаем один конечный файл со всеми паролями
Единственные знания, которые потребовались при программировании: WinSock, многопоточные приложения, протокол [Direct Connect](http://www.teamfair.info/DC-Protocol.htm) (да и то не весь). Из нового для меня был только сам протокол. На написание ушло 8 часов. 380 строк кода без модулей. В скомпилированном программа виде занимает 149 Килобайт. **Выкладывать бота не буду, это чревато.**
Ну а парсер списка хабов на php вот:
`</fontphp
header('Content-type: text/plain');
$f\_name='./hublist.xml';
$f =fopen($f\_name,'r');
$buf=fread($f,filesize($f\_name));
fclose($f);
preg\_match\_all('|address="dchub://([a-z0-9:.-]+?)"|i',$buf,$a);#да-да, знаю, паттерн не самый прямой
$f =fopen('./hublist.txt','w');
for ($i=0;$i$a[1]);$i++){fwrite($f,$a[1][$i]."\r\n");}
fclose($f);
echo 'done '.count($a[1]);
?>`
Паттерн при надобности можно поправить, например, на исключительно .ru-хабы.
##### Тест
Тестировал программу с 25 по 28 апреля 2010. За это время накачано **232** wand.dat. Самый жирный занимал 129 Килобайт. Что нашёл в этих вандах? **Я их даже не открывал**, ибо это уже нехорошо. Да и не пароли от вконтактиков были целью. Целью написания бота была проверка на трудность задачи автоматизации утаскивания паролей, лежащих на видном месте без присмотра.
##### Что накаченным богатством делать
А что там в этих вандах *может быть*?1. Во-первых, список валидных почтовых адресов. Можно использовать для спама. (На самом деле затраты их добычи таким способом не окупаются совершенно, легче использовать встроенный поиск MailAgent’а).
2. Пароли от всяких Контактов/Одноклассников/Фейсбуков — ценности для хакеров никакой.
3. Доступ к ftp сайтов, это уже опаснее — от надписи «Haxored by xakep Vasya666» до эксплойта на главной хакера отделяет лишь выдумка.
4. Список почтовых аккаунтов с паролями. По-моему, это самое опасное. Почту, как всем известно, с серверов никто не удаляет.
5. Пароли от аккаунтов у вашего провайдера. Правда за такое вас однозначно накажет провайдер. Жесто-о-око накажет.
На самом деле в вандах ещё может всякого лежать, только это всякое я описывать не буду, дабы не махать красной тряпкой перед хакерами, вернувшимися со школы.
##### Результат
Пароли. Очень много паролей за достаточно малый промежуток времени при минимальных одноразовых усилиях.
##### Вывод
Вывод? Какой ещё может быть **новый** вывод? Опять напоминать про то, что надо ставить мастер-пароли на браузеры, коли вы сохраняете пароли в браузере? Напоминать, что надо следить за тем, что вы расшариваете? **НО ЗАЧЕМ?! К этому всё равно никто не прислушается.** Вот только не плакать, когда жареный петух клюнет в одно место. | https://habr.com/ru/post/92343/ | null | ru | null |
# Swift. Struct vs Class memory and performance comparison или следует ли всегда использовать Struct
Проблема
--------
Как и многие iOS разработчики, я столкнулся с дилеммой: какой объект использовать для построения архитектуры проекта. Взять для примера реализацию паттерна фасад. Этот объект должен принять некоторое количество сущностей и реализовать методы для упрощенного доступа к ним. Если не вдаваться в подробности, то подойдет и класс, и структура: оба могут инкапсулировать объекты и функции. Так что же выбрать?
А что говорит Apple?
--------------------
Если обратиться к статье на сайте Apple [Choosing Between Structures and Classes](https://developer.apple.com/documentation/swift/choosing_between_structures_and_classes), то следуя пункту "Use structures by default.", нужно использовать структуры в нашем случае. Если конечно не нужна Objective-C совместимость.
Тестовые объекты
----------------
Объекты наполнения для целевых объектов:
```
protocol ObjectForProperties {
var queue: DispatchQueue { get } // reference type
var bool: Bool { get } // value type
}
final class ClassForProperty: ObjectForProperties {
var queue: DispatchQueue = .main
var bool: Bool = true
}
struct StructForProperty: ObjectForProperties {
var queue: DispatchQueue = .main
var bool: Bool = true
}
var classForProperty = ClassForProperty() // reference type
var structForProperty = StructForProperty() // value type
var array = [1] // value type with Copy-on-Write
```
Целевые объекты:
```
// Используем класс без использования протоколов
final class UseClassWithoutProtocols {
var ref: ClassForProperty
var value: StructForProperty
var array: [Int]
init(ref: ClassForProperty, value: StructForProperty, array: [Int]) {
self.ref = ref
self.value = value
self.array = array
}
}
// Используем класс с использованием протоколов
final class UseClassWithProtocols {
var ref: ObjectForProperties
var value: ObjectForProperties
var array: [Int]
init(ref: ObjectForProperties, value: ObjectForProperties, array: [Int]) {
self.ref = ref
self.value = value
self.array = array
}
}
// Используем структуру без использования протоколов
struct UseStructWithoutProtocols {
var ref: ClassForProperty
var value: StructForProperty
var array: [Int]
}
// Используем структуру с использованием протоколов
struct UseStructWithProtocols {
var ref: ObjectForProperties
var value: ObjectForProperties
var array: [Int]
}
let useClassWithoutProtocols = UseClassWithoutProtocols(
ref: classForProperty,
value: structForProperty,
array: array
)
let useClassWithProtocols = UseClassWithProtocols(
ref: classForProperty,
value: structForProperty,
array: array
)
var useStructWithoutProtocols = UseStructWithoutProtocols(
ref: classForProperty,
value: structForProperty,
array: array
)
var useStructWithProtocols = UseStructWithProtocols(
ref: classForProperty,
value: structForProperty,
array: array
)
```
Размещение в памяти объектов
----------------------------
Структуры передаются копированием значения. У классов вместо копирования используется ссылка на существующий экземпляр. Для некоторых стандартных типов значения реализован механизм [Copy-on-Write](https://medium.com/@lucianoalmeida1/understanding-swift-copy-on-write-mechanisms-52ac31d68f2f), который позволяет передавать объект передавая адрес и копировать только если объект изменяется. Но Copy-on-Write не реализован у структур по-умолчанию, то есть StructForProperty будет передаваться копированием в любом случае.
Проверим размещение объектов в памяти (опустим закрытые протоколом значения для чистоты эксперимента):
```
func address(of o: UnsafePointer) -> String {
String(format: "%p", Int(bitPattern: o))
}
func address(of classInstance: T) -> String {
String(format: "%p", unsafeBitCast(classInstance, to: Int.self))
}
// classForProperty addresses
print(address(of: classForProperty)) // 0x6000020e9600
print(address(of: useClassWithoutProtocols.ref)) // 0x6000020e9600
print(address(of: useStructWithoutProtocols.ref)) // 0x6000020e9600
// structForProperty addresses
print(address(of: &structForProperty)) // 0x111a1bca8
print(address(of: &useClassWithoutProtocols.value)) // 0x600002edb6d8
print(address(of: &useStructWithoutProtocols.value)) // 0x111a1bcd8
// array addresses
print(address(of: &array)) // 0x600002edb2f0
print(address(of: &useClassWithoutProtocols.array)) // 0x600002edb2f0
print(address(of: &useStructWithoutProtocols.array)) // 0x600002edb2f0
```
Что и требовалось доказать:
* Ссылочный объект имеет только один экземпляр в памяти.
* Тип значения имеет столько экземпляров в памяти, сколько раз он передавался.
* Тип значения с Copy-on-Write имеет только один экземпляр в памяти.
Занимаемая память
-----------------
В большинстве случаев структуры полностью хранятся в Stack, а классы хранятся в Heap, и ссылка на объект хранится в Stack. Stack имеет ограниченный размер. Heap не имеет ограничений по размеру. Из чего следует вывод, что память в Stack нужно беречь. [Большая статья про память.](https://habr.com/ru/post/592385/)
```
MemoryLayout.size(ofValue: useClassWithoutProtocols) // Размер в Stack 8
class_getInstanceSize(UseClassWithoutProtocols.self) // Общий размер 48
MemoryLayout.size(ofValue: useClassWithProtocols) // Размер в Stack 8
class_getInstanceSize(UseClassWithProtocols.self) // Общий размер 104
MemoryLayout.size(ofValue: useStructWithoutProtocols) // Размер в Stack 32
MemoryLayout.size(ofValue: useStructWithProtocols) // Размер в Stack 88
```
Если беречь память Stack, то очевидно нужно использовать классы. Если брать общий размер, то оптимальным решением будет использование структур без использования протоколов. Но в таком случае страдает тестируемость, принципы [SOLID](https://en.wikipedia.org/wiki/SOLID) и конечно [Протокольно-ориентированное программирование](https://habr.com/ru/post/486902/). Так же не стоит забывать про копирование: размер занимаемой память структурой прямо пропорционален количеству присваиваний объекта.
Время доступа
-------------
В теории время доступа к значениям класса дольше, так как переход по ссылкам требует большего времени. В то время как структуры находятся здесь и сейчас.
Замер получения булевой переменной в разных конфигурациях:
```
func countTime(_ workItem: () -> Void) -> Double {
let start = CFAbsoluteTimeGetCurrent()
workItem()
return CFAbsoluteTimeGetCurrent() - start
}
// для примера
// повторить для разных конфигураций
countTime {
let _ = useClassWithoutProtocols.ref.bool
}
```
Я провел несколько тестов и получил следующие средние значения:
| | | |
| --- | --- | --- |
| | Время доступа к ссылочному типу | Время доступа к типу значения |
| useClassWithoutProtocols | 0,000009597 | 0,000007105 |
| useClassWithProtocols | 0,000009501 | 0,000008715 |
| useStructWithoutProtocols | 0,000008059 | 0,000008597 |
| useStructWithProtocols | 0,000007011 | 0,000007714 |
Значения примерно равнозначны. Однако стоит отметить, что использования структуры со значениями ссылочных типов, закрытых протоколами, незначительно экономит время доступа.
Выводы
------
| | | | | |
| --- | --- | --- | --- | --- |
| | Stack | Heap | Время | Принципы |
| useClassWithoutProtocols | + | - | - | - |
| useClassWithProtocols | + | - | | + |
| useStructWithoutProtocols | - | + | | \_ |
| useStructWithProtocols | - | + | + | + |
1. Использовать структуры с использованием протоколов плохо для Stack, но хорошо для скорости выполнения.
2. Использовать классы хорошо для Stack.
Так как важно следить за Stack и соблюдать принципы, а время доступа незначительно отличается, я бы советовал использовать классы и протоколы для построения архитектуры. | https://habr.com/ru/post/670790/ | null | ru | null |
# OnPropertyChanged со строгими именами
Меня дико бесит OnPropertyChanged. Он требует передачи ему строки с именем идентификатора… Мало того, что такой код не верифицируется компилятором, так еще и никакого Intellisence — тайпи весь идентификатор от начала до конца… А если опечатаешся — так проглотит и во время выполнения. Вобщем, нехорошая вещь. Но в MVVM без нее никуда, как и в WPF без MVVM.
Последняя проблема худо-бедно решалась вот таким костылем, содранным [отсюда](http://msdn.microsoft.com/en-us/magazine/dd419663.aspx), который вызывался из OnPropertyChanged:
> `[Conditional("DEBUG")]
>
> [DebuggerStepThrough]
>
> public void VerifyPropertyName(string propertyName)
>
> {
>
> // Verify that the property name matches a real,
>
> // public, instance property on this object.
>
> if (TypeDescriptor.GetProperties(this)[propertyName] == null)
>
> {
>
> string msg = "Invalid property name: " + propertyName;
>
>
>
> if (this.ThrowOnInvalidPropertyName)
>
> throw new Exception(msg);
>
> else
>
> Debug.Fail(msg);
>
> }
>
> }`
И вот сегодня я совершенно случайно нашел красивый способ избавится от него.
Решение оказалось красивым и одновременно простым до банальности: использовать Expression, вот так:
> `this.OnPropertyChanged(() => this.ShowOverrideButton);`
Для этого нужно только создать в базовом классе перегрузку:
> `protected void OnPropertyChanged(Expression> property)
>
> {
>
> PropertyChangedEventHandler handler = this.PropertyChanged;
>
> if (handler != null)
>
> {
>
> var expression = property.Body as MemberExpression;
>
> if (expression == null)
>
> {
>
> throw new NotSupportedException("Invalid expression passed. Only property member should be selected.");
>
> }
>
>
>
> handler(this, new PropertyChangedEventArgs(expression.Member.Name));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Готово. Можете забыть о строках в OnPropertyChange. Остаются еще нехорошие строки в XAML в Binding — но у меня совершенно нет идей как от них избавится. | https://habr.com/ru/post/103991/ | null | ru | null |
# Restate — или как превратить бревно Redux в дерево
История развития IT намного интереснее любой мыльной оперы, но пересказывать ее мы не будем. Скажем только, что были свидетили принципа «data-driven», адреналинщики с two-way-binding и беспредельщики без принципов и понятий.
> Бог создал людей сильными и слабыми. Сэмюэл Кольт сделал их равными.
>
> Примерно тоже самое сделали Flux и Redux.
Была только одна проблема — Redux по сути своей крайне примитивная хреновина, и чтобы с ним хоть как-то работать надо было добавить парочку middleware — thunk, saga, observable и так далее.
Но эта статья заходит с другой стороны, серьезно так спрашивая про композицию, и, в частности, про компонентную модель. Которой в редаксе — нет.
Для лучшего понимания проблемы — давайте начнем с азов, и сделаем TODO.
React вариант
-------------
Реакт все любят за компонентную модель, и вообще за то, что он очень «composable». Можно *взять почти любой компонент, обернуть в 10 других и он будет работать так, как тебе надо.*(запомните эту фразу)
```
// Создадим список TODO
const TODOs = [todo1, todo2, todo3];
// Передадим приложению как пропс
const Application =
// Определим TodoList, который прокинет пропсы конечному элементу
const TodoList = ({todos}) => (
{todos.map( todo =>
);
// Ну и сам TODO очень просто
const Todo = (props) => ......
```
Все хорошо, но встает вопрос о том что делать с событиями, как это все вообще контролировать
Простой Redux вариант
---------------------
Redux решает много проблем, и о них мы говорить сейчас не будем. Я надеюсь код ниже для всех совершенно понятен и очевиден.
```
// Создадим стор
const store = createStore({
todos: [todo1, todo2, todo3]
});
// Создадим приложение
const Application =
// Коннектим компонент к стору. Нам нужны все TODO
const ConnectedTodoList = connect(
state => ({todos: state.todos}),
{ onTodoClick }
)(TodoList)
// Далее все тоже самое
const TodoList = ({todos}) => (
{todos.map( todo => onTodoClick(todo.id)} />
);
....
```
Это пример плохого redux приложения, и именно так выглядит [оригинальный пример](https://github.com/reactjs/redux/tree/master/examples/todos/src) из репозитория redux.
Проблемы тут две:
— миксуем React и Redux
— при изменении любого Todo происходит перерендер всего — и списка Todo и каждого из Todo.
Более правильный Redux
----------------------
Правильный вариант от не правильного особо то и не отличается
```
// Коннектим компонент к стору. Нам нужны все TODO
const ConnectedTodoList = connect(
state => ({todos: getOnlyIds(state.todos)}), <----- изменение вот тут
{ onTodoClick }
)(TodoList)
const TodoList = ({todos}) => (
{todos.map( id => <----- вот тут
);
// Конектим Todo к стору
const ConnectedTodo = connect(
(state,props) => ({...state.todos[props.id])}), <----- и вот тут
{ onTodoClick: () => dispatch => dispatch(onTodoClick(props.id)) }
)(Todo)
....
```
Чем это лучше? TodoList не зависит от содержимого конкретного Todo, реагируя только на сам факт наличия. Ну а Todo — сам сходит за данными, и сам свой Id в onTodoClick добавит.
По сути — добавить «больше» редакса тут уже нельзя. Заодно React механизм прокидывания данных от родителей к детят более не используется. Как результат — никакая композиция более не возможна.
Какая композиция?
-----------------
Хороший пример «проблемы» — это [пример Tree-view](https://github.com/reactjs/redux/blob/master/examples/tree-view/), опять же из официального репозитория.
Технически — тот же самый TODO-list, только появляется «вложеность». «Вложености» там правда нет, потому что «стор» совершенно плоский, и любую, самую глубокую ноду можно адресовать по Id. И проблема не в этой структуре данных, а в том, что другую использовать банально не получается!
Все потому, что Node, встречая для отрисовки дочерних Node рендерит ConnectedNode, а в случае reduxа — все Connected компоненты равны, и конектятся непосредственно к стору.
И, если компоненты равны, они еще и должны совершить совершенно одинаковое действие — взять элемент массива с известным Id.
Другими словами — Компоненты работают независимо от своего положение в дереве, и совершенно нельзя *взять компонент, обернуть еще в 10, и заставить работать так как вам нужно* — он будет работать всегда одинаково. Предсказуемо — конечно же да. Только хотели ли мы это?
Банально — попробуйте переделать любой TODO список в список-списков, аля Trello — прийдется переписывать примерно все, и уж точно каждый connect.
И если проблема именно в полном игнирировании reduxом вложености компонентов — возможно именно это и требуется починить. В том смысле, что
Хватит это терпеть!
-------------------
Представим ситуацию, когда родительский компонент может подготовить данные для своего ребенка, так как он считает нужным. Представим ситуацию когда родитель может контролировать все действия, которые совершает его ребенок. И вспомним, что это примерно то, что redux старался «починить», и это никак-нельзя запилить обратно.
Вот только на самом деле это немного разные вещи. Проблема была в двунаправленности событий, которая порождала каскадные апдейты, которые было практически невозможно контролировать.
Плюс — 99% примеров продолжают использовать стандартный подход Reacta, который как раз и позволяет правдами или не правдами прокинуть некий секретный Id в ребенка, чтобы он потом смог прочитать данные из стора.
Просто это можно сделать немного более проще, и правильнее.
Redux-restate
-------------
Redux-restate ([github](https://github.com/thekashey/restate)) — миниатюрная (50 строк\*) библиотека, которая принимает один или более стор на вход, и совершает над ними некие операции и выдавает стор на выход.
> Сразу стоит уточнить — колличество сторов не меняется! restate это view в базе данных, или transformation в mobx, или линза, или mapStateToProps(только ToState). Это не «стор».
На самом деле restate это три отдельный пакета:
— redux-restate — нижний уровень, делай что хочешь
— react-redux-restate — обвязка вокруг реакта — получить стор из контекста, и положить обратно (узкий момент)
— react-redux-focus — упрощенный вариант restate. Для использования в 99% случаев.
Работает все просто:
— При «погружении»(создании стейта) можно програмно менять те данные, которые будут доступны для детей
— При «всплытии»(обработке событий) можно дополнять ивент нужными данными, чтобы правильно сформировать конечную команду.
«Погружение» — это просто однонаправленное действие, которое берет стейт на вход и давает стейт на выход. При этом очень важно мемоизировать промежуточный результат тем же recompose, так же как это делается в mapStateToProps.
```
const composeState = (state, props) => ({
...state,
part: recompose(operationOn(state))
});
```
«Всплытие» — однонаправленое действие, которое выполняется когда подчиненный компонет вызывает dispatch. Его смысл — добавить ту «специфичность», что была убрана в момент создания стейта.
```
const routeDispatch = (dispatch, event, props) => dispatch({...event, somethingFrom: props.data });
```
Пример «еще более правильного» redux:
```
// Коннектим компонент к стору. Нам нужны все TODO
const ConnectedTodoList = connect(
state => ({todos: getOnlyIds(state.todos)}),
{ onTodoClick }
)(TodoList)
const TodoList = ({todos}) => (
{todos.map( id => <----- изменение вот тут
);
// Конектим Todo к стору (reactReduxFocus - простой самый простой API для одного стора)
const RestatedTodo = reactReduxFocus(
(state, props) => ({todo: state.todos[props.id]}), // оставить в сторе _только_ todo
(dispatch, event, props) => dispatch({...event, id: props.id}); // добавить в ивент todoID
)(ConnectedTodo)
// Конектим Todo к стору
const ConnectedTodo = connect(
(state,props) => ({...state.todo}), <----- тут стало проще
{ onTodoClick } <---- тут стало проще
)(Todo)
....
```
Как сайд эффект получаем автоматический areStatesEqual — если вычисленный стейт shallowEqual старому значению — распространение изменения прекращается, что позволяет изолировать различные части приложения друг от друга.
Пример с деревом теперь можно написать «более» правильно
```
const RestatedNode = reactReduxFocus(
(state, props) => ({
...state,
// перекрываем node данными ребенка
node: state.node.children[props.nodeId]
}),
(dispatch, event, props) => dispatch({
...event,
// сохраняем в nodeId хлебные крошки пройденого пути
nodeId:[props.nodeId, ...event.nodeId]
});
)(ConnectedNode);
const ConnectedNode = connect(
state => {
...state,
children: state.node.children,
leafs: state.node.leafs
}........);
)(Node)
```
И все — вкладывай RestatedNode друг в друга — reactReduxFocus все аккуратно в начале разберет, а потом соберет обратно все хлебные крошки во диспача команды.
Остается вопрос как же вернуться в нормальному стору, когда «синтетический», «в котором ничего нет» больше не нужен. Ну и становиться нужен reactReduxRestate, который принимает больше одного стора на вход.
```
import {createProvider} from 'react-redux'
import reactReduxFocus from 'react-redux-focus'
import reactReduxRestate from 'react-redux-restate'
const Provider = createProvider('realStore');
// restate будет читать из 'realStore', а писать - в 'store', с которым работает connect
const FocusedComponent = reactReduxFocus(..., ..., {
storageKey: 'realStore'
})(SomeComponent);
const RestatedComponent = reactReduxRestate({
// будет произведен коннект с default стором ('store') и 'realStore'
// после чего можно будет читать данные и из реального стора, и из синтетического. Вдруг там что-то интересное есть?
realStore: 'realStore'
},..., ...)(AnotherComponent)
- подключен сразу к двум "сторам"
- подключен только к реальному, несмотря на то, что живет в синтетическом
```
В общем — исходных код всех трех компонент реально занимает пару десятков строк, но открывает столько вариантов для… композиии.
В принципе — именно это и требовалось.
А что, так можно было?
----------------------
Restate далеко не пионер в данном вопросе. Например [electron-redux](https://github.com/hardchor/electron-redux) занимается «почти» что этим же — соединяет два стора (main и render), один из который не настоящий, да еще и роутит dispatchи из одного в другой.
Технически того же эффекта можно добиться и с использованием restate, причем с меньшим колличеством костылей, но у restate совершенно нет IPC.
Или взять «систему опций» Яндекс.Карт. Она вообще не так чтобы очень известная (публична и документированна), но всякий кто хоть раз использовал API Яндекс Карт могли заметить как там красиво «каскадируются» опции — есть цвет полилинии задается на уровне карты, то опция называется geoObjectStrokeColor, а если на уровне геообьекта — strokeColor.
В общем работает «префексирование», и его можно встретить везде — самый лучший пример работы — в [примере настройки карты](https://tech.yandex.com/maps/jsbox/2.1/behaviors) задается «scrollZoomSpeed», сам же компонент управления будет читать из стора просто «speed».
Вот только в Яндекс.Картах это префексирование работает снизу вверх — префиксы добавляются от ребенка к родителю, пока не найдется совпадение, что почти исключает возможность купировать апдейты, те изменении какого либо значения нельзя узнать какой компонент каким хитрым образом это значение потом прочитает.
Restate — попытка скрестить именно систему Яндекс.Карт и redux. Починить и то и другое. Ну и занять долгие вечера каникул.
-> [github.com/thekashey/restate](https://github.com/thekashey/restate) | https://habr.com/ru/post/346116/ | null | ru | null |
# LUA в nginx: горячий кеш в памяти
Решил пополнить копилку статей на Хабре про такой замечательный ЯП, как lua, парой примеров его использования под капотом nginx. Разбил на два независимых поста, второй [тут](http://habrahabr.ru/post/215235/).
В этом посте nginx используется как «горячий кеш» неких постоянно пополняемых данных, запрашиваемых клиентами по интервалу с опциональным группированием (некий аналог BETWEEN и GROUP BY/AGGREGATE из SQL). Подгрузка данных в кеш осуществляется самим же lua+nginx из Redis. Исходные данные в Redis складываются ежесекундно, а клиенты хотят их от сих до сих (интервал в секундах, минутах, часах...) с агрегацией по N (1<=N<=3600) секунд, отсортированные по дате и в json формате.
С хорошим hitrate на имеющейся машине получается обеспечить 110-130к «хотелок» в секунду, правда с плохим — только 20-30к. Что, в общем-то, тоже приемлемо для нас на одной инстанции nginx.
Из некоего источника ежесекундно приходят данные, которые складываются в Redis ZSET. Важным моментом является привязка данных именно ко времени — выборка будет идти по временным интервалам. Пришел один клиент — «дай мне от сих до сих посекундно», пришел другой — «а мне вот этот интервальчик, но давай с часовой агрегацией», третьему понадобилась одна последняя секунда, четвертому за сутки с аггрегацией по 27 секунд, ну и т.д… Стучаться за данными непосредственно в Redis нереально. Заранее кешировать подготовленные данные весьма проблематично, т.к. требуемые интервалы и шаг агрегации в общем случае у каждого клиента/запроса свой и могут произвольно варьироваться. Сервер должен быть готов быстро ответить на любой разумный запрос.
Первоначально была идея выполнять агрегацию на стороне Redis, вызывая через EVAL redis-lua код из nginx-lua кода. Данная «технология We need to go deeper» не подошла из-за однопоточной природы самого Redis: по быстрому отдать «сырые данные» выходит значительно быстрее, чем сгруппировать и выпихнуть готовый результат.
Данные в Redis хранятся поэлементно уже в json формате вида:
```
ZADD ns:zs:key 1386701764 "{\"data100500\":\"hello habr\",\"dt\":\"10.12.2013 10:05:00\",\"smth\":\"else\"}"
```
Ключом является timestamp, в dt строковый эквивалент по версии «наполняльщика».
Соответственно, выборка диапазона:
```
ZREVRANGEBYSCORE ns:zs:data:sec 1386701764 1386700653 WITHSCORES
```
И на lua через resty Redis:
```
local redis = require 'redis'
local R, err = redis:new()
R:connect('12.34.56.78', 6379)
R:zrevrangebyscore('ns:zs:data:sec', to, from, 'WITHSCORES')
-- и т.п.
```
**Про пул коннектов в resty Redis**Важно, что Resty использует настраиваемый пул коннектов к Redis и R:connect() в общем случае не создает новое соединение. Возврат соединения после использования НЕ выполняется автоматически, его нужно выполнить вызовом R:set\_keepalive(), возвращающим соединение обратно в пул (после возврата использовать его без повторного R:connect() уже нельзя). Счетчик доставаний текущего коннекта из пула можно узнать через R:get\_reused\_times(). Если >0 — значит это уже ранее созданное и настроенное соединение. В таком случае не нужно повторно слать AUTH и т.п.
Собираем nginx ([lua-nginx-module](https://github.com/chaoslawful/lua-nginx-module) + [lua-resty-redis](https://github.com/agentzh/lua-resty-redis)), бегло настраиваем:
```
http {
lua_package_path '/path/to/lua/?.lua;;';
init_by_lua_file '/path/to/lua/init.lua';
lua_shared_dict ourmegacache 1024m;
server {
location = /data.js {
content_by_lua_file '/path/to/lua/get_data.lua';
}
}
}
```
**Про работу с shared dict**В конфиге указывается [shared dict](https://github.com/chaoslawful/lua-nginx-module#ngxshareddict) «ourmegacache», который будет доступен в lua как таблица (словарь, хеш). Данная таблица одна для всех worker процессов nginx и операции на ней атомарны для нас.
Доступ к таблице прост:
```
local cache = ngx.shared.ourmegacache
cache:get('foo')
cache:set('bar', 'spam', 3600)
-- и т.п. см. документацию
```
При исчерпании свободного места в памяти, начинается чистка по методу [LRU](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%BA%D1%8D%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#Least_Recently_Used_.28.D0.92.D1.8B.D1.82.D0.B5.D1.81.D0.BD.D0.B5.D0.BD.D0.B8.D0.B5_.D0.B4.D0.B0.D0.B2.D0.BD.D0.BE_.D0.BD.D0.B5.D0.B8.D1.81.D0.BF.D0.BE.D0.BB.D1.8C.D0.B7.D1.83.D0.B5.D0.BC.D1.8B.D1.85.29), что в нашем случае подходит. Кому не подходит — смотрите в сторону методов safe\_add, flush\_expired, и т.п. Так же стоит учитывать еще, вроде как, не решенный официально [баг в nginx](http://www.mail-archive.com/nginx-devel@nginx.org/msg00661.html), связанный с хранением больших элементов в данном shared dict.
Для разнообразия границы запрашиваемого интервала и шаг агрегации будем получать из GET параметров запроса **from**, **to** и **step**. С данным соглашением примерный формат запроса к сервису будет таким:
> /data.js?step=300&from=1386700653&to=1386701764
```
local args = ngx.req.get_uri_args()
local from = tonumber(args.from) or 0
...
```
Итак, у нас есть поэлементные json записи, хранящиеся в Redis, которые мы можем оттуда получать. Как их лучше кешировать и отдавать клиентам?
* Можно хранить посекундные записи в таблице по отдельности. Однако, как показала практика, выполнение уже нескольких десятков запросов к таблице крайне негативно сказывается на производительности. А если придет запрос на сутки, то ответа с небольшим таймаутом можно и не дождаться;
* Записи можно хранить блоками, объединяя через некий общий разделитель или сериализуя их хоть в тот же json. А при запросе нужно разбербанивать по разделителю или десериализовывать. Так себе вариант;
* Хранить данные иерархически, с частичными повторами на разных уровнях аггрегации. Используются блоки кеша разного размера: 1 секунда (одиночная запись), 10 секунд, 1 минута, 10 минут, час. В каждом блоке содержатся данные всех его секунд. Самое важное, что содержимое блока никак не меняется и не отдается кусками: или целиком как есть или никак.
Выбран последний вариант, потребляющий больше памяти, но значительно уменьшающий число обращений к таблице. Используются блоки кеша разного размера: 1 секунда (одиночная запись), 10 секунд, 1 минута, 10 минут, час. В каждом блоке содержатся данные всех его секунд. Каждый блок выровнен на границу своего интервала, например первый элемент 10 секундного интервала всегда имеет timestamp, имеющий десятичный остаток 9 (сортировка по убыванию, как хотят клиенты), а часовой блок содержит элементы 59:59, 59:58,… 00:00. При объединении элементов, они сразу склеиваются с разделителем — запятой, что позволяет отдавать данные блоки клиенту одним действием: '[', block, ']', а также быстро объединять их в более крупные куски.
Для покрытия запрошенного интервала выполняется разбиение на максимально возможные блоки с достройкой по краям более мелкими блоками. Т.к. у нас есть единичные блоки, то всегда возможно полное покрытие требуемого интервала. Для запроса интервала 02:29:58… 03:11:02 получаем раскладку по кешам:
```
1сек - 03:11:02
1сек - 03:11:01
1сек - 03:11:00
1мин - 03:10:59 .. 03:10:00
10мин - 03:09:59 .. 03:00:00
30мин - 02:59:59 .. 02:30:00
1сек - 02:29:59
1сек - 02:29:58
```
*Это лишь пример. Реальные вычисления выполняют на timestamp'ах.*
Выходит, что нужны 8 запросов к локальному кешу. Или к Redis, если локально их уже/еще нет. А чтобы не ломиться за одинаковыми данными из разных worker'ов/connect'ов, можно использовать атомарность операций с shared dict для реализации блокировок (где key — строковый ключ кеша, содержащий в себе сведения о интервале и шаге агрегации):
```
local chunk
local lock_ttl = 0.5 -- пытаемся получить блокировку не дольше, чем полсекунды
local key_lock = key .. ':lock'
local try_until = ngx.now() + lock_ttl
local locked
while true do
locked = cache:add(key_lock, 1, lock_ttl)
chunk = cache:get(key)
if locked or chunk or (try_until < ngx.now()) then
break
end
ngx.sleep(0.01) -- ожидание, не блокирующее nginx evloop
end
if locked then
-- удалось получить блокировку. делаем, что собирались
elseif chunk then
-- лок получить не удалось, но в кеш положили нужные нам данные
end
if locked then
cache:delete(key_lock)
end
```
Имея нужную раскладку по кешам, возможность выбора нужного диапазона из Redis, и логику агрегации (тут очень специфично, не привожу примера), получаем отличный кеширующий сервер, который, после прогрева, стучится в Redis только раз в секунду за новым элементом + за старыми, если они еще не выбирались или были выброшены по LRU. И не забываем про ограниченный пул коннектов в Redis.
В нашем случае прогрев выглядит как кратковременный скачок входящего трафика порядка 100-110Мб/сек на несколько секунд. По cpu на машине с nginx прогрева вообще почти не заметно.
*Изображение в шапке взято [отсюда](http://blog.cloudflare.com/pushing-nginx-to-its-limit-with-lua).* | https://habr.com/ru/post/215237/ | null | ru | null |
# «Мечта лентяя» или скриптовый движок на самом себе
У разработчиков прикладного ПО очень часто возникает потребность встроить в свой продукт некий скриптовый язык, который бы решал часть задач, не описанных детально на момент проектирования системы. Действительно удобно: и возможность расширения функциональности есть, и трудоёмкость создания такого решения, на первый взгляд, невелика.
Эту давнюю мечту можно было бы назвать «мечтой лентяя», если бы имеющиеся общедоступные встраиваемые скриптовые средства были бы просты. Готовые средства существовали давно, например на платформе Windows, ещё в прошлом веке можно было использовать интерфейсы VBScript и Jscript через COM-интерфейс IActiveScriptSite. В настоящее время существует большое количество и других решений, например на базе Lua, но все они имеют одну неприятную особенность, сильно ограничивающую желание их применять.
Скрипты прекрасно работают и сами по себе, на них можно выполнять и логику, и арифметику, но пользы от них ровным счётом никакой, если сложно или нет возможности:
• добавлять функции и объекты для доступа к объектам разрабатываемой системы,
• проводить синтаксический контроль исходного скрипта и генерировать сообщения о синтаксических ошибках,
• выполнять скрипт в пошаговом режиме, подобно отладчику, с нотификацией точки исполнения и статусом.
И ещё, хотелось бы, чтобы делалось всё это просто и интуитивно понятно и не приходилось бы проводить бессонные ночи за чтением многочисленной документации по новому API. Увы, это удаётся далеко не всегда и весьма нечасто.
Прикладное ПО сейчас очень часто пишется на C#, и хотелось бы иметь что-то знакомое, но гибкое, и позволяющее писать скрипты. Такое решение есть, и оно заслуживает пристального внимания. Это пространство имён System.CodeDom.Compiler с его классом CSharpCodeProvider. Всё это появилось ещё в .NET 4.0, но по какой-то причине в большинстве публикаций по C# не затрагивался вопрос написания скриптов на C#, используя сам же язык C# в качестве базового. А это очень и очень удобно для написания и дальнейшего сопровождения продукта.
В этом случае самый главный и интересный метод — CompileAssemblyFromSource(), который выполняет компиляцию, генерирует сообщения об ошибках, и мы уже запросто можем написать «Hello world!»
```
using System;
using System.IO;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
// готовим текст скрипта
StringBuilder sb = new StringBuilder();
sb.AppendLine("using System;");
sb.AppendLine("namespace ConsoleApplication1");
sb.AppendLine("{");
sb.AppendLine(" public class MyScripter");
sb.AppendLine(" {");
sb.AppendLine(" public void Hello()");
sb.AppendLine(" {");
sb.AppendLine(" Console.WriteLine(\"Hello world!\");");
sb.AppendLine(" }");
sb.AppendLine(" }");
sb.AppendLine("}");
// компилируем
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerResults compileResults = codeProvider.CompileAssemblyFromSource(
new CompilerParameters(), new string[] { sb.ToString() });
// выводим ошибки, если они есть
foreach (CompilerError err in compileResults.Errors)
Console.WriteLine("Error({0:1}): {2} {3}", err.Line, err.Column,
err.ErrorNumber, err.ErrorText);
if (compileResults.Errors.HasErrors) return;
// загружаем получившуюся dll в память
byte[] dllBytes = File.ReadAllBytes(compileResults.PathToAssembly);
Assembly asmDll = Assembly.Load(dllBytes, null);
Type objType = asmDll.GetType("ConsoleApplication1.MyScripter");
// создаём объект класса из скрипта
object oClassInst = Activator.CreateInstance(objType);
// получаем точка входа и выполняем её
MethodInfo entry = objType.GetMethod("Hello", new Type[] {});
entry.Invoke(oClassInst, null);
}
}
}
```
Запускаем на исполнение:
Итак, в простейшем виде скрипт на C# успешно работает. Простым изменением текста скрипта мы можем влиять на его работу. Собственно, осталось лишь передать в скрипт в качестве примера какой-либо объект из основной программы.
В качестве такого объекта вполне подойдёт объект типа string:
```
using System;
using System.IO;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
string sMyStr = "Before Script.";
// готовим текст скрипта
StringBuilder sb = new StringBuilder();
sb.AppendLine("using System;");
sb.AppendLine("namespace ConsoleApplication1");
sb.AppendLine("{");
sb.AppendLine(" public class MyScripter");
sb.AppendLine(" {");
sb.AppendLine(" public void Hello(ref string s)");
sb.AppendLine(" {");
sb.AppendLine(" Console.WriteLine(\"Hello world!\");");
sb.AppendLine(" s=\"After Script.\";");
sb.AppendLine(" }");
sb.AppendLine(" }");
sb.AppendLine("}");
// компилируем
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerResults compileResults = codeProvider.CompileAssemblyFromSource(
new CompilerParameters(), new string[] { sb.ToString() });
// выводим ошибки, если они есть
foreach (CompilerError err in compileResults.Errors)
Console.WriteLine("Error({0:1}): {2} {3}", err.Line, err.Column,
err.ErrorNumber, err.ErrorText);
if (compileResults.Errors.HasErrors) return;
// загружаем получившуюся dll в память
byte[] dllBytes = File.ReadAllBytes(compileResults.PathToAssembly);
Assembly asmDll = Assembly.Load(dllBytes, null);
Type objType = asmDll.GetType("ConsoleApplication1.MyScripter");
// создаём объект класса из скрипта
object oClassInst = Activator.CreateInstance(objType);
// получаем точка входа и готовим параметры
MethodInfo entry = objType.GetMethod("Hello",
new Type[] { typeof(string).MakeByRefType() });
Object[] param = new Object[] { sMyStr };
Console.WriteLine(param[0]); // до выполнения скрипта
entry.Invoke(oClassInst, param); // вызов метода
Console.WriteLine(param[0]); // после выполнения скрипта
}
}
}
```
Запускаем на исполнение:
Видно, что теперь мы можем передавать и возвращать значения из кода скрипта. Если в качестве параметра передать не ссылку на строку, а какой-то внутренний объект информационной системы, то мы вполне можем воздействовать на систему из скрипта.
У данного механизма есть режим исполнения в режиме отладчика, для этого нужно подключать .pdb файл, есть и много других интересных возможностей.
Недостатком подхода можно считать только то, что при компиляции создаётcя dll во временном каталоге ОС.
Путь разрешения этого недостатка ведёт нас в сторону использования пространства System.Reflection.Emit, но это достаточно объёмный материал, подходящий для отдельной статьи. Это сложно, т. к. в данном случае компилятор и генерацию придется писать самостоятельно. Но зато какие возможности по придумыванию своего собственного синтаксиса! Да и назвать новый язык программирования можно в честь себя или любимой кошки.
Удачи!
*Аркадий Пчелинцев, архитектор проектов* | https://habr.com/ru/post/327096/ | null | ru | null |
# Дайджест интересных новостей и материалов из мира PHP за последние две недели №20 (18.06.2013 — 30.06.2013)
Предлагаем вашему вниманию очередную подборку с ссылками на новости и материалы.
Приятного чтения!
### PHP 5.5
* [Состоялся долгожданный релиз PHP 5.5!](http://php.net/archive/2013.php#id2013-06-20-1) — Небольшой обзор новых возможностей есть в [хабрапосте](http://habrahabr.ru/post/184142/) , а также [тут](http://www.opennet.ru/opennews/art.shtml?num=37239)  и [тут](http://evertpot.com/php-55-released/).
Согласно принятому ранее [решению](https://wiki.php.net/rfc/php53eol), ветка 5.3.x закрывается. Последним регулярным релизом станет 5.3.27. В течение года при необходимости будут выпускаться исправления проблем с безопасностью, после чего поддержка 5.3 будет приостановлена окончательно.
* [У php.net новый дизайн (в бете). Краткая новость и опрос](http://habrahabr.ru/post/184514/)  — Если у вас есть конкретные пожелания по новому оформлению [сайта](http://php.net), то смело делитесь ими [тут](https://phpdotnet.uservoice.com/forums/211823-php-net-beta-site)
* [Новые возможности в PHP 5.5](https://gist.github.com/nikic/5213689) — Никита Попов собрал все самые значимые по его мнению нововведения в удобной таблице с обозначением автора и ссылками на соответствующие RFC.
* [API хэширования паролей](http://habrahabr.ru/post/184220/)  — Об этом уже [писал](http://blog.ircmaxell.com/2012/11/designing-api-simplified-password.html) не раз даже сам автор API, но за хороший хабрапост на русском — спасибо!
* [Как быть с 5.4 и 5.3?](http://schlueters.de/blog/archives/173-PHP-5.5-is-out,-whats-up-with-5.4-and-5.3.html) — Релиз-менеджер PHP 5.3 рекомендует счастливым и не желающим что-либо менять пользователям версии 5.3 продолжать пользоваться ею лишь вовремя устанавливая обновления этой ветки. Пользователям же PHP 5.4 автор рекомендует обновиться до 5.5.
* [Новая константа CLASS](http://thephp.cc/viewpoints/blog/2013/06/php-5-5-new-class-constant) — В посте пример того, где действительно необходимо использование новой константы. Кроме того несколько примеров «из жизни» есть в [оригинальном RFC](https://wiki.php.net/rfc/class_name_scalars).
* [Кэширование байт-кода из коробки](http://thephp.cc/viewpoints/blog/2013/06/php-5-5-out-of-the-box-bytecode-cache) — Небольшой обзор прошлого и настоящего кэширования байт-кода в PHP.
* [Практическая польза генераторов из PHP 5.5](http://blakegardner.co/2013/06/24/practical-usage-of-php-5-5-generators-yield-keyword/) — Автор реализовал аналог функции `range()` с использованием генератора, и демонстрирует насколько это сократило потребление памяти.
### Новости и релизы
* [Вышел WordPress 3.5.2](http://wordpress.org/news/2013/06/wordpress-3-5-2/) — В релиз включены важные исправления безопасности, всем пользователям настоятельно рекомендуется обновиться немедленно.
* [Вышел Codeception 1.6.3](http://codeception.com/06-23-2013/codeception-1-6-3) — Релиз отличного инструмента тестирования. Хоть и минорный, но содержит несколько приятных нововведений, таких, например, как модуль для Yii 2 и Facebook-модуль.
* [Релиз PHP QB 1.3](http://www.opennet.ru/opennews/art.shtml?num=37244)  — Обновилась альтернативная виртуальная машина для PHP, которая благодаря статической типизации позволяет для ряда специфических задач получить значительный прирост в производительности.
* [Быстрый поиск по дайджестам](http://pronskiy.github.io/php-digest/)  — Небольшой инструмент, который позволяет искать сразу по всем PHP-дайджестам, публиковавшимся на Хабре. Делал для себя, но думаю будет полезен многим, например, если нужно быстро найти все статьи по интересующей теме.
### PHP
* [PHP Internals Book: Hashtables](http://www.phpinternalsbook.com/hashtables.html) — Новая глава книги посвящена хэш-таблице — структуре данных, которая повсеместно используется в реализации интерпретатора.
* RFC: [Поддержка анонимных catch-блоков](https://wiki.php.net/rfc/anonymous_catch), [Structural Type Hinting](https://wiki.php.net/rfc/protocol_type_hinting) — Не смотря на то, что новая версия PHP только вышла, уже появляются предложения для грядущих версий. Пока не революционные, но посмотрим, что будет дальше.
### Материалы для обучения
* [Сделать Phalcon еще быстрее — разве это возможно? Да!](http://blog.phalconphp.com/post/53713853781/making-phalcon-even-faster-is-that-possible-yes) — Благодаря применению техники [оптимизации основанной на данных профилирования](http://ru.wikipedia.org/wiki/Profile-guided_optimization) Phalcon действительно можно сделать еще быстрее.
* [Упаковываем Sуmfony-приложение в один файл — продолжение](http://fabien.potencier.org/article/70/packing-a-symfony-full-stack-framework-application-in-one-file-bootstrapping) — Если в [предыдущем посте](http://fabien.potencier.org/article/69/packing-a-symfony-full-stack-framework-application-in-one-file-introduction) Fabien писал о причинах и мотивах побудивших его упаковать приложение в один файл, то в этот раз он приступил к реализации задуманного. Но стоит заметить, что упаковано в один файл будет только приложение, а код фреймворка и инструментов останется в папке vendor.
* [Моё маленькое расследование или История одного взлома](http://habrahabr.ru/post/184150/)  — Отличный хабрапост, в котором автор делится информацией об исследованном инциденте взлома.
* [Разбираемся с потоками данных в PHP](http://phpmaster.com/%EF%BB%BFunderstanding-streams-in-php/) — Многие разработчики игнорируют [потоки данных](http://www.php.net/manual/ru/intro.stream.php), однако этот мощный инструмент часто может очень облегчить жизнь. Пост будет хорошей отправной точкой для тех, кто решил разобраться с потоками. Также имеются хорошие [слайды по потокам](http://www.slideshare.net/auroraeosrose/writing-and-using-php-streams-and-sockets-zendcon-2011).
* [Уведомления на рабочем столе Ubuntu для PHPUnit-тестов](http://odino.org/desktop-notifications-for-phpunit-tests-on-ubuntu/) — Автор предлагает не смотреть в консоль ожидая окончания тестов, а настроить уведомления на рабочем столе которые бы сигнализировали о статусе процесса тестирования. Приведено решение для Ubuntu, но используя [Growl](http://growl.info/) можно сделать тоже самое для OS X и Windows.
* [Простой список задач на Backbone.js и Slim](http://www.codeforest.net/creating-simple-tasks-app-with-backbone-js-and-slim-micro-framework-part-1), [2](http://www.codeforest.net/creating-simple-tasks-app-with-backbone-js-and-slim-micro-framework-part-2) — В двух частях вкратце показано использование популярной JS-библиотеки в связке с микрофреймворком Slim и библиотекой [NotORM](http://www.notorm.com/).
* [Видео туториалы по PhpStorm](http://www.jetbrains.com/phpstorm/documentation/phpstorm-video-tutorials.jsp) — Почти 2 часа скринкастов, в которых раскрыты как базовые возможности IDE, так и некоторые продвинутые варианты использования.
Кроме того рекомендую ознакомиться с полезным [хабрапостом](http://habrahabr.ru/post/184264/) , в котором описано как включить автодополнение SQL-кода прямо в редакторе.
* [Погружаемся в Symfony 2](http://net.tutsplus.com/tutorials/php/diving-into-symfony-2-2/) — Небольшой пост, который станет хорошим началом для желающих освоить фреймворк.
* [Обновление PHP сломало мой импорт данных](http://spudley.com/blog/php-upgrade-broke-my-data-importer) — Автор пишет о проблеме, с которой столкнулся при обновлении с PHP 5.3 до 5.4 — нельзя так просто взять и использовать `LOAD DATA INFILE`, но автор нашел обходное решение.
* [От процедурного к объектно-ориентированному PHP](http://net.tutsplus.com/tutorials/php/from-procedural-to-object-oriented-php/) — Большой туториал, в котором на примере простого клиента Google API обоснован и пошагово продемонстрирован переход от процедурного к объектно-оринтированному подходу.
* [Интервью с Phil Sturgeon](http://7php.com/php-interview-phil-sturgeon/) — О своем опыте как разработчика рассказывает автор PyroCMS, участник PHP-Fig, ранее контрибьютор в CodeIgniter и FuelPHP, а ныне в Laravel.
* [Основы использования Arduino из PHP](http://www.a-basketful-of-papayas.net/2013/06/basics-of-using-arduino-from-php.html) — Автор пишет о протоколе [Firmata](http://www.firmata.org/wiki/Main_Page) и об использовании PHP-библиотек, реализующих ассинхронный ввод/вывод, например [React](http://reactphp.org/). Автор реализовал собственную подобную библиотеку — Carica Io и приводит пример ее использования.
* [Google App Engine и мольба о Phalcon](http://phpmaster.com/google-app-engine-and-a-plea-for-phalcon/) — Пост содержит небольшой обзор GAE, немного информации и рекомендаций по переходу от обычного хостинга на GAE и рассуждения на тему недоступности расширений. «Phalcon больше PHP6 чем сам PHP6» — пишет автор и просит проголосовать поставив звездочку за соответствующий [запрос о новой возможности для GAE](http://phpmaster.com/google-app-engine-and-a-plea-for-phalcon/).
* [Тестирование клиентов для Memcached и Redis](http://alekseykorzun.com/post/53283070010/benchmarking-memcached-and-redis-clients) — [Результаты тестов](https://docs.google.com/spreadsheet/pub?key=0AhePUdRMAppIdHIzd2d3YU9oVE55MnctaGc3NTVvcVE&single=true&gid=0&output=html) показывают, что выбор правильного клиента может оказаться не менее важен, чем выбор хранилища.
* [Структуры данных для PHP-разработчиков](http://phpmaster.com/php-data-structures-1/) — В первом посте из серии речь идет о стэке и очереди. Базовые сведения, пример реализации соответствующих объектов на PHP и немного о встроенной реализации из SPL. Пост будет полезен молодым разработчикам и тем, кто только начинает.
* [Использование ZFTool](http://www.maltblue.com/tutorial/zftool-for-basic-project-management) — Туториал по использованию [инструмента командной строки для ZF2](http://habrahabr.ru/post/166385/) , который позволяет автоматизировать ряд базовых операций.
* [Единое расположение ресурсов в PHP](http://webmozarts.com/2013/06/19/the-power-of-uniform-resource-location-in-php/) — Автор описал в посте преимущества указания расположения ресурсов в едином формате и сделал [предложение](https://github.com/bschussek/fig-standards/blob/path-matching-v1/proposed/resource-location.md) в PHP-FIG для утверждения в качестве стандарта. Ресурсом в данном случае может быть файл шаблона, конфигурационный файл, изображение и т.п.
* [Расширяем Symfony 2 Forms](http://habrahabr.ru/post/184484/)  — Хабрапост об использовании Type Extensions.
* [Ускорьте ваше PHP-приложение с помощью OpCache](http://fideloper.com/install-zend-opcache) — Если хотите использовать OpCache но обновляться до 5.5 пока не желаете, то для вас эта небольшая инструкция по установке и настройке расширения.
* [Обратная совместимость — для неудачников](http://blog.ircmaxell.com/2013/06/backwards-compatibility-is-for-suckers.html) — Anthony Ferrara, core-разработчиков PHP считает, что если одной из целей вашего проекта декларируется обратная совместимость, то вы — неудачник. Он также призывает больше думать о прямой совместимости, то есть стараться предусмотреть возможные изменения. Доступен [хабраперевод](http://habrahabr.ru/post/185164/)  поста.
* [Как использовать Propel в Laravel 4](http://picqer.com/blog/propel-with-laravel) — Небольшая заметка об использовании ORM-библиотеки [Propel](http://propelorm.org/) вместо встроенной во фреймворк Eloquent ORM.
* [Операторы, работающие с массивами](http://phpmaster.com/array-operators-in-php-interesting-but-less-spoken/) — Описание и примеры работы операторов с массивами в PHP.
* [Проблема инициализации объектов в ООП приложениях на PHP. Поиск решения при помощи шаблонов Registry, Factory Method, Service Locator и Dependency Injection](http://habrahabr.ru/post/183658/)  — Хороший хабрапост, в котором автор простым языком и на простых примерах разъясняет суть часто используемых шаблонов проектирования.
* [Обзор PuPHPet](http://whateverthing.com/blog/2013/06/19/puphpet-by-the-bbq/) — О сервисе PuPHPet, который позволяет быстро и очень просто виртуализировать вашу рабочую среду, уже не раз было написано в дайджесте. По ссылке пост с небольшим обзором. Также можно ближе познакомиться с Vagrant и Puppet [тут](https://jtreminio.com/2013/06/make_vagrant_up_yours/), и глянуть хорошие слайды по Vagrant [тут](https://speakerdeck.com/danielcsgomes/boost-your-dev-environment-with-vagrant).
* [Http запросы — мы все это делаем неправильно](http://habrahabr.ru/post/184302/)  — Хороший хабрапост, в котором автор указывает на типичную ошибку создателей библиотек — они игнорируют возможность установить постоянное HTTP-соединение.
### Материалы c прошедших конференций
* [Lone Star PHP 2013](https://joind.in/event/view/1350/slides#event-tabs) — Слайды 23 докладов с прошедшей в Далласе [конференции](http://lonestarphp.com/), полностью посвященной PHP.
* [Внедрение зависимости и DI-контейнеры](http://gonzalo123.com/2013/06/24/talk-about-dependency-injection-and-dependency-injection-containers-at-the-desymfony-2013-conference/) — Хорошие слайды доклада с прошедшей в Испании конференции [deSymfony 2013](http://desymfony.com/). Слайды остальных докладов доступны [тут](https://joind.in/event/view/1252/slides#event-tabs), но к сожалению почти все из них на испанском.
* [Обзор Symfony 2](http://blog.nerdery.com/2013/06/symfony2-tech-talk/) — Видеозапись доклада о внутренностях фреймворка и принципах положенных в его основу.
* [Фреймворк — это не архитектура](http://thephp.cc/viewpoints/blog/2013/06/a-framework-is-no-architecture) — Видеозапись доклада, в котором рассказано почему ваш любимый фреймворк не предоставляет архитектуры приложения и какие это имеет последствия.
* [Devconf 2013](http://devconf.ru/programm/) — На сайте конференции стали доступны ссылки на слайды докладов, в том числе и по PHP.
* [PHP Object Injection Revisited](http://raz0r.name/talks/confidence-2013-php-object-injection-revisited/) — Отличная презентация по безопасности десериализации данных в PHP с прошедшей не так давно в Кракове конференции [CONFidence](http://2013.confidence.org.pl/).
[Ссылка](http://habrahabr.ru/company/zfort/blog/183642/) на предыдущий выпуск. | https://habr.com/ru/post/185142/ | null | ru | null |
# Полезные идиомы многопоточности С++
### Введение
Данная статья является продолжением цикла статей: [Использование паттерна синглтон [1]](http://habrahabr.ru/post/116577/), [Синглтон и время жизни объекта [2]](http://habrahabr.ru/post/118368/), [Обращение зависимостей и порождающие шаблоны проектирования [3]](http://habrahabr.ru/post/118550/), [Реализация синглтона в многопоточном приложении [4]](http://habrahabr.ru/post/150276/). Сейчас я хотел бы поговорить о многопоточности. Эта тема настолько объемна и многогранна, что охватить ее всю не представляется возможным. Здесь я заострю внимание на некоторых практичных вещах, которые позволят вообще не думать о многопоточности, ну или думать о ней в крайне минимальном объеме. Если говорить точнее, то думать о ней только на этапе проектирования, но не реализации. Т.е. будут рассмотрены вопросы о том, как сделать так, чтобы автоматически вызывались правильные конструкции без головной боли. Такой подход, в свою очередь, позволяет значительно уменьшить проблемы, вызванные состояниями гонок (race condition, см. [Состояние гонки [5]](http://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D0%BD%D0%BA%D0%B8)) и взаимными блокировками (deadlock, см. [Взаимная блокировка [6]](http://ru.wikipedia.org/wiki/%D0%92%D0%B7%D0%B0%D0%B8%D0%BC%D0%BD%D0%B0%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)). Этот факт уже сам по себе представляет немалую ценность. Также будет рассмотрен подход, который позволяет иметь доступ к объекту из нескольких потоков одновременно без использования каких-либо блокировок и атомарных операций!
Большинство статей ограничиваются лишь определенным набором примитивов, которыми, хотя и удобно пользоваться, но не решают общих проблем, возникающих в многопоточной среде. Ниже приведен список, который обычно используется в такого рода подходах. При этом я буду считать, что читатель уже знаком с такими подходами, поэтому я не буду заострять внимание на этом.
Сущности для использования:
| |
| --- |
| Описание интерфейса мьютекса:
```
struct Mutex
{
void lock();
void unlock();
private:
// OS specific
...
};
```
|
| RAII примитив (exception-safe):
```
struct Lock
{
Lock(Mutex& mutex_) : mutex(mutex_) { mutex.lock(); }
~Lock() { mutex.unlock(); }
private:
Mutex& mutex;
};
```
|
| Класс для издевательств в качестве простого примера:
```
struct A
{
int data;
mutable Mutex m;
};
```
|
Примеры использования:
| |
| --- |
| Пример 1. Примитивный подход: C-style
```
A a;
a.m.lock();
a.data = 10;
a.m.unlock();
```
|
| Пример 2. Продвинутый подход: RAII-style
```
A a;
{
Lock lock(a.m);
a.data = 10;
}
```
|
| Пример 3. Практически идеал: инкапсуляция локов
```
struct B
{
void setData(int data_)
{
Lock lock(m);
data = data_;
}
int getData() const
{
Lock lock(m);
return data;
}
private:
mutable Mutex m;
int data;
};
B b;
b.setData(10);
int x = b.getData();
```
|
Здесь стоит отметить, что последний вариант редко встретишь в статьях про многопоточность, что является очень печальным фактом: [Многопоточность, общие данные и мьютексы [9]](http://habrahabr.ru/blogs/cpp/72929/), [Кросс-платформенные многопоточные приложения [10]](http://habrahabr.ru/post/141744/), [Потоки, блокировки и условные переменные в C++11 (Часть 2) [11]](http://habrahabr.ru/post/182626/). В этой статье будут рассмотрены интересные вопросы, которые помогут существенно упростить работу с многопоточными примитивами (см. [Потоки, блокировки и условные переменные в C++11 (Часть 1) [12]](http://habrahabr.ru/post/182610/), [Два простых правила для предотвращения взаимных блокировок на мьютексах [13]](http://habrahabr.ru/company/nordavind/blog/176541/)). В чем-то данная статья будет являться развитием идей, взятых из [Enforcing Correct Mutex Usage with Synchronized Values [14]](http://www.drdobbs.com/cpp/enforcing-correct-mutex-usage-with-synch/225200269). Однако приведенные ниже идеи и способы реализации были разработаны независимо от приведенной статьи.
### Инвариант
Начнем рассмотрение многопоточных вопросов, как это ни странно, с проверки инварианта объекта. Тем не менее, разработанный механизм для инварианта будет использоваться в дальнейшем.
Для тех, кто не знаком с понятием “инвариант”, посвящен этот абзац. Остальные могут его смело пропустить и переходить сразу к реализации. Итак, в ООП мы работаем, как это ни странно, с объектами. Каждый объект имеет свое собственное состояние, которое при вызове неконстантных функций его изменяет. Так вот, как правило, для каждого класса существует некий инвариант, который должен выполняться при каждом изменении состояния. Например, если объект представляет собой счетчик элементов, то очевидно, что для любого момента времени выполнения программы величина этого счетчика не должна быть отрицательной, т.е. в данном случае инвариант — это неотрицательное значение счетчика. Таким образом, сохранение инварианта дает некоторую гарантию того, что состояние объекта консистентно.
Представим, что у нашего класса есть метод `isValid`, который возвращает `true` в случае сохранения инварианта, и `false` — когда инвариант нарушен. Рассмотрим следующий “неотрицательный” счетчик:
```
struct Counter
{
Counter() : count(0) {}
bool isValid() const
{
return count >= 0;
}
int get() const
{
return count;
}
void set(int newCount)
{
count = newCount;
}
void inc()
{
++ count;
}
void dec()
{
-- count;
}
private:
int count;
};
```
Использование:
```
Counter c;
c.set(5);
assert(c.isValid()); // вернет true
c.set(-3);
assert(c.isValid()); // вернет false и сработает assert
```
Теперь хочется как-то автоматизировать проверку инварианта, чтобы не звать после каждого изменения значения метод `isValid`. Очевидный способ это сделать — включить этот вызов в метод `set`. Однако в случае присутствия большого количества неконстантных методов класса необходимо внутрь каждого такого метода вставить эту проверку. А хочется добиться автоматизма, чтобы писать меньше, а получать больше. Итак, приступим.
Здесь мы будем использовать инструментарий, разработанный в предыдущих циклах статей: [Использование паттерна синглтон [1]](http://habrahabr.ru/post/116577/), [Синглтон и время жизни объекта [2]](http://habrahabr.ru/post/118368/), [Обращение зависимостей и порождающие шаблоны проектирования [3]](http://habrahabr.ru/post/118550/), [Реализация синглтона в многопоточном приложении [4]](http://habrahabr.ru/post/150276/). Ниже приведу для справки реализацию, которая подвергнется припарированию:
**An.hpp**
```
#ifndef AN_HPP
#define AN_HPP
#include
#include
#include
// декларативные определения, см. [1]
#define PROTO\_IFACE(D\_iface, D\_an) \
template<> void anFill(An& D\_an)
#define DECLARE\_IMPL(D\_iface) \
PROTO\_IFACE(D\_iface, a);
#define BIND\_TO\_IMPL(D\_iface, D\_impl) \
PROTO\_IFACE(D\_iface, a) { a.create(); }
#define BIND\_TO\_SELF(D\_impl) \
BIND\_TO\_IMPL(D\_impl, D\_impl)
// Основной класс, реализующий подход DIP - dependency inversion principle
template
struct An
{
template
friend struct An;
An() {}
template
explicit An(const An& a) : data(a.data) {}
template
explicit An(An&& a) : data(std::move(a.data)) {}
T\* operator->() { return get0(); }
const T\* operator->() const { return get0(); }
bool isEmpty() const { return !data; }
void clear() { data.reset(); }
void init() { if (!data) reinit(); }
void reinit() { anFill(\*this); }
T& create() { return create(); }
template
U& create() { U\* u = new U; data.reset(u); return \*u; }
private:
// извлекает объект
// при первом доступе происходит его заполнение
// с использованием внешней функции anFill,
// которая должна быть переопределена для
// каждого конкретного типа T
T\* get0() const
{
// ленивая инициализации при первом доступе к объекту
const\_cast(this)->init();
return data.get();
}
std::shared\_ptr data;
};
// заливка экземпляра, см. [1]
// по умолчанию бросается исключение
// необходимо переопределять, используя макросы выше
// заливать можно как новые экземпляры,
// так и синглтоны. см. [3]
template
void anFill(An& a)
{
throw std::runtime\_error(std::string("Cannot find implementation for interface: ")
+ typeid(T).name());
}
#endif
```
Для того, чтобы иметь возможность проверять консистентность, модифицируем доступ к объекту (приватный метод `get0`) следующим образом:
```
template
struct An
{
// ...
T\* get0() const
{
const\_cast(this)->init();
assert(data->isValid()); // добавляем assert
return data.get();
}
// ...
};
```
Все хорошо, происходит проверка. Но вот беда: она происходит не после изменения, а до. Таким образом, объект может оказаться в неконсистентном состоянии, и только следующий вызов сделает свою работу:
```
c->set(2);
c->set(-2); // здесь assert не сработает
c->set(1); // и только здесь он сработает, хотя значение уже валидно!
```
Хочется, чтобы проверка происходила после изменения, а не до. Для этого будем использовать прокси-объект, в деструкторе которого будет происходить нужная проверка:
```
template
struct An
{
// ...
struct Access
{
Access(T& ref\_) : ref(ref\_) {}
~Access()
{
assert(ref.isValid());
}
T\* operator->() { return &ref }
private:
T& ref;
};
// соответственно, вызов (только неконстантный, т.к. константный не должен менять значение):
Access operator->() { return \*get0(); }
// ...
};
```
Использование:
```
An c;
c->set(2);
c->set(-2); // теперь assert сработает здесь
c->set(1);
```
Что и требовалось.
### Умный мьютекс
Перейдем теперь к нашим многопоточным задачам. Напишем новую реализацию мьютекса и назовем его “умным” по аналогии с умным указателем. Идея умного мьютекста в том, чтобы он брал на себя всю “грязную” работу по работе с объектом, а нам лишь оставалась самая вкусная часть.
Для его приготовления нам потребуется “обычный” мьютекс (так же, как и для умного указателя необходим обычный указатель):
```
// noncopyable
struct Mutex
{
// публичный интерфейс мьютекса
void lock();
void unlock();
private:
// ...
};
```
Теперь усовершенствуем наработки, применяемые ранее при проверке инварианта. Для этого будем использовать не только деструктор прокси-класса, но и конструктор:
```
template
struct AnLock
{
// ...
template
struct Access
{
// в конструкторе захватываем мьютекс
Access(const An& ref\_) : ref(ref\_)
{
ref.mutex->lock();
}
// в деструкторе мьютекс автоматически освобождаем
~Access()
{
ref.mutex->unlock();
}
U\* operator->() const { return ref.get0(); }
private:
const An& ref;
};
// изменяем реализацию операторов доступа к объекту
Access operator->() { return \*this; }
Access operator->() const { return \*this; }
// модифицируем функцию создания
template
U& create() { U\* u = new U; data.reset(u); mutex.reset(new Mutex); return \*u; }
private:
// ...
std::shared\_ptr data;
std::shared\_ptr mutex;
};
```
Использование:
```
AnLock c;
c->set(2); // изменяем значение
std::cout << "Extracted value: " << c->get() << std::endl;
```
Стоит отметить, что при использовании константной ссылки изменение значения будет приводить к ошибке компиляции (в отличие от прямого использования `shared_ptr`):
```
const AnLock& cc = c;
cc->set(3); // эта строчка не скомпилируется
```
Рассмотрим, что же у нас получилось. Добавив вывод на экран для методов класса `Counter` и `Mutex`, получаем следующий вывод на экран при изменении значения:
>
> ```
>
> Mutex::lock
> Counter::set: 2
> Mutex::unlock
>
> ```
>
Последовательность действий при выводе на экран:
>
> ```
>
> Mutex::lock
> Counter::get: 2
> Extracted value: 2
> Mutex::unlock
>
> ```
>
Удобство налицо: вместо явного вызова мьютекса мы просто работаем с объектом как-будто никакого мьютекса нет, а внутри происходит все, что нужно.
Можно спросить: а что делать, если мне надо, например, 2 раза вызвать `inc`, причем сделать это атомарно? Нет проблем! Добавим сначала в наш класс `AnLock` парочку `typedef` для удобства:
```
template
struct AnLock
{
// ...
typedef Access WAccess; // доступ на запись
typedef Access RAccess; // доступ на чтение
// ...
};
```
А затем используем следующую конструкцию:
```
{
AnLock::WAccess a = c;
a->inc();
a->inc();
}
```
Что, в свою очередь, дает следующий вывод:
>
> ```
>
> Mutex::lock
> Counter::inc: 1
> Counter::inc: 2
> Mutex::unlock
>
> ```
>
Чем-то напоминает транзакцию, не так ли?
### Умный RW-мьютекс
Итак, теперь мы можем попробовать реализовать несколько более сложную конструкцию под названием read-write mutex (см. [Readers–writer lock [7]](http://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock)). Суть использования достаточно простая: допускать возможность чтения данных объекта из нескольких потоков, в то время как одновременное чтение и запись или запись и запись должны быть запрещены.
Предположим, у нас есть уже реализация `RWMutex` с таким интерфейсом:
```
// noncopyable
struct RWMutex
{
// публичный интерфейс мьютекса
// для чтения
void rlock();
void runlock();
// для записи
void wlock();
void wunlock();
private:
// ...
};
```
Казалось бы, все, что надо сделать, это слегка изменить реализацию, чтобы наши прокси-типы `RAccess` и `WAccess` использовали разные функции:
```
template
struct AnRWLock
{
// ...
// доступ при чтении
struct RAccess
{
RAccess(const AnRWLock& ref\_) : ref(ref\_)
{
ref.mutex->rlock();
}
~RAccess()
{
ref.mutex->runlock();
}
const T\* operator->() const { return ref.get0(); }
private:
const AnRWLock& ref;
};
// доступ при записи
struct WAccess
{
WAccess(const AnRWLock& ref\_) : ref(ref\_)
{
ref.mutex->wlock();
}
~WAccess()
{
ref.mutex->wunlock();
}
T\* operator->() const { return ref.get0(); }
private:
const AnRWLock& ref;
};
WAccess operator->() { return \*this; }
RAccess operator->() const { return \*this; }
// ...
// модифицируем функцию создания
template
U& create() { U\* u = new U; data.reset(u); mutex.reset(new RWMutex); return \*u; }
private:
// ...
std::shared\_ptr data;
std::shared\_ptr mutex;
};
```
Использование:
```
AnRWLock c;
c->set(2);
```
Результат:
>
> ```
>
> RWMutex::wlock
> Counter::set: 2
> RWMutex::wunlock
>
> ```
>
Пока все отлично! Но последующий код:
```
std::cout << "Extracted value: " << c->get() << std::endl;
```
Дает:
>
> ```
>
> RWMutex::wlock
> Counter::get: 2
> Extracted value: 2
> RWMutex::wunlock
>
> ```
>
Для некоторых это не станет неожиданностью, а для остальной части я поясню, почему тут не работает так, как ожидалось. Ведь мы использовали константный метод, поэтому по идее должен был быть использован константный метод `operator->`. Однако, компилятор так не считает. И связано это с тем, что операции применяются последовательно: сначала применяется операция `->` к неконстантному объекту, а затем вызывается константный метод `Counter::get`, но поезд ушел, т.к. неконстантный `operator->` уже был вызван.
В качестве тривиального решения можно предложить вариант с приведением типа к константному перед обращением к объекту:
```
const AnRWLock& cc = c;
std::cout << "Extracted value: " << cc->get() << std::endl;
```
С результатом:
>
> ```
>
> RWMutex::rlock
> Counter::get: 2
> Extracted value: 2
> RWMutex::runlock
>
> ```
>
Но выглядит это решение, мягко говоря, не очень привлекательно. Хочется писать просто и коротко, а не использовать громоздкие конструкции при каждом обращении к константным методам.
Для решения этой проблемы введем новый оператор длинная стрелка `--->`, который бы осуществлял запись в объект, т.е. доступ к неконстантным методам, а обычную (короткую) стрелку `->` оставим для чтения. Доводы использования короткой стрелки для чтения и длинной — для записи, а не наоборот, следующие:
1. **Визуальный**. Сразу видно, где какая операция используется.
2. **Смысловой**. Чтение — это как бы поверхностное использование объекта: потрогал и отпустил. А запись — это более глубинная операция, изменение, так сказать, внутренностей, поэтому и стрелка длиннее.
3. **Прагматичный**. При замене обычного мьютекса на RW-мьютекс необходимо просто поправить ошибки компиляции, заменив короткую стрелку на длинную в этих местах, и все будет работать наиболее оптимальным образом.
Тут, наверно, внимательный читатель задался вопросом: а где взять такую же травку, как и у автора статьи? Ведь
Давайте смотреть на реализацию:
```
// длинная стрелка, запись:
WAccess operator--(int) { return *this; }
// короткая стрелка, чтение:
RAccess operator->() const { return *this; }
```
Использование:
```
AnRWLock c;
// не будет компилироваться: c->set(2)
c--->set(2);
```
Последовательность действий:
>
> ```
>
> RWMutex::wlock
> Counter::set: 2
> RWMutex::wunlock
>
> ```
>
Все как и раньше, за исключением использования длинной стрелки. Смотрим дальше:
```
std::cout << "Extracted value: " << c->get() << std::endl;
```
>
> ```
>
> RWMutex::rlock
> Counter::get: 2
> Extracted value: 2
> RWMutex::runlock
>
> ```
>
На мой взгляд, использование длинной стрелки для операции записи вполне оправдано: это решают нашу задачу, причем весьма элегантным способом.
**Если читатель не совсем разобрался, как это работает**Если читатель не совсем разобрался, как это работает, то я приведу следующий эквивалентный код использования “длинной” стрелки в качестве подсказки:
```
(c--)->set(2);
```
### Copy-on-write
Далее рассмотрим следующую интересную и полезную идиому: copy-on-write (COW), или [Копирование при записи [8]](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%B8_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B8). Как понятно из названия, основная идея заключается в том, что непосредственно перед изменением данных некоторого объекта сначала происходит копирование в новое место памяти, и уже затем изменение данных по новому адресу.
Хотя подход COW не связан непосредственно с многопоточностью, тем не менее, использование такого подхода совместно с другими значительно улучшает удобство работы и добавляет ряд незаменимых элементов. Именно поэтому ниже приводится реализация COW. Более того, разработанные трюки легко и непринужденно переносятся на реализацию этой идиомы.
Итак, как и для RW-мьютекса, нам необходимо отличать операции чтения от операции записи. При чтении ничего особенного не должно происходить, а вот при записи, если у объекта более одного владельца, то предварительно необходимо этот объект скопировать.
```
template
struct AnCow
{
// ...
// запись с использованием длинной стрелки
T\* operator--(int) { return getW0(); }
// чтение с использованием короткой стрелки
const T\* operator->() const { return getR0(); }
// функция клонирования (только для неполиморфных объектов!)
void clone() { data.reset(new T(\*data)); }
// ...
private:
T\* getR0() const
{
const\_cast(this)->init();
return data.get();
}
T\* getW0()
{
init();
// клонирование в случае “неуникальности” объекта
if (!data.unique())
clone();
return data.get();
}
```
Стоит обратить внимание, что здесь не рассматривается использование полиморфных объектов (т.е. никогда не создаем наследников шаблонного класса `T`), т.к. это выходит за рамки данной статьи. В следующей статье я постараюсь дать детальное решение этого вопроса, при этом реализация будет достаточно необычной.
Перейдем к использованию:
| Код | Вывод в консоли |
| --- | --- |
|
```
AnCow c;
c--->set(2);
```
|
```
Counter::set: 2
```
|
|
```
std::cout << "Extracted value: " << c->get() << std::endl;
```
|
```
Counter::get: 2
Extracted value: 2
```
|
|
```
AnCow d = c;
std::cout << "Extracted value: " << d->get() << std::endl;
```
|
```
Counter::get: 2
Extracted value: 2
```
|
|
```
d--->inc();
```
|
```
Counter copy ctor: 2
Counter::inc: 3
```
|
|
```
c--->dec();
```
|
```
Counter::dec: 1
```
|
В самом начале не происходит ничего интересного: установка значения и вывод на экран этого же значения — `2`. Далее происходит присвоение значения новой переменной, при этом данные объекта используются одни и те же. При выводе значения `d->get()` используется тот же самый объект.
Далее при вызове `d--->inc()` происходит самое интересное: сначала копируется объект, а затем получившееся значение увеличивается до 3-х. При последующем вызове `c--->dec()` копирования не происходит, т.к. владелец теперь только один и у нас имеется две различные копии объекта. Думаю, этот пример наглядно иллюстрирует работу COW.
### Key-value хранилище в памяти
Напоследок рассмотрим некоторые вариации реализации key-value хранилища в памяти при работе в многопоточной среде с использованием разработанных методик.
Будем использовать следующую реализацию для наших хранилищ:
```
template
struct KeyValueStorageImpl
{
// добавление значения в хранилище
void set(T\_key key, T\_value value)
{
storage.emplace(std::move(key), std::move(value));
}
// получение значения
T\_value get(const T\_key& key) const
{
return storage.at(key);
}
// удаление значения
void del(const T\_key& key)
{
storage.erase(key);
}
private:
std::unordered\_map storage;
};
```
Привяжем хранилище к синглтону для упрощения дальнейших манипуляций (см. [Использование паттерна синглтон [1]](http://habrahabr.ru/post/116577/)):
```
template
void anFill(AnRWLock>& D\_an)
{
D\_an = anSingleRWLock>();
}
```
Таким образом, при создании экземпляра `AnRWLock>` будет “заливаться” объект, извлеченный из синглтона, т.е. `AnRWLock>` всегда будет указывать на единственный экземпляр.
Для справки приведу используемую инфраструктуру:
**AnRWLock.hpp**
```
#ifndef AN_RWLOCK_HPP
#define AN_RWLOCK_HPP
#include
#include
#include
#include "Mutex.hpp"
// fill
#define PROTO\_IFACE\_RWLOCK(D\_iface, D\_an) \
template<> void anFill(AnRWLock& D\_an)
#define DECLARE\_IMPL\_RWLOCK(D\_iface) \
PROTO\_IFACE\_RWLOCK(D\_iface, a);
#define BIND\_TO\_IMPL\_RWLOCK(D\_iface, D\_impl) \
PROTO\_IFACE\_RWLOCK(D\_iface, a) { a.create(); }
#define BIND\_TO\_SELF\_RWLOCK(D\_impl) \
BIND\_TO\_IMPL\_RWLOCK(D\_impl, D\_impl)
#define BIND\_TO\_IMPL\_SINGLE\_RWLOCK(D\_iface, D\_impl) \
PROTO\_IFACE\_RWLOCK(D\_iface, a) { a = anSingleRWLock(); }
#define BIND\_TO\_SELF\_SINGLE\_RWLOCK(D\_impl) \
BIND\_TO\_IMPL\_SINGLE\_RWLOCK(D\_impl, D\_impl)
template
struct AnRWLock
{
template
friend struct AnRWLock;
struct RAccess
{
RAccess(const AnRWLock& ref\_) : ref(ref\_)
{
ref.mutex->rlock();
}
~RAccess()
{
ref.mutex->runlock();
}
const T\* operator->() const { return ref.get0(); }
private:
const AnRWLock& ref;
};
struct WAccess
{
WAccess(const AnRWLock& ref\_) : ref(ref\_)
{
ref.mutex->wlock();
}
~WAccess()
{
ref.mutex->wunlock();
}
T\* operator->() const { return ref.get0(); }
private:
const AnRWLock& ref;
};
AnRWLock() {}
template
explicit AnRWLock(const AnRWLock& a) : data(a.data) {}
template
explicit AnRWLock(AnRWLock&& a) : data(std::move(a.data)) {}
WAccess operator--(int) { return \*this; }
RAccess operator->() const { return \*this; }
bool isEmpty() const { return !data; }
void clear() { data.reset(); }
void init() { if (!data) reinit(); }
void reinit() { anFill(\*this); }
T& create() { return create(); }
template
U& create() { U\* u = new U; data.reset(u); mutex.reset(new RWMutex); return \*u; }
private:
T\* get0() const
{
const\_cast(this)->init();
return data.get();
}
std::shared\_ptr data;
std::shared\_ptr mutex;
};
template
void anFill(AnRWLock& a)
{
throw std::runtime\_error(std::string("Cannot find implementation for interface: ")
+ typeid(T).name());
}
template
struct AnRWLockAutoCreate : AnRWLock
{
AnRWLockAutoCreate() { this->create(); }
};
template
AnRWLock anSingleRWLock()
{
return single>();
}
#endif
```
**AnCow.hpp**
```
#ifndef AN_COW_HPP
#define AN_COW_HPP
#include
#include
#include
// fill
#define PROTO\_IFACE\_COW(D\_iface, D\_an) \
template<> void anFill(AnCow& D\_an)
#define DECLARE\_IMPL\_COW(D\_iface) \
PROTO\_IFACE\_COW(D\_iface, a);
#define BIND\_TO\_IMPL\_COW(D\_iface, D\_impl) \
PROTO\_IFACE\_COW(D\_iface, a) { a.create(); }
#define BIND\_TO\_SELF\_COW(D\_impl) \
BIND\_TO\_IMPL\_COW(D\_impl, D\_impl)
#define BIND\_TO\_IMPL\_SINGLE\_COW(D\_iface, D\_impl) \
PROTO\_IFACE\_COW(D\_iface, a) { a = anSingleCow(); }
#define BIND\_TO\_SELF\_SINGLE\_COW(D\_impl) \
BIND\_TO\_IMPL\_SINGLE\_COW(D\_impl, D\_impl)
template
struct AnCow
{
template
friend struct AnCow;
AnCow() {}
template
explicit AnCow(const AnCow& a) : data(a.data) {}
template
explicit AnCow(AnCow&& a) : data(std::move(a.data)) {}
T\* operator--(int) { return getW0(); }
const T\* operator->() const { return getR0(); }
bool isEmpty() const { return !data; }
void clear() { data.reset(); }
void init() { if (!data) reinit(); }
void reinit() { anFill(\*this); }
T& create() { return create(); }
template
U& create() { U\* u = new U; data.reset(u); return \*u; }
// TODO: update clone functionality on creating derived instances
void clone() { data.reset(new T(\*data)); }
private:
T\* getR0() const
{
const\_cast(this)->init();
return data.get();
}
T\* getW0()
{
init();
if (!data.unique())
clone();
return data.get();
}
std::shared\_ptr data;
};
template
void anFill(AnCow& a)
{
throw std::runtime\_error(std::string("Cannot find implementation for interface: ")
+ typeid(T).name());
}
template
struct AnCowAutoCreate : AnCow
{
AnCowAutoCreate() { this->create(); }
};
template
AnCow anSingleCow()
{
return single>();
}
#endif
```
Далее будут рассмотрены различные способы использования этого хранилища, от простого к сложному.
#### Пример 1. Простейшее использование.
Будем непосредственно использовать хранилище без дополнительных изысков:
```
// для простоты объявим класс для дальнейшего использования
template
struct KeyValueStorage : AnRWLock>
{
typedef T\_value ValueType;
};
```
Пример использования:
| Код | Вывод в консоли |
| --- | --- |
|
```
// ключ - имя
// значение - возраст
KeyValueStorage kv;
kv--->set("Peter", 28);
```
|
```
RWMutex::wlock
Key-value: inserting key: Peter
RWMutex::wunlock
```
|
|
```
kv--->set("Nick", 25);
```
|
```
RWMutex::wlock
Key-value: inserting key: Nick
RWMutex::wunlock
```
|
|
```
std::cout << "Peter age: " << kv->get("Peter") << std::endl;
```
|
```
RWMutex::rlock
Key-value: extracting key: Peter
Peter age: 28
RWMutex::runlock
```
|
В первой строчке мы создаем объект `kv`, в который заливается единственный экземпляр хранилища, используя синглтон (см. функцию `anFill`). Далее добавляются записи Peter и Nick, а затем выводится возраст Peter.
Думаю, из вывода понятно, что при записи автоматически берется write-lock, а при чтении — read-lock.
#### Пример 2. Вложенные RW-мьютексы.
Рассмотрим чуть более сложный пример. Предположим теперь, что мы хотим завести именованные счетчики `Counter` и использовать их из нескольких потоков. Нет проблем:
```
// объявляем новый класс, который может в себе хранить объекты с AnRWLock
template
struct KeyValueStorageRW : KeyValueStorage>
{
};
// объявим тип для наших счетчиков
typedef KeyValueStorageRW KVRWType;
```
Пример использования:
| Код | Вывод в консоли |
| --- | --- |
|
```
KVRWType kv;
// AnRWLockAutoCreate - автоматическое создание экземпляра
kv--->set("users", AnRWLockAutoCreate());
```
|
```
RWMutex::wlock
Key-value: inserting key: users
RWMutex::wunlock
```
|
|
```
kv--->set("sessions", AnRWLockAutoCreate());
```
|
```
RWMutex::wlock
Key-value: inserting key: sessions
RWMutex::wunlock
```
|
|
```
kv->get("users")--->inc();
```
|
```
RWMutex::rlock
Key-value: extracting key: users
RWMutex::wlock
Counter::inc: 1
RWMutex::wunlock
RWMutex::runlock
```
|
|
```
kv->get("sessions")--->inc();
```
|
```
RWMutex::rlock
Key-value: extracting key: sessions
RWMutex::wlock
Counter::inc: 1
RWMutex::wunlock
RWMutex::runlock
```
|
|
```
kv->get("sessions")--->dec();
```
|
```
RWMutex::rlock
Key-value: extracting key: sessions
RWMutex::wlock
Counter::dec: 0
RWMutex::wunlock
RWMutex::runlock
```
|
Как говорится, вуаля!
#### Пример 3. Оптимизация доступа.
Хотя о некоторых оптимизациях я хотел бы рассказать в следующей статье, однако здесь опишу, на мой взгляд, достаточно важную оптимизацию.
Ниже приведены различные варианты использования для сравнения.
##### Вариант 1: обычный
| Код | Вывод в консоли |
| --- | --- |
|
```
kv->get("users")--->inc();
```
|
```
RWMutex::rlock
Key-value: extracting key: users
RWMutex::wlock
Counter::inc: 2
RWMutex::wunlock
RWMutex::runlock
```
|
##### Вариант 2: оптимальный
| Код | Вывод в консоли |
| --- | --- |
|
```
auto users = kv->get("users");
```
|
```
RWMutex::rlock
Key-value: extracting key: users
RWMutex::runlock
```
|
|
```
users--->inc();
```
|
```
RWMutex::wlock
Counter::inc: 3
RWMutex::wunlock
```
|
Во втором примере видно, что второй мьютекс на запись для объекта `Counter` берется только после отпускания первого, который контролирует key-value хранилище. Такая реализация обеспечивает более оптимальное использование мьютексов, хотя и получаем в результате более длинную запись. Эту оптимизацию стоит иметь в виду при использовании вложенных мьютексов.
#### Пример 4. Поддержка атомарности изменений.
Предположим, что нам необходимо атомарно увеличить на 100 один из счетчиков, например “users”. Конечно, для этого можно позвать 100 раз операцию `inc()`, а можно сделать так:
| Код | Вывод в консоли |
| --- | --- |
|
```
auto c = kv->get("users");
```
|
```
RWMutex::rlock
Key-value: extracting key: users
RWMutex::runlock
```
|
|
```
KVRWType::ValueType::WAccess cw = c;
cw->set(cw->get() + 100);
```
|
```
RWMutex::wlock
Counter::get: 4
Counter::set: 104
RWMutex::wunlock
```
|
Обратите внимание, что при использовании `WAccess` далее все операции идут с обычной “короткой” стрелкой, т.к. доступ к объекту на запись уже получен. Также стоит обратить внимание на то, что операции `get` и `set` идут под одним и тем же мьютексом, чего мы и хотели достичь. Это очень похоже на то, что мы как будто открыли транзакцию при действии над объектом.
Этот же трюк можно использовать совместно с описанной выше оптимизацией для доступа непосредственно к счетчикам.
##### Вариант 1: обычный
| Код | Вывод в консоли |
| --- | --- |
|
```
kv->get("users")--->inc();
```
|
```
RWMutex::rlock
Key-value: extracting key: users
RWMutex::wlock
Counter::inc: 4
RWMutex::wunlock
RWMutex::runlock
```
|
|
```
kv->get("sessions")--->dec();
```
|
```
RWMutex::rlock
Key-value: extracting key: sessions
RWMutex::wlock
Counter::dec: -1
RWMutex::wunlock
RWMutex::runlock
```
|
##### Вариант 2: оптимальный
| Код | Вывод в консоли |
| --- | --- |
|
```
AnRWLock c1, c2;
{
KVRWType::RAccess r = kv;
c1 = r->get("users");
c2 = r->get("sessions");
}
```
|
```
RWMutex::rlock
Key-value: extracting key: users
Key-value: extracting key: sessions
RWMutex::runlock
```
|
|
```
c1--->inc();
```
|
```
RWMutex::wlock
Counter::inc: 5
RWMutex::wunlock
```
|
|
```
c2--->dec();
```
|
```
RWMutex::wlock
Counter::dec: -2
RWMutex::wunlock
```
|
Опять же, во втором примере мьютексы используются более оптимально: read lock берется ровно один раз, write lock берется вне read-lock, что дает бОльшую производительность при конкурентном доступе.
#### Пример 5. COW.
Предположим, что у нас есть сотрудники со следующей информацией:
```
struct User
{
std::string name;
int age;
double salary;
// много более другой информации...
};
```
Наша задача: провести различные операции над выбранными пользователями, например рассчитать бухгалтерский баланс. Ситуация осложняется тем, что операция длительная. При этом при расчете изменение информации о сотрудниках недопустимо, т.к. различные показатели должны быть согласованными, и если изменится какие-либо данные, то баланс может не сойтись. При этом хочется, чтобы за время проведения операции информацию о сотрудниках таки можно было изменять, не дожидаясь окончания длительных операций. Чтобы реализовать рассчет, необходимо как бы снимать snapshot данных для какого-то момента времени. Конечно, при этом данные могут стать неактуальны, но для баланса важнее иметь самосогласованность результатов.
Посмотрим, как это можно реализовать с использованием COW. Подготовительный этап:
| |
| --- |
| Использование COW при создании экземпляра `User`
```
BIND_TO_SELF_COW(User)
```
|
| Объявляем новый класс, который может в себе хранить объекты с `AnCow`
```
template
struct KeyValueStorageCow : AnRWLock>>
{
};
```
|
| Объявление нашего хранилища: `int` — id пользователя, `User` — пользователь
```
KeyValueStorageCow kv;
```
|
| Добавление информации о пользователе Peter
```
AnCow u;
u--->name = "Peter";
u--->age = 35;
u--->salary = 12345;
kv--->set(1, u);
```
|
| Добавление информации о пользователе George
```
AnCow u;
u--->name = "George";
u--->age = 31;
u--->salary = 54321;
kv--->set(2, u);
```
|
| Изменение информации о возрасте сотрудника
```
AnCow u = kv->get(2);
++ u--->age;
kv--->set(2, u);
```
|
Проведение баланса:
| |
| --- |
| Получение нужных пользователей
```
AnCow u1 = kv->get(1);
AnCow u2 = kv->get(2);
```
|
| Расчет необходимых параметров. Все данные будут самосогласованны и останутся неизменны вплоть до окончания операций.
```
double totalSalary = u1->salary + u2->salary;
double averageSalary = totalSalary/2.;
double averageAge = (u1->age + u2->age)/2.;
double averageSalaryPerAge = (u1->salary/u1->age + u2->salary/u2->age)/2.;
// ...
```
|
Таким образом, при проведении длительной операции происходит фиксация информации о пользователях на момент ее извлечения. В каждый момент времени возможно изменить информацию о сотруднике, однако это не повлияет на текущие расчеты. А при следующем проведении баланса будут использованы самые свежие данные. Такой подход гарантирует самосогласованность расчетов с возможностью изменения данных в любой момент, не дожидаясь окончания длительных расчетов.
В целом, можно было бы конечно использовать копирование всех элементов перед расчетом. Однако при наличии достаточно большого количества информации это будет достаточно длительная операция. Поэтому она в обозначенном подходе откладывается до тех пор, пока действительно необходимо скопировать данные, т.е. только при их одновременном использовании в расчетах и изменении.
### Анализ и обобщение
Ниже будет дан анализ примеров. Наибольший интерес, прежде всего, представляет последний пример с COW, так как там скрываются неожиданные сюрпризы.
#### COW в деталях
Рассмотрим последовательность операций последнего примера. Ниже приведена общая схема при извлечении значения из контейнера:
Здесь `Data` — это `User` в описанном выше примере, а `shared_ptr` — это содержимое объекта `AnCow`. Последовательность операций:
| N | Операция | Описание |
| --- | --- | --- |
| 1 | lock | Блокировка хранилища, делается автоматически при вызове `operator->` |
| 2 | copy | Копирование `shared_ptr`, т.е. фактически происходит простое увеличение счетчиков (`use_count` и `weak_count` внутри объекта `shared_ptr`) |
| 3 | unlock | Снятие блокировки хранилища деструкторе временного объекта |
После этих операций можно делать различные действия над объектом. При чтении никаких дополнительных действий не происходит: просто берем и считываем данные объекта непосредственно из занимаемой области данных. Тут стоит упомянуть очень неожиданный нюанс: **чтение данных объекта происходит без взятия блокировки!** Это неожиданное свойство я и хотел подчеркнуть, разбирая COW.
Что же происходит при записи данных в объект. Смотрим:
Последовательность операций при этом выглядит следующим образом:
| N | Операция | Описание |
| --- | --- | --- |
| 4 | clone | Клонирование объекта, вызывается конструктор копирования объекта `Data`, т.е. копирование всех его полей в новую область памяти. После этой операции `shared_ptr` начинает смотреть на вновь созданный объект. |
| 5 | modify | Непосредственно операция модификации. Может происходить длительное время, т.к. является неблокирующей. |
| 6 | lock | Перед обновлением хранилища прозводится взятие блокировки. |
| 7 | replace | Замена старого значения `shared_ptr` на новое, модифицированное на 5-м шаге. |
| 8 | unlock | Снятие блокировки хранилища. |
Как и в случае чтения, **запись в объект происходит без участия блокировок**, т.к. мы — единственный владелец созданного объекта. В принципе, ту же схему операций можно наблюдать при манипуляциях с объектом простого типа, например, типа `int`. Существенное отличие состоит в том, что при COW данные могут использоваться из одной и той же области памяти в нескольких потоках одновременно.
Стоит отметить, что большинство указанных выше операций происходят автоматически, т.е. нет необходимости в выполнении всех операций явным образом.
##### Оптимизация количества COW
Как показано выше, при изменении объекта COW происходит копирование всех его полей. Это не представляет большой проблемы при малом количестве данных. Но что делать, если у нас в классе имеется большое количество параметров? В этом случае можно использовать многоуровневые COW-объекты. Например, можно было бы ввести следующий класс `UserInfo`:
```
struct UserInfo
{
AnCow accounting;
AnCow common;
AnCow work;
};
struct AccountingInfo
{
AnCow incoming;
AnCow outcoming;
AnCow balance;
};
struct CommonInfo
{
// и т.д.
};
// и т.п.
```
Введя на каждом из уровней объекты COW, можно значительно уменьшить количество копирований. При этом, сама операция копирования будет состоять лишь в атомарном увеличении счетчиков. И лишь непосредственно сам объект изменения будет скопирован с использованием конструктора копирования. Можно легко показать, что **минимальное количество копирований достигается при количестве объектов на каждом из уровней равным 3-м**.
#### Обобщенная схема
Рассмотрев более детально операции с COW с учетом вложенности, можно теперь смело перейти к обобщению использования рассмотренных идиом. Но для этого сначала рассмотрим схемы, используемые в примерах.
В первом примере использовались вложенные `AnRWLock` объекты:
Key-value хранилище в указанном примере был положен в синглтон и сверху обернут “умным” мьютексом. Значения при этом также были обернуты в “умный” мьютекс.
Следующая схема описывает пример с COW:
Здесь значение было обернуто в объект `AnCow` для реализации семантики COW.
Соответственно, обобщенную схему можно представить в виде:
Понятно, что объекты `AnLock` и `An(RW)Lock` взаимозаменяемы: можно использовать как один, так и другой. Также можно цепочку повторять несколько раз, как показно на примере ниже:
Стоит, однако, помнить, что семантика объектов `An(RW)Lock` и `AnCow` существенно отличается:
| Свойство | Умный мьютекс | COW |
| --- | --- | --- |
| Доступ к полям объекта | Блокируется на время чтения/записи | Не блокируется |
| Изменение объекта в контейнере | Изменение “на месте” (in-place) | После изменения необходимо положить новое значение обратно в контейнер |
### Выводы
Итак, в статье были рассмотрены некоторые идиомы, повышающие эффективность написания многопоточных приложений. Стоит отметить следующие преимущества:
1. **Простота**. Нет необходимости явного использования многопоточных примитивов, все происходит автомагически.
2. **Гибкость**. Решение применимо для широкого класса многопоточных задач с возможностью комбинирования различных идиом. Здесь также стоит упомянуть поддержку транзакционности (в памяти) на некотором начальном уровне.
3. **Качество**. Использование такого подхода позволяет существенно уменьшить количество проблем, связанных с состоянием гонки (race condition) и взаимной блокировки (deadlock). Состояния гонки устраняются наличием автоматических блокировок благодаря умным мьютексам. Вероятность взаимной блокировки существенно уменьшается благодаря гранулярному (fine-grained) доступу к данным на каждом уровне, и фиксированным автоматическим порядком захвата и снятия блокировок.
Такой универсальный подход стал возможен благодаря тому, что в реализации `An`-классов происходит полный контроль использования хранимых объектов. Поэтому появляется возможность добавлять нужный функционал, автоматически вызывая на границах доступа необходимые методы. Этот подход будет существенно углублен и расширен в следующей статье.
В приведенном материале не рассматривалось использование полиморфных объектов. В частности, реализация `AnCow` работает только с тем же шаблонным классом, т.к. всегда вызывается конструктор копирования для объявленного типа `T`. В следующей статье будет приведена реализация для более общего случая. Также будет проведена унификация объектов и способов их использования, рассказано о различных оптимизациях, о многопоточных ссылках, и многое другое.
### Литература
[1] [Хабрахабр: Использование паттерна синглтон](http://habrahabr.ru/post/116577/)
[2] [Хабрахабр: Синглтон и время жизни объекта](http://habrahabr.ru/post/118368/)
[3] [Хабрахабр: Обращение зависимостей и порождающие шаблоны проектирования](http://habrahabr.ru/post/118550/)
[4] [Хабрахабр: Реализация синглтона в многопоточном приложении](http://habrahabr.ru/post/150276/)
[5] [Википедия: Состояние гонки](http://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D0%BD%D0%BA%D0%B8)
[6] [Википедия: Взаимная блокировка](http://ru.wikipedia.org/wiki/%D0%92%D0%B7%D0%B0%D0%B8%D0%BC%D0%BD%D0%B0%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)
[7] [Wikipedia: Readers–writer lock](http://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock)
[8] [Википедия: Копирование при записи](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%B8_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B8)
[9] [Хабрахабр: Многопоточность, общие данные и мьютексы](http://habrahabr.ru/blogs/cpp/72929/)
[10] [Хабрахабр: Кросс-платформенные многопоточные приложения](http://habrahabr.ru/post/141744/)
[11] [Хабрахабр: Потоки, блокировки и условные переменные в C++11 [Часть 2]](http://habrahabr.ru/post/182626/)
[12] [Хабрахабр: Потоки, блокировки и условные переменные в C++11 [Часть 1]](http://habrahabr.ru/post/182610/)
[13] [Хабрахабр: Два простых правила для предотвращения взаимных блокировок на мьютексах](http://habrahabr.ru/company/nordavind/blog/176541/)
[14] [DrDobbs: Enforcing Correct Mutex Usage with Synchronized Values](http://www.drdobbs.com/cpp/enforcing-correct-mutex-usage-with-synch/225200269)
**P.S. Решение задачи про количество копирований**Предположим, на каждом из уровней имеется `n` объектов, количество уровней — `k`, а общее число элементов — `a`. Тогда количество элементов `a = n^k`, или `k = ln a/ln n`. ~~Сокращая `ln` получаем `k = a/n`.~~ Количество копирований `= n*k` (необходимо пройти каждый слой и скопировать на каждом слое `n` раз). Т.е. число копирований `= n*ln a/ln n` или просто `n/ln n`, т.к. `a` — const. Легко найти локальный минимум, он достигается [при `n = e`](http://www.wolframalpha.com/input/?i=n%2Fln+n), что ближе всего соответствует целому числу 3.
И напоследок — опрос. На повестке дня 2 вопроса: | https://habr.com/ru/post/184436/ | null | ru | null |
# Будущее внедрения зависимостей в Android
*Предлагаю вашему вниманию перевод [оригинальной статьи](https://medium.com/default-to-open/android-pie-and-the-future-of-dependency-injection-2fdbc65cb79b) от [Jamie Sanson](https://medium.com/@jamiesanson)*
### Создание Activity до Android 9 Pie
*Внедрение зависимостей (DI)* — это общая модель, по ряду причин используемая во всех формах разработки. Благодаря проекту Dagger, он взят в качестве шаблона, используемого в разработке для Android. Недавние изменения в Android 9 Pie привели к тому, что теперь у нас есть больше возможностей, когда речь идет о DI, особенно с новым классом [`AppComponentFactory`](https://developer.android.com/reference/android/app/AppComponentFactory).
---
DI очень важно, когда речь заходит о современной разработке Android. Это позволяет сократить общее количество кода при получении ссылок на сервисы, используемые между классами, и в целом хорошо разделяет приложение на компоненты. В этой статье мы сосредоточимся на Dagger 2, самой распространенной библиотеке DI, используемой в разработке Android. Предполагается, что вы уже обладаете базовыми знаниями о том, как это работает, но не обязательно понимать все тонкости. Стоит отметить, что эта статья — нечто вроде авантюры. Это интересно и всё, но на момент её написания Android 9 Pie даже не появлялся на [панели версий платформы](https://developer.android.com/about/dashboards/), поэтому, вероятно, данная тема не будет иметь отношения к повседневной разработке в течение как минимум нескольких лет.
### Внедрение зависимостей в Android сегодня
Проще говоря, мы используем DI для предоставления экземпляров классов «зависимости» нашим зависимым классам, то есть тем, которые выполняют работу. Давайте предположим, что мы используем [паттерн Репозиторий](https://docs.microsoft.com/en-us/previous-versions/msp-n-p/ff649690(v=pandp.10)) для обработки нашей логики, связанной с данными, и хотим использовать наш репозиторий в Activity для показа пользователю некоторых данных. Возможно, мы захотим использовать один и тот же репозиторий в нескольких местах, поэтому мы используем внедрение зависимостей, чтобы упростить совместное использование одного и того же экземпляра между кучей разных классов.
Для начала предоставим репозиторий. Мы определим функцию `Provides` в модуле, позволяющую Dagger знать, что это именно тот экземпляр, который мы хотим внедрить. Обратите внимание, что нашему репозиторию нужен экземпляр контекста для работы с файлами и сетью. Мы предоставим ему контекст приложения.
```
@Module
class AppModule(val appContext: Context) {
@Provides
@ApplicationScope
fun provideApplicationContext(): Context = appContext
@Provides
@ApplicationScope
fun provideRepository(context: Context): Repository = Repository(context)
}
```
Теперь нам нужно определить `Component` для обработки внедрения классов, в которых мы хотим использовать наш `Repository` .
```
@ApplicationScope
@Component(modules = [AppModule::class])
interface ApplicationComponent {
fun inject(activity: MainActivity)
}
```
Наконец, мы можем настроить нашу `Activity` чтобы использовать наш репозиторий. Предположим, что мы создали экземпляр нашего `ApplicationComponent` где-то еще.
```
class MainActivity: AppCompatActivity() {
@Inject
lateinit var repository: Repository
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Инжектим зависимости здесь
application.applicationComponent.inject(this)
// Теперь мы можем использовать наш репозиторий
}
}
```
Вот и всё! Мы только что настроили внедрение зависимостей в рамках приложения с помощью Dagger. Есть несколько способов сделать это, но это кажется самым простым подходом.
### Что не так с текущим подходом?
В приведенных выше примерах мы увидели два разных типа инъекций, один очевиднее другого.
Первый, который вы, возможно, пропустили, известен как **внедрение в конструктор**. Это метод предоставления зависимостей через конструктор класса, означающий, что класс, использующий зависимости, не имеет представления о происхождении экземпляров. Это считается самой чистой формой внедрения зависимостей, так как она прекрасно инкапсулирует нашу логику внедрения в наши классы `Module`. В нашем примере мы использовали этот подход для предоставления репозитория:
```
fun provideRepository(context: Context): Repository = Repository(context)
```
Для этого нужен был `Context`, который мы предоставили в функции `provideApplicationContext()`.
Второе, более очевидное, что мы увидели, это **внедрение в поле класса**. Этот метод использовался в нашей `MainActivity` для предоставления нашего хранилища. Здесь мы определяем поля как получателей инъекций, используя аннотацию `Inject`. Затем в нашей функции `onCreate` мы сообщаем `ApplicationComponent` что в наши поля надо инжектить зависимости. Выглядит не так чисто, как внедрение в конструктор, поскольку у нас есть явная ссылка на наш компонент, что означает, что концепция внедрения просачивается внутрь наших зависимых классов. Другой недостаток в классах Android Framework, так как мы должны быть уверены, что первое, что мы делаем — это предоставляем зависимости. Если это произойдёт не в той точке жизненного цикла, мы можем случайно попытаться использовать объект, который ещё не был инициализирован.
В идеале, следовало бы полностью избавиться от внедрений в поля класса. Такой подход пропускает информацию о внедрении в классы, которые не должны знать об этом, и потенциально может вызвать проблемы с жизненными циклами. Мы видели попытки сделать это лучше, и *Dagger* в Android — довольно надежный способ, но в конечном итоге было бы лучше, если бы мы могли просто использовать внедрение в конструктор. В настоящее время мы не можем использовать такой подход для ряда классов фреймворка, таких как «Activity», «Service», «Application» и т. д., поскольку они создаются для нас системой. Кажется, на данный момент мы застряли на внедрении в поля классов. Тем не менее, в Android 9 Pie готовится нечто интересное, что, возможно, в корне всё изменит.
### Внедрение зависимостей в Android 9 Pie
Как уже упоминалось в начале статьи, в Android 9 Pie есть класс AppComponentFactory. Документация для него довольно скудная, и размещена просто на сайте разработчика как таковая:
> *Интерфейс, используемый для управления созданием элементов манифеста.*
Это интригует. «Элементы манифеста» здесь относятся к классам, которые мы перечисляем в нашем файле `AndroidManifest` — таким как Activity, Service и наш Application класс. Это позволяет нам «контролировать создание» этих элементов… так, погодите, мы теперь можем установить правила для создания наших Activity? Прелесть какая!
Давайте копнём глубже. Мы начнём с расширения [`AppComponentFactory`](https://developer.android.com/reference/android/app/AppComponentFactory) и переопределения метода `instantiateActivity`.
```
class InjectionComponentFactory: AppComponentFactory() {
private val repository = NonContextRepository()
override fun instantiateActivity(cl: ClassLoader, className: String, intent: Intent?): Activity {
return when {
className == MainActivity::class.java.name -> MainActivity(repository)
else -> super.instantiateActivity(cl, className, intent)
}
}
}
```
Теперь нам нужно объявить нашу фабрику компонентов в манифесте внутри тега **application**.
Наконец мы можем запустить наше приложение… и это работает! Наш `NonContextRepository` предоставляется через конструктор MainActivity. Изящно!
Обратите внимание, что здесь есть некоторые оговорки. Мы не можем использовать `Context` здесь, так как ещё до его существования происходит вызов нашей функции — это сбивает с толку! Мы можем пойти дальше, чтобы конструктор внедрил наш класс Application, но давайте посмотрим, как Dagger может сделать это еще проще.
### Встречайте — Dagger Multi-Binds
Я не буду вдаваться в подробности работы множественного связывания Dagger под капотом, так как это выходит за пределы данной статьи. Всё, что вам нужно знать, — это то, что он обеспечивает хороший способ внедрения в конструктор класса без необходимости вызова конструктора вручную. Мы можем использовать это, чтобы легко внедрить классы фреймворка масштабируемым способом. Посмотрим, как всё это складывается.
Давайте сначала настроим нашу Activity, чтобы понять, что куда двигаться дальше.
```
class MainActivity @Inject constructor(
private val repository: NonContextRepository
): Activity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Отсюда мы можем использовать наш репозиторий
}
}
```
Из этого сразу видно, что почти *нет* упоминаний о внедрении зависимостей. Единственное, что мы видим, — это аннотацию `Inject` перед конструктором.
Теперь необходимо изменить компонент и модуль Dagger:
```
@Component(modules = [ApplicationModule::class])
interface ApplicationComponent {
fun inject(factory: InjectionComponentFactory)
}
```
```
@Module(includes = [ComponentModule::class])
class ApplicationModule {
@Provides
fun provideRepository(): NonContextRepository = NonContextRepository()
}
```
Ничего особенного не изменилось. Теперь нам нужно только внедрить нашу фабрику компонентов, но как нам создать наши элементы манифеста? Здесь нам понадобится `ComponentModule`. Давайте посмотрим:
```
@Module
abstract class ComponentModule {
@Binds
@IntoMap
@ComponentKey(MainActivity::class)
abstract fun bindMainActivity(activity: MainActivity): Any
@Binds
abstract fun bindComponentHelper(componentHelper: ComponentHelper): ComponentInstanceHelper
}
@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
@Retention(AnnotationRetention.RUNTIME)
@MapKey
internal annotation class ComponentKey(val clazz: KClass)
```
Ага, хорошо, всего лишь несколько аннотаций. Здесь мы связываем нашу `Activity` с мапой, внедряем эту мапу в наш класс `ComponentHelper` и предоставляем этот `ComponentHelper` — все в двух инструкциях `Binds`. Dagger знает, как создать экземпляр нашей `MainActivity` благодаря аннотации `Inject` поэтому может «привязать» провайдера к этому классу, автоматически предоставляя необходимые нам зависимости для конструктора. Наш `ComponentHelper` выглядит следующим образом.
```
class ComponentHelper @Inject constructor(
private val creators: Map, @JvmSuppressWildcards Provider>
): ComponentInstanceHelper {
@Suppress("UNCHECKED\_CAST")
override fun resolve(className: String): T? =
creators
.filter { it.key.name == className }
.values
.firstOrNull()
?.get() as? T
}
interface InstanceComponentHelper {
fun resolve(className: String): T?
}
```
Проще говоря, теперь у нас есть карта классов для поставщиков для этих классов. Когда мы пытаемся разрешить класс по имени, мы просто находим провайдера для этого класса (если он у нас есть), вызываем его, чтобы получить новый экземпляр этого класса, и возвращаем его.
Наконец, нам нужно внести изменения в наш [`AppComponentFactory`](https://developer.android.com/reference/android/app/AppComponentFactory) чтобы использовать наш новый вспомогательный класс.
```
class InjectionComponentFactory: AppComponentFactory() {
@Inject
lateinit var componentHelper: ComponentInstanceHelper
init {
DaggerApplicationComponent.create().inject(this)
}
override fun instantiateActivity(cl: ClassLoader, className: String, intent: Intent?): Activity {
return componentHelper
.resolve(className)
?.apply { setIntent(intent) } ?: super.instantiateActivity(cl, className, intent)
}
}
```
Запустите код еще раз. Это всё работает! Прелесть какая.
### Проблемы внедрения в конструктор
Такой заголовок может выглядеть не очень впечатляющим. Хотя мы можем внедрить большинство экземпляров в обычном режиме с помощью внедрения в конструктор, у нас нет очевидного способа предоставления контекста для наших зависимостей стандартными способами. А ведь `Context` в Android — это всё. Он нужен для доступа к настройкам, сети, конфигурации приложения и многому другому. Нашими зависимостями часто являются вещи, которые используют связанные с данными службы, такие как сеть и настройки. Мы можем обойти это, переписав наши зависимости, чтобы они состояли из чистых функций, или инициализируя все с помощью экземпляров контекста в нашем классе `Application`, но для определения наилучшего способа сделать это требуется гораздо больше усилий.
Другим недостатком этого подхода является определение области видимости. В Dagger одной из ключевых концепций реализации высокопроизводительного внедрения зависимостей с хорошим разделением отношений между классами является модульность графа объекта и использование области видимости. Хотя этот подход не запрещает использование модулей, он ограничивает использование области видимости. [`AppComponentFactory`](https://developer.android.com/reference/android/app/AppComponentFactory) существует на совершенно ином уровне абстракции относительно наших стандартных классов фреймворка — мы не можем получить ссылку на него программно, поэтому у нас нет способа дать ему указание предоставить зависимости для `Activity` в другой области видимости.
Существует множество способов решить наши проблемы с областями видимости на практике, одним из которых является использование [`FragmentFactory`](https://developer.android.com/reference/androidx/fragment/app/FragmentFactory) для внедрения наших фрагментов в конструктор с областями видимости. Я не буду вдаваться в подробности, но оказывается, что сейчас у нас есть метод управления созданием фрагментов, который не только дает нам гораздо большую свободу с точки зрения области видимости, но и обладает обратной совместимостью.
### Заключение
В Android 9 Pie появился способ использования внедрения в конструктор для предоставления зависимостей в наших классах фреймворка, таких как «Activity» и «Application». Мы увидели, что с помощью *Dagger Multi-binding* мы можем с легкостью предоставлять зависимости на уровне приложения.
Конструктор, внедряющий все наши компоненты, чрезвычайно привлекателен, и мы можем даже сделать что-то, чтобы заставить его работать должным образом с экземплярами контекста. Это многообещающее будущее, но оно доступно только начиная с API 28. Если вы хотите охватить менее 0,5% пользователей — можете попробовать. В противном случае стоит подождать и посмотреть, останется ли такой способ актуальным через несколько лет. | https://habr.com/ru/post/444530/ | null | ru | null |
# Функциональный подход в Jetpack Compose: каррирование функций
28 июля в мире Android произошло важное событие: анонсировали [Jetpack Compose 1.0](https://android-developers.googleblog.com/2021/07/jetpack-compose-announcement.html). Вместе с этим нововведением места для ключевого слова `class` стало ещё меньше. Kotlin поддерживает парадигму **функционального программирования** (ФП), и разработчики Google этим умело пользуются.
Часто объектно-ориентированный подход (ООП) ставят в противовес ФП. Это ошибка: они не соперники и могут друг друга дополнить. Одно из понятий ФП — каррирование функций. Оно позволяет произвести частичное применение в ожидании данных, минимизируя количество ошибок в коде: это может пригодиться при разработке в Compose и не только :)
Давайте посмотрим, что такое каррирование и как его можно использовать на практике.
### Несколько слов об аргументах функции
Для ООП-мира привычно думать, что функции могут иметь несколько аргументов. На самом деле это не так. Функция описывает связь между исходным (областью определения) и конечным множеством данных (областью значений). Она не связывает несколько исходных множеств с конечным множеством.
Таким образом, функция не может иметь несколько аргументов. По сути, аргументы — это множество:
```
// Привычный вид функции
fun f(a: Int, b: Int) = a + b
// Скрытый вид функции
fun f(vararg a: Int) = a.first() + a.last()
```
Следуя соглашению, лишний код опущен. Но всё же это функция одного аргумента, а не двух.
### Что такое каррирование функций
Итак, теперь мы знаем, что аргумент один — массив данных (кортеж). Тогда функцию `f(a, b)` можно рассматривать как множество всех функций на N от множества всех функций на N. Это выглядело бы так: `f(a)(b)`. В таком случае можно записать: `f(a) = f2; f2(b) = a + b`.
Когда применяется функция `f(a)`, аргумент `a` перестаёт быть переменной и превращается в константу для функции `f2(b)`. Результат выполнения `f(a)` — функция, которую можно выполнить отложенно.
Преобразование функции в вид `f(a)(b)` и называется каррированием — в честь математика Хаскелла Карри. Хотя он это преобразование и не изобретал :)
```
// Пример каррированой функции с применением fun
fun f(a: Int) = { b: Int -> a + b }
// Пример каррированой функции с применением переменной
val f2: (Int) -> (Int) -> Int = { b -> { a -> a + b } }
```
### Jetpack Compose и частичное применение функций
Каррирование позволяет разбить функцию на несколько блоков и выполнить их отложенно по мере надобности. Для этого подхода существует термин — **«частичное применение»**.
Приведу практический пример частичного применения в Jetpack Compose. Добавим простой BottomNavigation с логикой переключения в приложение, любезно сгенеренное нам Android Studio.
Demo currying app
```
CurryingTheme {
var currentTab by remember { mutableStateOf(0) }
Scaffold(
bottomBar = {
BottomNavigation {
BottomNavigationItem(
selected = currentTab == 0,
icon = { Icon(Icons.Filled.Person, null) },
onClick = {
currentTab = 0
}
)
BottomNavigationItem(
selected = currentTab == 1,
icon = { Icon(Icons.Filled.Phone, null) },
onClick = {
currentTab = 1
}
)
}
}
) {
Greeting("Android")
}
}
```
Подправим Greeting для переключения текста в зависимости от состояния BottomNavigation.
```
when (currentTab) {
0 -> Greeting("Selected - Person")
1 -> Greeting("Selected - Phone")
}
```
Это работает, но подобный подход чреват багами: использование случайных констант принесёт путаницу в них. Давайте заменим произвольные константы на `sealed class`, который поможет нам избежать возможных проблем.
```
sealed class BottomNavigationTab {
object Person : BottomNavigationTab()
object Phone : BottomNavigationTab()
}
```
Выглядит намного надёжней. Добавим ещё небольшую фичу — вывод Snackbar при переключении. В данном случае он хорошо подчёркивает важность упрощения `onClick` и карринга в дальнейшем.
```
CurryingTheme {
val scope = rememberCoroutineScope()
val scaffoldState: ScaffoldState = rememberScaffoldState()
var currentTab: BottomNavigationTab by remember { mutableStateOf(BottomNavigationTab.Person) }
Scaffold(
scaffoldState = scaffoldState,
bottomBar = {
BottomNavigation {
BottomNavigationItem(
selected = currentTab == BottomNavigationTab.Person,
icon = { Icon(Icons.Filled.Person, null) },
onClick = {
currentTab = BottomNavigationTab.Person
scope.launch {
scaffoldState.snackbarHostState.showSnackbar("Selected - ${currentTab::class.simpleName}")
}
}
)
BottomNavigationItem(
selected = currentTab == BottomNavigationTab.Phone,
icon = { Icon(Icons.Filled.Phone, null) },
onClick = {
currentTab = BottomNavigationTab.Phone
scope.launch {
scaffoldState.snackbarHostState.showSnackbar("Selected - ${currentTab::class.simpleName}")
}
}
)
}
}
) {
when (currentTab) {
BottomNavigationTab.Person -> Greeting("Selected - Person")
BottomNavigationTab.Phone -> Greeting("Selected - Phone")
}
}
}
```
Допустим, BottomNavigationItem будет далеко не один. `onClick` выглядит удручающе — много дублирующего кода. Это можно легко подправить, вынеся код во вложенную функцию.
```
fun onClick(tab: BottomNavigationTab) {
currentTab = tab
scope.launch {
scaffoldState.snackbarHostState.showSnackbar("Selected - ${currentTab::class.simpleName}")
}
}
```
С применением этой функции `onClick` будет выглядеть следующим образом:
```
BottomNavigationItem(
selected = currentTab == BottomNavigationTab.Person,
icon = { Icon(Icons.Filled.Person, null) },
onClick = {
onClick(BottomNavigationTab.Person)
}
)
BottomNavigationItem(
selected = currentTab == BottomNavigationTab.Phone,
icon = { Icon(Icons.Filled.Phone, null) },
onClick = {
onClick(BottomNavigationTab.Phone)
}
)
```
Это рабочий вариант, но карринг с помощью частичного применения поможет ещё больше упростить `onClick`.
```
// каррированая функция
fun onClick(tab: BottomNavigationTab): () -> Unit = {
currentTab = tab
scope.launch {
scaffoldState.snackbarHostState.showSnackbar("Selected - ${currentTab::class.simpleName}")
}
}
```
```
// частичное применение
BottomNavigationItem(
selected = currentTab == BottomNavigationTab.Person,
icon = { Icon(Icons.Filled.Person, null) },
onClick = onClick(BottomNavigationTab.Person)
)
BottomNavigationItem(
selected = currentTab == BottomNavigationTab.Phone,
icon = { Icon(Icons.Filled.Phone, null) },
onClick = onClick(BottomNavigationTab.Phone)
)
```
---
Мы рассмотрели один из примеров применения каррированной функции в Jetpack Compose, но цели данного преобразования значительно шире.
Каррирование широко используется в языках программирования, поддерживающих функциональную парадигму. Все языки, поддерживающие замыкание, позволяют записывать каррированные функции: например, JavaScript, C#, Kotlin, Haskell. Имеет смысл освоить этот приём, чтобы минимизировать баги в коде, упростить его для понимания, сократить количество строк, обогатить ООП-код. Удачи!
Проект доступен на [GitHub](https://github.com/keygenqt/android-demo/tree/master/currying) | https://habr.com/ru/post/581476/ | null | ru | null |
# Империя наносит ответный удар
Недавно появилась статья «Hackathon 2: Time lapse analysis of Unreal Engine 4», в которой рассказывается, как взяв инструмент Klocwork, можно найти множество ошибок в проекте Unreal Engine 4. Я не могу пройти мимо этой статьи. Дело в том, что в свое время мы исправили все ошибки, которые нашел в этом проекте анализатор PVS-Studio. Понятно, что были исправлены не вообще все ошибки, а только обнаруживаемые анализатором. Однако статья создаёт впечатление, что анализатор PVS-Studio пропустил слишком много. Что ж, теперь мой ход. Я тоже заново перепроверил Unreal Engine 4 и нашел массу ошибок. Таким образом я могу заявить, что PVS-Studio тоже может найти сейчас в Unreal Engine 4 новые ошибки. Ничья.
Историческая справка
--------------------
Всё началось полтора года назад, когда я написал статью "[Долгожданная проверка Unreal Engine 4](http://www.viva64.com/ru/b/0249/)". Далее было сотрудничество с компанией Epic Games, результатом которого стало устранение всех предупреждений, которые выдавал PVS-Studio. В результате было поправлено множество ошибок и устранены все ложные срабатывания анализатора. Наша команда выдала компании Epic Games проект, свободный от предупреждений PVS-Studio. Как это происходило, можно узнать из статьи "[Как команда PVS-Studio улучшила код Unreal Engine](http://www.viva64.com/ru/b/0330/)".
Недавно на просторах интернета я наткнулся на статью "[Hackathon 2: Time lapse analysis of Unreal Engine 4](http://blog.klocwork.com/static-analysis/analysis-of-unreal-engine-4/)". Статья хорошая и корректная. Компания Rogue Wave молодец, что проводит такие мероприятия и делает мощный статический анализатор кода Klocwork. Michail Greshishchev тоже молодец, что проделал работу по проверке Unreal Engine и нашёл время написать про это статью. Всё хорошо. Но я обеспокоен, что сторонний человек, мало знакомый со статическими анализаторами, может сделать неправильные выводы. Поэтому я обязан прокомментировать эту статью.
Непреднамеренно, но непосвященному читателю эта статья показывает нас в невыгодном свете по сравнению Klocwork. Кажется, что PVS-Studio находит меньше ошибок, чем Klocwork. На самом деле мир устроен сложнее. Оба анализатора имеют различные множества диагностик. Частично эти множества пересекаются. Однако каждый из анализаторов имеет уникальный набор диагностик. Таким образом, проверив большой проект одним анализатором, вы потом всегда что-то найдёте другим анализатором.
Ещё один нюанс. Мы не проверяли сторонние библиотеки (каталог ThirdParty), а Michail Greshishchev проверял (по крайней мере частично), о чем свидетельствует один из примеров кода (см. функцию HeadMountedDisplayCommon). В ThirdParty анализатор PVS-Studio может также легко найти множество интересных дефектов. Тем более, что размер ThirdParty-исходников в 3 раза больше самого UE4.
Однако всё это звучит как жалкие попытки оправдаться :). Поэтому мне не остаётся ничего другого, как сравнять счёт. С этой целью были взяты исходники Unreal Engine 4 и проверены последней версией анализатора PVS-Studio.
И сейчас я продемонстрирую, что всегда можно легко найти ошибки в большом быстро меняющемся проекте.
Результаты проверки проекта с помощью PVS-Studio
------------------------------------------------
Я проверил исходные коды UE4 последней версией PVS-Studio. Проверялись исходные коды UE4 без учета каталога ThirdParty. Если я их проверю, у меня получится не статья, а справочник :).
Я получил 1792 предупреждения общего назначения первого и второго уровня. Не надо пугаться. Сейчас станет понятно, откуда взялось это число.
Большинство предупреждений (93%) связано с новым диагностическим правилом V730, предназначенным для выявления неинициализированных членов класса. Неинициализированный член класса — это не всегда ошибка, но тем не менее это то место в программе, которое стоит проверить. Вообще 1672 предупреждений V730 это много. На других проектах я не видел подобного количества этих предупреждений. Тем более, что анализатор по возможности пытается предугадать, когда неинициализированный член — это не страшно. Кстати, поиск неинициализированных членов — неблагодарная работа, и возможно читателям будет интересно познакомиться со статьёй "[Поиск неинициализированных членов класса](http://www.viva64.com/ru/b/0354/)".
Однако вернемся к проекту UE4. В статье я не буду касаться предупреждения [V730](http://www.viva64.com/ru/d/0377/). Их слишком много, и я слишком плохо знаю проект UE4, чтобы судить, может-ли привести та или иная неинициализированная переменная к ошибке в работе программы. Однако я уверен, что среди этих 1672 предупреждения скрывается немало настоящих серьезных ошибок. Думаю, разработчикам из Epic Games стоит проанализировать их. Если же они сочтут, что это сплошные ложные срабатывания, то тогда эту диагностику можно просто отключить.
Итак, 1792 — 1672 = 120. Итого PVS-Studio выдал 120 предупреждений общего назначения (1 и 2 уровень) при проверке Unreal Engine. Множество из этих предупреждений выявили настоящие ошибки. Рассмотрим наиболее интересные фрагменты кода и соответствующие им предупреждения.
Интересные ошибки, найденные с помощью PVS-Studio
-------------------------------------------------
Ещё раз подчеркну, что в статье я приведу далеко не все участки кода, которые заслуживают внимания и правки. Во-первых, я смотрел отчет бегло и мог пропустить что-то интересное. Во-вторых, я не выписывал несерьезные ошибки или те, которые сложно объяснить (требуется привести много фрагментов кода).
**Ошибка N1**
```
FORCEINLINE
bool operator==(const FShapedGlyphEntryKey& Other) const
{
return FontFace == Other.FontFace
&& GlyphIndex == Other.GlyphIndex
&& FontSize == Other.FontSize
&& FontScale == Other.FontScale
&& GlyphIndex == Other.GlyphIndex;
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions 'GlyphIndex == Other.GlyphIndex' to the left and to the right of the '&&' operator. fontcache.h 139
Два раза повторяется проверка «GlyphIndex == Other.GlyphIndex». [Эффект последней строки](http://www.viva64.com/ru/b/0260/) в действии. По всей видимости, последним сравнением должно быть: KeyHash == Other.KeyHash.
**Ошибка N2**
Ещё один эффект последней строки. Прямо-таки канонический.
```
bool
Compare(const FPooledRenderTargetDesc& rhs, bool bExact) const
{
....
return Extent == rhs.Extent
&& Depth == rhs.Depth
&& bIsArray == rhs.bIsArray
&& ArraySize == rhs.ArraySize
&& NumMips == rhs.NumMips
&& NumSamples == rhs.NumSamples
&& Format == rhs.Format
&& LhsFlags == RhsFlags
&& TargetableFlags == rhs.TargetableFlags
&& bForceSeparateTargetAndShaderResource ==
rhs.bForceSeparateTargetAndShaderResource
&& ClearValue == rhs.ClearValue
&& AutoWritable == AutoWritable;
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions to the left and to the right of the '==' operator: AutoWritable == AutoWritable rendererinterface.h 180
В самом конце забыли дописать «rhs.» и в результате переменная 'AutoWritable' сравнивается сама с собой.
**Ошибка N3**
```
void AEQSTestingPawn::PostLoad()
{
....
UWorld* World = GetWorld();
if (World && World->IsGameWorld() &&
bTickDuringGame == bTickDuringGame)
{
PrimaryActorTick.bCanEverTick = false;
}
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions to the left and to the right of the '==' operator: bTickDuringGame == bTickDuringGame eqstestingpawn.cpp 157
**Ошибка N4**
```
int32 SRetainerWidget::OnPaint(....) const
{
....
if ( RenderTargetResource->GetWidth() != 0 &&
RenderTargetResource->GetWidth() != 0 )
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions 'RenderTargetResource->GetWidth() != 0' to the left and to the right of the '&&' operator. sretainerwidget.cpp 291
**Ошибка N5, N6**
Две одинаковых ошибки расположились по соседству. Макросы ZeroMemory, которые есть не что иное как вызовы функции memset(), обнуляют только часть выделенной памяти.
```
class FD3D12BufferedGPUTiming
{
....
FD3D12CLSyncPoint* StartTimestampListHandles;
FD3D12CLSyncPoint* EndTimestampListHandles;
....
};
void FD3D12BufferedGPUTiming::InitDynamicRHI()
{
....
StartTimestampListHandles = new FD3D12CLSyncPoint[BufferSize];
ZeroMemory(StartTimestampListHandles,
sizeof(StartTimestampListHandles));
EndTimestampListHandles = new FD3D12CLSyncPoint[BufferSize];
ZeroMemory(EndTimestampListHandles,
sizeof(EndTimestampListHandles));
....
}
```
Предупреждения PVS-Studio:* V512 A call of the 'memset' function will lead to underflow of the buffer 'StartTimestampListHandles'. d3d12query.cpp 493
* V512 A call of the 'memset' function will lead to underflow of the buffer 'EndTimestampListHandles'. d3d12query.cpp 495
Ошибка в том, что оператор sizeof() вычисляет размер указателя, а не массива. Одним из правильных вариантов, будет написать так:
```
ZeroMemory(StartTimestampListHandles,
sizeof(FD3D12CLSyncPoint) * BufferSize);
ZeroMemory(EndTimestampListHandles,
sizeof(FD3D12CLSyncPoint) * BufferSize);
```
**Ошибка N7**
```
void FDeferredShadingSceneRenderer::RenderLight(....)
{
....
if (bClearCoatNeeded)
{
SetShaderTemplLighting(
RHICmdList, View, \*VertexShader, LightSceneInfo);
}
else
{
SetShaderTemplLighting(
RHICmdList, View, \*VertexShader, LightSceneInfo);
}
....
}
```
Предупреждение PVS-Studio: V523 The 'then' statement is equivalent to the 'else' statement. lightrendering.cpp 864
В независимости от условия, выполняются одинаковые действия.
**Ошибка N8**
```
bool FBuildDataCompactifier::Compactify(....) const
{
....
uint64 CurrentFileSize;
....
CurrentFileSize = IFileManager::Get().FileSize(*File);
if (CurrentFileSize >= 0)
{
....
}
else
{
GLog->Logf(TEXT("Warning. ......"), *File);
}
....
}
```
Предупреждение PVS-Studio: V547 Expression 'CurrentFileSize >= 0' is always true. Unsigned type value is always >= 0. buildpatchcompactifier.cpp 135
Проверка «if (CurrentFileSize >= 0)» не имеет смысла. Переменная 'CurrentFileSize' имеет беззнаковый тип, а значит её значение всегда >= 0.
**Ошибка N9**
```
template
void UnsetParameters(....)
{
....
int32 NumOutUAVs = 0;
FUnorderedAccessViewRHIParamRef OutUAVs[3];
OutUAVs[NumOutUAVs++] = ObjectBuffers......;
OutUAVs[NumOutUAVs++] = ObjectBuffers.Bounds.UAV;
OutUAVs[NumOutUAVs++] = ObjectBuffers.Data.UAV;
if (CulledObjectBoxBounds.IsBound())
{
OutUAVs[NumOutUAVs++] = ObjectBuffers.BoxBounds.UAV;
}
....
}
```
V557 Array overrun is possible. The 'NumOutUAVs ++' index is pointing beyond array bound. distancefieldlightingshared.h 388
Если условие (CulledObjectBoxBounds.IsBound()) выполнится, то произойдёт выход за границы массива. Обратите внимание, что массив 'OutUAVs' состоит только из 3 элементов.
**Ошибка N10**
```
class FSlateDrawElement
{
....
FORCEINLINE void SetPosition(const FVector2D& InPosition)
{ Position = Position; }
....
FVector2D Position;
....
};
```
Предупреждение PVS-Studio: V570 The 'Position' variable is assigned to itself. drawelements.h 435
Эту ошибку даже описывать не нужно. Опечатка. Должно быть: { Position = InPosition; }.
**Ошибка N11**
```
bool FOculusRiftHMD::DoesSupportPositionalTracking() const
{
const FGameFrame* frame = GetFrame();
const FSettings* OculusSettings = frame->GetSettings();
return (frame && OculusSettings->Flags.bHmdPosTracking &&
(OculusSettings->SupportedTrackingCaps &
ovrTrackingCap_Position) != 0);
}
```
Предупреждение PVS-Studio: V595 The 'frame' pointer was utilized before it was verified against nullptr. Check lines: 301, 302. oculusrifthmd.cpp 301
Сначала переменная 'frame' используется, а затем проверяется на равенство nullptr.
Эта ошибка очень схожа с той, что описана в [статье](http://blog.klocwork.com/static-analysis/analysis-of-unreal-engine-4/) Klocwork:
```
bool FHeadMountedDisplay::IsInLowPersistenceMode() const
{
const auto frame = GetCurrentFrame();
const auto FrameSettings = frame->Settings;
return frame && FrameSettings->Flags.bLowPersistenceMode;
}
```
Как видите, оба анализатора умеют выявлять данный вид дефекта.
Стоит отметить, что код приводимый в статье Klocwork, относится к каталогу ThirdParty, проекты из которого мы не проверяли.
**Ошибка N12 — N21**
```
FName UKismetNodeHelperLibrary::GetEnumeratorName(
const UEnum* Enum, uint8 EnumeratorValue)
{
int32 EnumeratorIndex = Enum->GetIndexByValue(EnumeratorValue);
return (NULL != Enum) ?
Enum->GetEnum(EnumeratorIndex) : NAME_None;
}
```
Предупреждение PVS-Studio: V595 The 'Enum' pointer was utilized before it was verified against nullptr. Check lines: 146, 147. kismetnodehelperlibrary.cpp 146
Опять ситуация, когда в начале указатель разыменован, и только затем проверен. Рассматривать такие ошибки дальше скучно. Просто приведу списком места, на которые стоит обратить внимание:* V595 The 'Class' pointer was utilized before it was verified against nullptr. Check lines: 278, 282. levelactor.cpp 278
* V595 The 'Template' pointer was utilized before it was verified against nullptr. Check lines: 380, 386. levelactor.cpp 380
* V595 The 'UpdatedComponent' pointer was utilized before it was verified against nullptr. Check lines: 100, 116. interptomovementcomponent.cpp 100
* V595 The 'SourceTexture' pointer was utilized before it was verified against nullptr. Check lines: 150, 178. d3d12rendertarget.cpp 150
* V595 The 'NewRenderTarget' pointer was utilized before it was verified against nullptr. Check lines: 922, 924. d3d11commands.cpp 922
* V595 The 'RenderTarget' pointer was utilized before it was verified against nullptr. Check lines: 2173, 2175. d3d11commands.cpp 2173
* V595 The 'MyMemory' pointer was utilized before it was verified against nullptr. Check lines: 210, 217. bttask\_moveto.cpp 210
* V595 The 'SkelComp' pointer was utilized before it was verified against nullptr. Check lines: 79, 100. animnode\_animdynamics.cpp 79
* V595 The 'Result' pointer was utilized before it was verified against nullptr. Check lines: 1000, 1004. uobjectglobals.cpp 1000
**Ошибка N22**
```
class FD3D12Device
{
....
virtual void InitD3DDevice();
virtual void CleanupD3DDevice();
....
// Деструктор не объявлен
....
};
```
V599 The virtual destructor is not present, although the 'FD3D12Device' class contains virtual functions. d3d12device.cpp 448
В классе FD3D12Device имеются виртуальные методы. Это значит, что предполагается, что у этого класса будут наследники. Однако в этом классе отсутствует виртуальный деструктор. Это очень опасно и скорее всего рано или поздно приведёт к ошибке.
**Ошибка N23-N26**
```
int SpawnTarget(WCHAR* CmdLine)
{
....
if(!CreateProcess(....))
{
DWORD ErrorCode = GetLastError();
WCHAR* Buffer = new WCHAR[wcslen(CmdLine) + 50];
wsprintf(Buffer,
L"Couldn't start:\n%s\nCreateProcess() returned %x.",
CmdLine, ErrorCode);
MessageBoxW(NULL, Buffer, NULL, MB_OK);
delete Buffer;
return 9005;
}
....
}
```
Предупреждение PVS-Studio: V611 The memory was allocated using 'new T[]' operator but was released using the 'delete' operator. Consider inspecting this code. It's probably better to use 'delete [] Buffer;'. bootstrappackagedgame.cpp 110
Неправильным способом освобождается выделенная память. Должно быть написано:
```
delete [] Buffer;
```
Есть ещё несколько таких ошибок:* V611 The memory was allocated using 'new T[]' operator but was released using the 'delete' operator. Consider inspecting this code. It's probably better to use 'delete [] ChildCmdLine;'. bootstrappackagedgame.cpp 157
* V611 The memory was allocated using 'new T[]' operator but was released using the 'delete' operator. Consider inspecting this code. It's probably better to use 'delete [] ChildCmdLine;'. bootstrappackagedgame.cpp 165
* V611 The memory was allocated using 'new T[]' operator but was released using the 'delete' operator. Consider inspecting this code. It's probably better to use 'delete [] ChildCmdLine;'. bootstrappackagedgame.cpp 169
**Ошибка N27**
```
void FSlateTexture2DRHIRef::InitDynamicRHI()
{
....
checkf(GPixelFormats[PixelFormat].BlockSizeX ==
GPixelFormats[PixelFormat].BlockSizeY ==
GPixelFormats[PixelFormat].BlockSizeZ == 1,
TEXT("Tried to use compressed format?"));
....
}
```
Предупреждение PVS-Studio: V709 Suspicious comparison found: 'a == b == c'. Remember that 'a == b == c' is not equal to 'a == b && b == c'. slatetextures.cpp 67
Проверка работает совсем не так, как задумывал программист. По всей видимости следовало написать:
```
GPixelFormats[PixelFormat].BlockSizeX == 1 &&
GPixelFormats[PixelFormat].BlockSizeY == 1 &&
GPixelFormats[PixelFormat].BlockSizeZ == 1
```
**Ошибка N28**
```
void UWidgetComponent::UpdateRenderTarget()
{
....
FLinearColor ActualBackgroundColor = BackgroundColor;
switch ( BlendMode )
{
case EWidgetBlendMode::Opaque:
ActualBackgroundColor.A = 1.0f;
case EWidgetBlendMode::Masked:
ActualBackgroundColor.A = 0.0f;
}
....
}
```
V519 The 'ActualBackgroundColor.A' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 938, 940. widgetcomponent.cpp 940
Здесь косвенным образом выявлен пропущенный оператор 'break'. Переменной 'ActualBackgroundColor.A' два раза подряд могут быть присвоены разные значения. Это и настораживает анализатор PVS-Studio.
**Ошибка N29**
```
void FProfilerManager::TrackDefaultStats()
{
// Find StatId for the game thread.
for( auto It = GetProfilerInstancesIterator(); It; ++It )
{
FProfilerSessionRef ProfilerSession = It.Value();
if( ProfilerSession->GetMetaData()->IsReady() )
{
....;
}
break;
}
}
```
Предупреждение PVS-Studio: V612 An unconditional 'break' within a loop. profilermanager.cpp 717
Очень подозрительный код. Кажется, оператор 'break' расположен не на своём месте. Я не уверен, но возможно планировалось написать так:
```
for( auto It = GetProfilerInstancesIterator(); It; ++It )
{
FProfilerSessionRef ProfilerSession = It.Value();
if( ProfilerSession->GetMetaData()->IsReady() )
{
....;
break;
}
}
```
Итоги
-----
По крайней мере 29 предупреждений из 120, выданных PVS-Studio указали на настоящие ошибки (24%). Ещё около 50%, это код, который пахнет. Оставшееся — ложные срабатывания. Суммарное затраченное мной время на проверку проекта и написание этой статьи — около 10 часов.
Какие выводы можно сделать по результатам работы анализаторов PVS-Studio и Klocwork:1. В большом и быстро развивающемся проекте всегда можно найти ещё немножко ошибок :)
2. Наборы диагностик PVS-Studio и Klocwork различаются, хотя и есть пересечение.
3. Возможно, Klocwork проверял Unreal Engine 4, включая сторонние библиотеки (ThirdParty). Мы ни тогда, ни сейчас эти библиотеки не проверяли.
4. Оба анализатора молодцы, и их использование может приносить массу пользы процессу разработки программ.
Спасибо всем за внимание.
[](http://www.viva64.com/en/b/0356/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [The Empire Strikes Back](http://www.viva64.com/en/b/0356/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/270783/ | null | ru | null |
# Как устроены технические индикаторы на фондовых рынках
Любой кто когда-нибудь интересовался фондовыми или криптовалютными рынками видел эти дополнительные линии. И вы наверно слышали мнения от матерых трейдеров о том, что они не работают и как они не используют ничего. Но многим они очень помогают и мой торговый терминал, в который я лениво смотрю раз в день, выглядит примерно как на картинке ниже.
Как же все таки они устроены? И кому это может быть полезно? Вам определенно с этим следует ознакомиться, если:
1. Вы ими пользуетесь в своей торговле
2. Вы планируете написать торгового робота
3. Вы хотите реализовать торговую стратегию сами
Технический индикатор, это чаще всего оконная, весовая или рекуррентная функция от цен и объемов, которые приходят с биржи в формате массива свеч TOHLCV (unix time, open, high, low, close, volume). Так же могут использоваться различные фильтрации, максимумы-минимумы или другие индикаторы как основа для последующих вычислений.
**Скользящая средняя (SMA)**
При реализации индикаторов очень удобно использовать функциональный подход программирования. Например, скользящая средняя, это всего лишь среднее значение от каждого значения скользящей оконной функции на цене закрытия
```
function sma($close, window) {
return rolling(x => mean(x), window, $close);
}
```
где функция mean() это среднее значение, параметр window — размер окна, а rolling() это комбинация оконной функции, которая для каждой текущей ячейки массива выдает массив из последних n элементов, и операции, которая сворачивает окно в число.
```
function rolling(operation, window, array) {
let result = [];
for (let i = 0; i < array.length; i++) {
if (i + 1 < window) {
result.push(NaN);
} else {
result.push(operation(array.slice(i + 1 - window, i + 1)));
}
}
return result;
}
```
Скользящая средняя является запаздывающим индикатором и помогает определить тренд. Она рисуется наложением поверх графика цен и первые значения обычно обычно отбрасываются.
Обычно рассматривают пару индикаторов и точка, когда индикатор с коротким окном пересекает индикатор с длинным окном снизу рассматривается как потенциальная точка входа, и сверху — выхода. На практике чаще используют экспоненциально взвешенную скользящую среднюю, применяя весовую оконную функцию, что бы уменьшить эффект запаздывания.
**Среднеквадратичное отклонение (STDEV)**
Если мы заменим в предыдущем варианте функцию mean() на корень из дисперсии sd(), то получим уже скользящее среднеквадратичное отклонение.
```
function stdev($close, window) {
return rolling(x => sd(x), window, $close);
}
```
Дисперсия считается обычным всем известным способом, чаще всего без коррекции Бесселя. Так же используется именно корень из дисперсии, так как сама дисперсия измеряется в квадратных рублях/долларах.
**Полосы Боллинджера (BB)**
Таким образом мы уже получили два базовых индикатора, которые уже можно комбинировать и получать новые. Например, если поточечно сложить скользящую среднюю и среднеквадратичное отклонение, при этом домножив на 2, то мы получим верхнюю часть полосы Боллинджера, а если вычесть — нижнюю.
В коде это будет выглядеть так
```
function bb($close, window, mult) {
let middle = sma($close, window);
let upper = pointwise((a, b) => a + b * mult, middle, stdev($close, window));
let lower = pointwise((a, b) => a - b * mult, middle, stdev($close, window));
return { lower : lower, upper : upper};
}
```
где функция pointwise, ничего другого не делает, кроме как поэлементно собирает из двух массивов один, используя данную ей операцию.
Полосы Боллинджера помогают определить затишье перед большим движением цены, и используются как инструмент для удобного отображения волатильности на графике, среднеквадратичное отклонение не отобразить наложением на одном графике с ценой, поэтому его удобно откладывать от скользящей средней.
**Примечание**
У этого индикатора есть один недостаток — он использует экспоненциально взвешенные функции. Как упражнение, можете попробовать самостоятельно его преобразовать, не забывайте учитывать, что стандартное отклонение тоже нужно высчитывать экспоненциально взвешенно.
**Экспоненциально взвешенная скользящая средняя (EMA)**
Как можно уменьшить запаздывание скользящей средней? Так как при ее вычислении складывается n последних цен закрытия, можно понять что складывать можно с каким то весом, уменьшая вклад старых цен. Таким образом мы приходим к формуле взвешенной оконной функции.
если  и выбрать какую то константу  меньше единицы, то мы получим бесконечно убывающий вес, если при этом складывать цены начиная с самой новой.
Можно значительно упростить вычисления, если не учитывать вклад *хвостов*. Расширив размер окна на всю длину можно получить рекурсивное определение.
![$ 1+q+q^2+...+q^n \underset{n\to \infty}{\underset{q < 0}{\approx}} \frac{1}{1-q}\\ \mathrm{EMA}_{curr} = \frac{\sum x_i q^i}{\sum q^i} \approx (1-q) \sum x_i q^i\\ \mathrm{EMA}_{next} = \frac{x_{next} +q \cdot \sum x_i q^i}{1 + q \cdot \sum q^i} = (1-q) \cdot \left[x_{next}+q \cdot \sum x_i q^i\right]\\ \mathrm{EMA}_{next} = (1-q) \cdot x_{next} + q \cdot \mathrm{EMA}_{curr}$](https://habrastorage.org/getpro/habr/formulas/82a/898/b17/82a898b176461bfcc27579d7b7902f01.svg)
В итоге нам нужно выбрать какое то значение  как константу сглаживания. [Можно показать](https://en.wikipedia.org/wiki/Moving_average#Relationship_between_SMA_and_EMA), что если взять  центр масс у весовых графиков EMA и SMA выше становится одинаковым. В коде все это выглядит намного проще.
```
function ema($close, window, weight = null) {
weight = weight ? weight : 2 / (window + 1);
let ema = [ mean($close.slice(0, window)) ];
for (let i = 1; i < $close.length; i++) {
ema.push($close[i] * weight + ema[i - 1] * (1 - weight));
};
return ema;
}
```
В целом эта та же скользящая средняя, но более чувствительная.
Эффективность использования зависит от вашего опыта и используемых настроек. Например на [данном](https://cryptowat.ch/) сайте довольно удачно подобраны параметры.
**Cхождение/расхождение скользящих средних (MACD)**
Джеральд Аппель в 1979 году придумал один из самых простых и в то же время эффективных осцилляторов ценовых моментов. Он преобразует два трендовых индикатора EMA в индикатор моментов, беря из двух миров лучшее. То есть он, грубо говоря, находит производную. Рисуется он в отдельном окне двумя линиями и гистограммой, а не наложением, как предыдущие. На самом деле индикаторов которые рисуются в отдельном окне значительно больше, но об этом может быть как нибудь в другой раз.
Формула расчета довольно простая, берутся две ema с динным и коротким окном, например в 26 и 12 единицы, и вычитаются, полученная линия и будет искомым индикатором. Взяв от этой разности еще одну ema c шагом в 3 единицы получим сигнальную линию. Гистограмма, которую Джеральд добавил позже высчитывается разницей между двумя предыдущими результатами и по сути является средневзвешенной производной.
```
function macd($close, wshort, wlong, wsig) {
let line = pointwise((a, b) => a - b, ema($close, wshort), ema($close, wlong));
let signal = ema(line, wsig);
let hist = pointwise((a, b) => a - b, line, signal);
return { line : line, signal : signal, hist : hist };
}
```
**Тестирование индикаторов, нормированная среднеквадратичная ошибка**
Имея точные таблицы со значением индикаторов, можно качественно протестировать ваш расчет. Существуют различные способы определения меры ошибки между двумя функциями, но практика показала что нормированная среднеквадратичная ошибка, которая считается как
лучше всего работает, как при малых величинах, так и при больших. Например биткоин в долларах может стоить 20000$ и разница в 10$ не критична, в то же время один альткоин может исчисляться несколькими сатошами.
```
function nrmse(f, g) {
let sqrDiff = pointwise((a, b) => (a - b) * (a - b), f, g);
return Math.sqrt(mean(sqrDiff)) / (Math.max(...f) - Math.min(...f));
}
```
**Заключение**
Так в несколько строчек можно выразить базовые индикаторы, если вы планируете выполнять их анализ машинным обучением, то для определения идеальных точек входа советую обратить внимания на индикатор ZigZag, который не является полезным для торговли, но исключительно полезен в качестве учителя. Следует так же учитывать, что вам для торговли нужно выбирать максимально не похожие друг на друга идикаторы и пробовать изменять их входные параметры. Можно попробовать автоматически изменять их во времени, так как максимально эффективным параметрам свойственно изменятся.
**Используемые источники**
1. [StockCharts](https://stockcharts.com/school/doku.php?id=chart_school:technical_indicators) — cписок алгоритмов с проверочными данными в таблицах
2. [Cryptowatch](https://cryptowat.ch/) — хорошо настроенные параметры индикаторов
3. [Github](https://github.com) — исходный код | https://habr.com/ru/post/419239/ | null | ru | null |
# Перепиливаем JDBC DB2 под .NET
В очень странное время мы живем .NET становится кроссплатформенным, JAVA становится слаще. Но пока мы вместе движемся в общее светлое будущее есть много унаследованных решений которые необходимо поддерживать. И пока это удается с помощью лобзика и напильника…
### Прежде чем
В текущий момент в драйвере поддерживается только тот функционал, который необходим в наших проектах. Вы всегда можете присоединится к проекту [Wintegra.Data](https://github.com/Wintegra/Wintegra.Data)
### История
(для нетерпеливых можно сразу переходить к пункту [Пилим](#Description))
Хотя в последнее время реляционные базы данных как-то не в хайпе и всем подавай CAP системы – быстрые, удобные, иногда консистентные и масштабируемые. И всё же интерпрайз живет на старых и проверенных решениях, одним из который является база данных от «Голубого гиганта» — IBM и имя ей [DB2](https://en.wikipedia.org/wiki/IBM_DB2).
В меру быстрая, надежная, не хуже и не лучше, чем Oracle и MS SQL. Что-то есть, чего-то нет, но в общем SQL нотацию поддерживает (хотя и без обиды на собачек не обошлось @)
Для работы со своей базой под .NET IBM поставляет ODBC драйвер, в общем-то не плохой, но использующий маленькую тележку нативного кода.
С другой стороны, под JAVA есть полностью работающий драйвер без какого-либо использования сторонних dll, имя ему JCC (JDBC 4.0 Driver (db2jcc4.jar)).
И не понятно, что мешает IBM реализовать «правильный» дайвер под .NET.
Поскольку .NET Core не за горами, а переписывать тонны кода под JAVA с C# выглядит более чем странно, то почему не убить двух зайцев – оставить код, и использовать драйвер JDBC.
Для начала воспользуемся [IKVM.NET](https://ru.wikipedia.org/wiki/IKVM.NET) для конвертирования jar в dll и будем его использовать в .NET. Автор утверждает, что можно спокойно запускать [Minecraft](http://weblog.ikvm.net/2014/12/01/RunningMinecraftOnIKVMNET.aspx). Так что JDBC драйвер не вызвал ни каких проблем.
Создать необходимую библиотеку достаточно просто выполнив команду:
```
ikvmc.exe -classloader:ikvm.runtime.AppDomainAssemblyClassLoader -target:library db2jcc4.jar db2jcc_license_cu.jar -out:db2jcc4.dll
```
Теперь всё что нам надо, это подключить созданную dll к своему решению и использовать её.
**JAVA код в .NET**
```
using System;
using com.ibm.db2.jcc;
using java.sql;
using Thread = java.lang.Thread;
using Class = java.lang.Class;
using String = System.String;
using Connection = java.sql.Connection;
using Statement = java.sql.Statement;
using DriverManager = java.sql.DriverManager;
using ResultSet = java.sql.ResultSet;
namespace jdbc
{
class Program
{
static void Main(string[] args)
{
Class.forName(
typeof(com.ibm.db2.jcc.DB2Driver).AssemblyQualifiedName, true,
Thread.currentThread().getContextClassLoader());
String url = "jdbc:db2://192.168.72.135:50000/DB1:user=root;password=password;";
using (Connection conn = DriverManager.getConnection(url))
{
String sql = "SELECT * FROM TABLE(VALUES( CAST( :p AS VARCHAR(100)) , 'It is work')) AS T(ID, LOG)";
using (var stmt = conn.prepareCall(sql))
{
stmt.setString("p","1234");
using (ResultSet rs = stmt.executeQuery())
{
while (rs.next())
{
//Retrieve by column name
String id = rs.getString("ID");
String log = rs.getString("LOG");
global::System.Console.WriteLine("LOG: " + id + " : " + log);
}
}
}
}
}
}
}
```
Однако не думаю, что разработчики .NET оценят синтаксис в виде java.lang.\*, а вспомнив про унаследованные проекты, которые явно работают как минимум поверх IDbConnetion и часто через [Dapper](https://en.wikipedia.org/wiki/Dapper_ORM), наш результат может быть интересен только в качестве факультативного развлечения.
### Пилим
Подготовив лобзик и напильник будем делать свой велосипед, уж на сколько нам он нужен.
```
public sealed class Db2Connection : DbConnection, ICloneable
```
Вполне достаточно для создания подключения и работы Dapper-ом.
**Db2Connection****Немного магии из мира JAVA**
```
static Db2Connection()
{
Class.forName(
typeof(com.ibm.db2.jcc.DB2Driver).AssemblyQualifiedName, true,
Thread.currentThread().getContextClassLoader());
}
```
Мы загружаем JDBC драйвер, почти так же как в JAVA как
```
Class.forName("com.ibm.db2.jcc.DB2Driver");
```
**Соединение с базой данных** – один в один из JAVA:
```
connector = DriverManager.getConnection(_connectionString);
```
Стоит отметить, что строка подключения такая же как в JDBC (хотя по надобности можно использовать Db2ConnectionStringBuilder для задания своих или совместимых в ODBC параметров).
```
jdbc:db2://192.168.72.135:50000/DB1:currentSchema=DB01;user=root;password=password;fullyMaterializeLobData=true;DB2NETNamedParam=1;
```
Подключение к серверу, порт, база данных, схема, логин и пароль. Для настройки можно заглянуть на сайт «Голубого гиганта» [URL format for IBM Data Server Driver for JDBC and SQLJ type 4 connectivity](http://www.ibm.com/support/knowledgecenter/en/SSEPEK_10.0.0/com.ibm.db2z10.doc.java/src/tpc/imjcc_r0052342.html).
Вроде всё, что могло быть интересным…
Для нанесения выгоды в базу данных нужны команды, нужно – делаем:
```
public sealed class Db2Command : DbCommand, ICloneable
```
Где пришлось повозится так это с Dapper-ом.
**Db2Command****Dapper упорно заменяет параметр :XML\_BODY типа XmlDocument** на невнятное (:XML\_BODY1, :XML\_BODY2) – пришлось написать не сложную регулярочку.
```
new Regex(@"\(:(?\w+)\d+,:\1\d+\)");
```
Хотя да, можно было напилить TypeHandler, для любознательных [Dapper — ulong throwing System.ArgumentException](http://www.codegur.site/32991877/dapper-ulong-throwing-system-argumentexception). Но во-первых обертка над ODBC уже работала с XmlDocument, а во-вторых использование магических команд вида, в начале приложения:
```
SqlMapper.AddTypeHandler(DapperULongHandler.Default);
```
всегда чревата ошибками.
### Магический метод номер раз
```
internal static CallableStatement PrepareExecute(Db2Connection connection, string query, Db2ParameterCollection parameters)
```
Возвращает подготовленный к выполнению запрос.
Особого внимания заслуживает объяснение использования prepareCall (*CallableStatement*) в место prepareStatement (*PreparedStatement*). Использование позиционных параметров проще, но в ряде случаев не удобно, использование именованных требует некоторой дополнительной работы, что снижает быстро действие и увеличивает сложность кода. Предпочтение было отдано именованным параметрам, поскольку с ними проще отлаживать уходящие на сервер запросы и даёт бонус в случае когда выполняется мульти запрос.
Для своей магии использует два других.
### Магический метод номер два
```
internal static string PrepareCommandText(string query, Db2ParameterCollection parameters, ref int parameter)
```
Заменяет позиционные параметры на именованные.
Небольшой обман Dapper-а обошелся аж в два goto. И хотя можно было обойтись без них, но решение простое и оставлено как удовлетворительное.
*ref int parameter* — понадобиться для Db2DataReader и реализации мульти запросов.
### Последний магический метод
```
private static void PrepareParameters(CallableStatement stmt, Db2ParameterCollection parameters)
```
Устанавливает параметры.
Развесистый if и вызов множества методов stmt.setXXX(name,
Для команд нужны параметры:
```
public sealed class Db2ParameterCollection : DbParameterCollection, IList
```
```
public sealed class Db2Parameter : DbParameter, ICloneable
```
**Db2Parameter****Для Dapper-а** необходимо немного поколдовать над методом:
```
public override DbType DbType
```
так как он используется для приведения типов, в остальном реализуем интерфейс.
И необходимо очень внимательно отнестись к методу:
```
public object Clone()
```
Поскольку нам нужно создавать копии параметров при мульти запросах.
**Db2ParameterCollection**Заслуживает внимание только из-за наличия небольшой оптимизации метода:
```
public override int IndexOf(string parameterName)
```
в остальном ни чего существенного.
И в завершении:
```
internal sealed class Db2DataReader : DbDataReader
```
Реализующий выполнение мульти запросов через JDBC.
**Db2DataReader**Возможно это не самое лучшее решение, но почему нет.
**Во-первых**, необходимо разбить запрос на подзапросы. Ни каких неожиданностей простое регулярное выражение
```
new Regex(@"(?[^;]+);?");
```
**Во-вторых**, необходимо подготовить для каждого из подзапросов свой набор параметров. Воспользуемся
```
new Regex(@"(?:\w+)");
```
и уже знакомым методом Db2Command.PrepareCommandText для замены позиционных параметров на их именованные (как бонус: Dapper может нормально отрабатывать именованные параметры в мульти запросах).
**В-третьих**, небольшой хак в public override bool NextResult(), для перехода от одной команды к следующей.
```
var b = _statement.getMoreResults();
if (b)
{
_rs = _statement.getResultSet();
}
else
{
_statement = PrepareStatementAndResultSet();
if (_statement != null)
{
_rs = _statement.executeQuery();
b = true;
}
}
```
### Итоги
Конечно пока проект не завершен, но в будущем есть желание заменить реализацию оболочки над db2jcc4.jar на «нормальную» реализацию драйвера под .NET без лишних приседаний.
Для чего может понадобиться?
Ну, во-первых, можно не ставить ODBC драйвер на машину пользователя, хотя да в объеме вы не выиграете.
Во-вторых, можно потихоньку перенести свой backend на linux с mono. Что очень удобно при небольшой шепотке [Docker-а](https://ru.wikipedia.org/wiki/Docker)
И конечно не много для фана, да прибудет с вами многосложный запрос:
**SELECT**
```
SELECT
r.ID
, r.INCOME
, r.GU_CODE as GuCode
, r.NO as No
, r.DIVISION
, d.NAME as DivisionName
, u.LNAME || ' ' || u.FNAME || nvl(' ' || u.MNAME, '') as CreaterName
, r.SIGNED
, r.SIGNED_SYSUSER_ID as SignedID
, su.LNAME || ' ' || su.FNAME || nvl(' ' || su.MNAME, '') as SignedName
--, (select count(*) from PACK_ENTRY p where p.REGISTRY_ID = r.ID) as PackCount -- Use C# code
--, (select count(*)
-- from PACK_ENTRY p
-- join FILE_ENTRY f on f.PACK_ID=p.ID
-- where p.REGISTRY_ID = r.ID) as FileCount -- Use C# code
-- TODO 2016-04-13 emiya: Добавить доп.поля для включения информции в таблицу REGISTRY_ENTRY
, (select p.CLOSE_DATE from PACK_ENTRY p join REGISTRY_TO_PACK p2p on p2p.REGISTRY_ID = r.ID and p2p.PACK_ID = p.ID order by p.INCOME fetch first 1 rows only) as CloseDate
, (select p.CATEGORY_ID from PACK_ENTRY p join REGISTRY_TO_PACK p2p on p2p.REGISTRY_ID = r.ID and p2p.PACK_ID = p.ID order by p.INCOME fetch first 1 rows only) as CategoryCode
, (select l.SHORTNAME from PACK_ENTRY p
join CATEGORY_LIST l on l.ID = p.CATEGORY_ID
join REGISTRY_TO_PACK p2p on p2p.REGISTRY_ID = r.ID and p2p.PACK_ID = p.ID
order by p.INCOME fetch first 1 rows only) as CategoryName
, p2p.REGISTRY_ID
, p.ID
, p.INCOME
, p.CLOSE_DATE as CloseDate
, p.CATEGORY_ID as CategoryCode
, l.SHORTNAME as CategoryName
, p.GU_CODE as GuCode
, p.NO
, p.DIVISION
, p.SYSUSER_ID as SysUserID
, (select count(*) from FILE_ENTRY where PACK_ID = p.ID) as Count
, r.SIGNED
, p.PLACE
, p2p.STATUS
, p2p.NOTE
from REGISTRY_ENTRY r
join DIVISION d on d.CODE=r.DIVISION
join SYSUSER u on u.ID=r.SYSUSER_ID
LEFT JOIN SYSUSER su ON su.ID=r.SIGNED_SYSUSER_ID
join REGISTRY_TO_PACK p2p on p2p.REGISTRY_ID = r.ID
join PACK_ENTRY p on p.ID = p2p.PACK_ID
join CATEGORY_LIST l on l.ID = p.CATEGORY_ID
WHERE r.ID=? AND @DIVISION
order by r.ID,p.GU_CODE,p.NO
```
Ссылка на пакет в [NuGet](https://www.nuget.org/packages/Wintegra.JDBC/). | https://habr.com/ru/post/303878/ | null | ru | null |
# VPN везде и всюду: IPsec без L2TP со strongSwan
*достаточно сильный лебедь*
Если вы когда-либо искали VPN, который будет работать на десктопах, мобильных устройствах и роутерах без установки дополнительного ПО и перепрошивки роутера, вы, вероятно, выбирали между PPTP и L2TP+IPsec. У протокола PPTP имеются проблемы с безопасностью и прохождением через брандмауеры и NAT, так что в 2015 году его уже использовать не стоит, а использование L2TP излишне, т.к. L2 VPN, по моему мнению, для обычного удаленного доступа не нужен практически никогда.
Удивительно, что в интернете не так-то просто можно найти информацию о настройке чего-то помимо L2TP+IPsec в транспортном режиме, учитывая, что это обширный стек протоколов, который можно конфигурировать буквально как душе угодно, поэтому я попытаюсь устранить такое несовершенство мира.
### Небольшое введение в мир IPsec
Вообще говоря, не совсем правильно называть IPsec VPN. IPsec не предназначен для построения «виртуальных частных сетей», а создан для шифрования или защиты от подмены передаваемых по IP данных. Это специальный слой поверх IP, который, в зависимости от режима и настроек, работает по-разному. В отличие от привычного VPN, который создает новый интерфейс в системе, на который вы, как это чаще всего бывает, назначаете IP-подсеть из диапазона частных адресов (т.е. создаете новый сетевой сегмент), и через который маршрутизируется трафик в зашифрованном виде, IPsec просто шифрует трафик магическим образом между «внешними» интерфейсами сервера и клиента.
В современном IPsec используются:
* **Authentication Header (AH)** — протокол, обеспечивающий аутентификацию отправителя и целостность данных. Подписывает не только данные пакета, но и все заголовки, кроме изменяемых полей (ToS, TTL, чексумма).
* **Encapsulating Security Payload (ESP)** — протокол, обеспечивающий аутентификацию, целостность и конфиденциальность
* **Security Association (SA)** — параметр с настройками шифрования канала
* **Internet Key Exchange (IKE и IKEv2)** — протокол обмена параметрами, настройками и согласования SA
AH и ESP — транспортные протоколы, инкапсулируемые прямо в IP, имеющие собственные значение для поля Protocol в IP-заголовке. В современном мире, где NAT стоит за NAT у NAT с NAT'ом, следует использовать что-то более привычное, поэтому сейчас повсеместно используется инкапсуляция ESP-пакетов в UDP. AH не поддерживает работу через NAT.
Сам IPsec поддерживает работу в двух режимах:
* **Транспортный режим**. Подписывает заголовки и данные (если AH) или подписывает и шифрует данные (если ESP) пакета. Не скрывает IP-адрес получателя пакета, если он маршрутизируется. Этот режим используется для связки L2TP+IPsec.
* **Туннельный режим**. Подписывает (если AH) и еще шифрует (если ESP) **весь пакет**.
Протокол IKE позволяет проводить аутентификацию клиента с использованием X.509-сертификатов, Pre-Shared Key и Extensible Authentication Protocol (EAP). Поддерживается двухэтапная аутентификация.
Все современные десктопные ОС (Windows Vista/7/8/8.1, OS X, Linux), мобильные устройства (Android, iOS, Windows Phone, Blackberry) и некоторые роутеры поддерживают VPN с использованием IPsec ESP в туннельном режиме и его настройкой через протокол Internet Key Exchange (IKE) версии 1 или 2, а значит IPsec мы именно так и будем настраивать.
Кстати, писать правильно IPsec, но Cisco IP**S**ec.
### IPsec в Linux
Сам IPsec (AH/ESP, SA) работает в ядре, поэтому нам нужен IKE-демон для передачи настроек подключающимся клиентам. Их довольно много, но полноценных и активных на данный момент всего два: [strongSwan](http://strongswan.org/) и [libreswan](https://libreswan.org/). Вторым я не пользовался, ничего сказать о нем не могу, зато первый — прекрасный и удивительный, к тому же, это единственный демон, у которого есть своя userspace-реализация IPsec, поэтому его можно использовать в контейнерах OpenVZ со старым, как динозавры, ядром 2.6.32 с поломанной поддержкой маршрутизации IPsec.**Немного об IPsec в OpenVZ**В OpenVZ есть поддержка IPsec, и она вполне себе годна для запуска L2TP+IPsec, но там что-то явно не так с маршрутизацией на не-локальные интерфейсы. Вероятно, это можно починить добавлением пары правил на хостовую машину, но это довольно проблематично, если у вас нет доступа к ней, как бывает во подавляющем большинстве случаев. Поэтому для OpenVZ необходимо использовать userspace IPsec, который можно собрать параметром --enable-kernel-libipsec
Упоминания о баге:
[lists.strongswan.org/pipermail/users/2014-February/005822.html](https://lists.strongswan.org/pipermail/users/2014-February/005822.html)
[bugzilla.redhat.com/show\_bug.cgi?id=1081804](https://bugzilla.redhat.com/show_bug.cgi?id=1081804)
[forum.openvz.org/index.php?t=tree&goto=39937](http://forum.openvz.org/index.php?t=tree&goto=39937)
[lowendtalk.com/discussion/33226/need-someone-to-test-ipsec-on-their-boxes](http://lowendtalk.com/discussion/33226/need-someone-to-test-ipsec-on-their-boxes)
Нам потребуется strongSwan версии минимум 5.0.0. Я рекомендую использовать версию не ниже 5.2.0, т.к. именно в этой версии появилась утилита «swanctl», которая заметно удобней старой «ipsec». Утилита потребуется, по большому счету, только для вывода какой-то информации или статистики, она не обязательна для настройки и можно обойтись только ipsec, но в статье будет использоваться только она.
**Скрытый текст**Жизнь со swanctl:
Жизнь без swanctl:
Нам могут потребоваться некоторые модули, которых может не быть в стандартной поставке:
* **xauth-noauth** — поддельный аутентификатор, позволяет вводить любой логин и пароль. Нужен для iPhone и iPad при аутентификации только по ключам, т.к. там нет возможности отключить аутентификацию по логину и паролю.
* **vici** — интерфейс для swanctl.
* **libipsec** — для userspace IPsec (для OpenVZ и, возможно, других контейнеров).
Если вас не смущает необходимость вводить логин и пароль на iPhone, вам не нужен swanctl и вы не собираетесь запускать это все в OpenVZ-контейнере, то и пересобирать ничего не нужно.
К большому сожалению, мейнтейнеры strongSwan в Debian не запаковали ничего из этого (на февраль 2015), поэтому я сделал [патчик](http://lists.alioth.debian.org/pipermail/pkg-swan-devel/Week-of-Mon-20141110/000439.html), который вы можете использовать.
### Переходим к настройке
Будем настраивать подключение через IKEv2 (Windows, Linux, Blackberry), IKEv1+XAUTH (iOS, OS X, Android) и IKEv2+EAP-TLS (Windows Phone). Используем ключи, никаких PSK!
Разработчики strongSwan предлагают нам использовать команду «ipsec pki» для генерации ключей, но она настолько же неудобная, насколько и обычный openssl, поэтому я адаптировал Easy-RSA v3 из OpenVPN для генерации как OpenVPN, так и IPsec-совместимых ключей. С ним вы можете использовать одну связку ключей для двух протоколов!
[github.com/ValdikSS/easy-rsa-ipsec](https://github.com/ValdikSS/easy-rsa-ipsec)
Easy-RSA чрезвычайно простой, поддерживать PKI-инфраструктуру с ним одно удовольствие!
Итак, инициализируем PKI и создаем CA, серверный и клиентский ключи. **Важно, чтобы название серверного ключа совпадало с FQDN (доменом, проще говоря) вашего сервера!**
```
$ git clone https://github.com/ValdikSS/easy-rsa-ipsec.git
$ cd easy-rsa-ipsec/easyrsa3
$ ./easyrsa init-pki
init-pki complete; you may now create a CA or requests.
$ ./easyrsa build-ca nopass
Generating a 2048 bit RSA private key
…
Common Name (eg: your user, host, or server name) [Easy-RSA CA]:IPsec CA
…
$ ./easyrsa build-server-full uk1.pvpn.pw nopass
Generating a 2048 bit RSA private key
…
Write out database with 1 new entries
Data Base Updated
$ ./easyrsa build-client-full client1 nopass
Generating a 2048 bit RSA private key
…
Write out database with 1 new entries
Data Base Updated
$ ./easyrsa export-p12 client1 nopass
Successful export of p12 file. Your exported file is at the following
location…
```
Ключи сгенерированы. Я добавлял параметр `nopass` на каждом шагу, чтобы ключи не были защищены паролем (его можно установить позже в любое время).
Теперь нам необходимо скопировать их в нужные директории внутри `/etc/ipsec.d/`, чтобы strongSwan нашел их:
```
# cp pki/ca.crt /etc/ipsec.d/cacerts/
# cp pki/issued/uk1.pvpn.pw.crt /etc/ipsec.d/certs/
# cp pki/private/uk1.pvpn.pw.key /etc/ipsec.d/private/
```
Переходим к настройке strongSwan!
Первым делом, указываем наш приватный ключ в `/etc/ipsec.secrets`
```
# This file holds shared secrets or RSA private keys for authentication.
# RSA private key for this host, authenticating it to any other host
# which knows the public part.
# this file is managed with debconf and will contain the automatically created private key
include /var/lib/strongswan/ipsec.secrets.inc
: RSA uk1.pvpn.pw.key
```
Редактируем конфигурационный файл `/etc/ipsec.conf`
```
# ipsec.conf - strongSwan IPsec configuration file
# basic configuration
config setup
# strictcrlpolicy=yes
# uniqueids = no
include /var/lib/strongswan/ipsec.conf.inc
conn %default
dpdaction=clear
dpddelay=35s
dpdtimeout=300s
fragmentation=yes
rekey=no
ike=aes256gcm16-aes256gcm12-aes128gcm16-aes128gcm12-sha256-sha1-modp2048-modp4096-modp1024,aes256-aes128-sha256-sha1-modp2048-modp4096-modp1024,3des-sha1-modp1024!
esp=aes128gcm12-aes128gcm16-aes256gcm12-aes256gcm16-modp2048-modp4096-modp1024,aes128-aes256-sha1-sha256-modp2048-modp4096-modp1024,aes128-sha1-modp2048,aes128-sha1-modp1024,3des-sha1-modp1024,aes128-aes256-sha1-sha256,aes128-sha1,3des-sha1!
# left - local (server) side
left=%any
leftauth=pubkey
leftcert=uk1.pvpn.pw.crt
leftsendcert=always
leftsubnet=0.0.0.0/0,::/0
# right - remote (client) side
right=%any
rightauth=pubkey
rightsourceip=192.168.103.0/24,2002:25f7:7489:3::/112
rightdns=8.8.8.8,2001:4860:4860::8888
conn ikev2-pubkey
keyexchange=ikev2
auto=add
conn ikev2-pubkey-osx
also="ikev2-pubkey"
leftid=uk1.pvpn.pw
conn ikev1-fakexauth
keyexchange=ikev1
rightauth2=xauth-noauth
auto=add
conn ikev2-eap-tls
also="ikev2-pubkey"
rightauth=eap-tls
eap_identity=%identity
```
Как видите, конфигурационный файл состоит из нескольких секций. В секции `config setup` два закомментированных параметра: `strictcrlpolicy = yes` будет требовать неистекший лист отзывов для проведения аутентификации клиента, а `uniqueids = no` позволяет подключаться нескольким клиентам с одним сертификатом одновременно.
Далее идут секции с описаниями подключений. Секция с названием `%default` описывает подключение по умолчанию, от которого будут наследоваться другие подключения. Здесь устанавливаются следующие параметры:
* `dpdaction=clear` включает механизм Dead Peer Detection (DPD) и указывает, что нужно забывать о клиенте, если он не отзывался дольше таймаута
* `dpddelay=35s` — задержка до включения DPD
* `dpdtimeout=300s` — таймаут для DPD
* `fragmentation=yes` — включение внутренней фрагментации пакетов. Позволяет использовать IPsec с провайдерами, у которых сломана IP-фрагментация пакетов (привет, мобильный МТС!)
* `rekey=no` — выключение инициации смены ключей со стороны сервера. Windows это не любит.
* `ike` — перечень ciphersuites для использования с IKE (т.е. во время установки шифрованного соединения для передачи конфигурационных параметров, в том числе и ключей для установки SA)
* `esp` — перечень ciphersuites для шифрования трафика
* `left` и `right` — случаем все интерфейсы и принимаем всех клиентов
* `leftid` — указываем наш FQDN. Нужно для сломанного IKEv2 в OS X El Capitan
* `leftauth/rightauth=pubkey` — используем аутентификацию по ключам
* `leftsubnet` — подсети, которые мы отправляем клиенту для маршрутизации (весь IPv4 и IPv6-интернет). Уберите IPv6, если не используете его.
* `rightsourceip` — пул IP-адресов, из которого выдаем адрес клиенту. Уберите IPv6, если не используете его.
* `rightdns` — IP-адреса DNS-серверов
Давайте разберемся с ciphersuites в ike и esp. Здесь перечислены методы шифрования в порядке убывания приоритета, и их так много из-за того, что некоторые из них могут быть недоступны на каких-то устройствах, например, мобильных. Первым делом идут так называемые [AEAD-алгоритмы](https://ru.wikipedia.org/wiki/AEAD-режим_блочного_шифрования), т.е. такие шифры, которые не требуют отдельного алгоритма для [аутентификации](https://ru.wikipedia.org/wiki/Имитовставка), с убывающей группой Диффи-Хеллмана для реализации Perfect Forward Secrecy (PFS). Это самые быстрые шифры, которые доступны в IPsec. Хоть это и AEAD-режим, в ike должны быть алгоритмы хеширования для процесса хендшейка. Затем идет привычный AES-CBC с группами Диффи-Хеллмана. Клиентам, которые не поддерживают PFS, мы не позволим подключиться.
Если у вас нет модуля `xauth-noauth` для соединения `ikev1-fakexauth`, то вы можете заменить его просто на `xauth` и создать пользователя в `/etc/ipsec.secrets`, например, с логином и паролем client1:
```
client1 : XAUTH "client1"
```
Теперь у нас есть три подключения: `ikev2-pubkey` для IKEv2, `ikev1-fakexauth` для IKEv1 с фейковой проверкой логина и пароля и `ikev2-eap-tls` — IKEv2+EAP-TLS для Windows Phone. Перезапускаем strongSwan.
Если все верно, вы увидите следующий вывод команды **swanctl -L**
```
$ swanctl -L
ikev2-pubkey: IKEv2
local: %any
remote: %any
local public key authentication:
id: CN=uk1.pvpn.pw
certs: CN=uk1.pvpn.pw
remote public key authentication:
ikev2-pubkey: TUNNEL
local: 0.0.0.0/0 2000::/3
remote: dynamic
ikev1-fakexauth: IKEv1
local: %any
remote: %any
local public key authentication:
id: CN=uk1.pvpn.pw
certs: CN=uk1.pvpn.pw
remote public key authentication:
remote XAuth authentication:
ikev1-fakexauth: TUNNEL
local: 0.0.0.0/0 2000::/3
remote: dynamic
ikev2-eap-tls: IKEv2
local: %any
remote: %any
local public key authentication:
id: CN=uk1.pvpn.pw
certs: CN=uk1.pvpn.pw
remote EAP authentication:
ikev2-eap-tls: TUNNEL
local: 0.0.0.0/0 2000::/3
remote: dynamic
```
#### Проблемы MTU
Из-за особенностей и ошибок в реализации разных IPsec-клиентов, MTU внутри туннеля нельзя угадать заранее, а на Android вообще устанавливается MTU 1500, из-за чего большие пакеты не передаются и вообще ничего не работает. Чтобы нивелировать этот недостаток, достаточно изменять параметр TCP MSS в момент установки TCP-соединения на стороне сервера. Будем использовать значение 1360 для IPv4 и 1340 для IPv6, чтобы размер пакета не превышал 1400 байт внутри туннеля:
```
# iptables -t mangle -I FORWARD -p tcp -m policy --pol ipsec --dir in --syn -m tcpmss --mss 1361:1536 -j TCPMSS --set-mss 1360
# iptables -t mangle -I FORWARD -p tcp -m policy --pol ipsec --dir out --syn -m tcpmss --mss 1361:1536 -j TCPMSS --set-mss 1360
# ip6tables -t mangle -I FORWARD -p tcp -m policy --pol ipsec --dir in --syn -m tcpmss --mss 1341:1536 -j TCPMSS --set-mss 1340
# ip6tables -t mangle -I FORWARD -p tcp -m policy --pol ipsec --dir out --syn -m tcpmss --mss 1341:1536 -j TCPMSS --set-mss 1340
```
На этом настройка сервера закончена. Не забудьте настроить NAT, если вам он нужен!
### Настройка клиентов
Алгоритм настройки клиентов в общих чертах заключается в импорте сертификатов из файла \*.p12, создании нового подключения с типом IPsec PKI, IPsec XAUTH RSA или IKEv2 (в зависимости от устройства), указания клиентского сертификата и адреса сервера.
**Внимание! Нужно вводить именно тот адрес сервера, который вы вводили при создании серверного ключа. Подключиться по другому домену или просто по IP-адресу, если сертификат был сгенерирован на домен, не получится!**
#### Windows
Windows 7, 8, 8.1 (IKEv2)
[Установка сертификатов](https://wiki.strongswan.org/projects/strongswan/wiki/Win7Certs)
[Создание соединения](https://wiki.strongswan.org/projects/strongswan/wiki/Win7Config)
[Подключение](https://wiki.strongswan.org/projects/strongswan/wiki/Win7Connect)
Windows Vista (IKE)
[IKE на Windows Vista](https://wiki.strongswan.org/projects/strongswan/wiki/WindowsVista)
#### OS X и iOS
[Настройка подключения на iOS и OS X](https://wiki.strongswan.org/projects/strongswan/wiki/IOS_(Apple)#iOS-client-configuration)
#### Android
Вы можете использовать как IPsec-клиент Android и подключаться по протоколу IKE, так и [клиент strongSwan](https://play.google.com/store/apps/details?id=org.strongswan.android) и использовать IKEv2. Клиент strongSwan работает стабильнее и надежно переподключает в случае потери соединения.
Импортируйте сертификат либо через файловый менеджер, либо используя пункт «Установка с SD-карты» в разделе «Безопасность». Перейдите в настройки VPN, создайте новое подключение с типом «IPSec Xauth RSA», в поле «Адрес сервера» впишите, собственно, адрес сервера, в поле «Сертификат пользователя IPSec» и «Сертификат ЦС IPSec» укажите сертификат «client1». Нажмите на соединение, введите любые логин и пароль и попробуйте подключиться.
### Заключение
IPsec, по моему мнению, является замечательной альтернативой OpenVPN, который любят многие администраторы. Почему большинство VPN-провайдеров все еще используют L2TP+IPsec для меня остается загадкой, т.к. strongSwan предоставляет всю необходимую функциональность для такого рода серивисов (полная поддержка Radius, море плагинов). Я использую strongSwan на своем сервисе уже около полугода в режиме закрытого тестирования и он оставил о себе исключительно положительные впечатления.
IPsec, как я уже говорил, очень гибкий и поддерживает уйму аутентификаторов, поэтому вы можете делать даже такие сумасшедшие вещи, как аутентификация по SIM-карте в мобильном устройстве и хранение публичных ключей в IPSECKEY-записи домена, защищенной DNSSEC.
Если вы боитесь использовать IPsec из-за документов NSA, которые опубликовывал Эдвард Сноуден, пожалуйста, прочитайте статью [Don’t stop using IPsec just yet](https://nohats.ca/wordpress/blog/2014/12/29/dont-stop-using-ipsec-just-yet/), чтобы развеять сомнения. | https://habr.com/ru/post/250859/ | null | ru | null |
# Вам посылка, или Как мы доставляем сообщения с сервера на клиент в реальном времени
*Меня зовут Алексей Комаров, я* — *старший frontend-разработчик в SuperJob. Хочу поделиться опытом реализации механизма обновления данных в реальном времени у нас на сайте. Под катом — подробности о выборе подхода, о проблемах, с которыми мы столкнулись при разработке, о наших кейсах оптимизации
клиентской стороны и, конечно, немного кода и наглядных схем.*
### Выбор технологии для real-time
Все началось с того, что перед нами встала задача реализовать в браузере чат; обмен сообщениями должен происходить в реальном времени.
Для знакомых с web людей не является секретом, что протокол HTTP предполагает клиент-серверную архитектуру, в которой клиент всегда инициирует передачу данных, а сервер только отвечает на запросы клиентов. В режиме реального времени необходимо, чтобы сервер инициировал отправку данных.
Давайте рассмотрим, какие есть решения этой проблемы.
Способы организации real time в web
-----------------------------------
* **Polling**
Клиент по таймеру опрашивает сервер: «А не появилось ли чего-нибудь новенького?» Это самый старый и прямолинейный способ организации real-time. Минусов у этого подхода больше, чем плюсов: нагрузка на сеть и сервер; данные приходят не в реальном времени, а с задержкой между наступлением события и отправкой данных.
* **Long Polling**
Клиент открывает соединение, а сервер держит его до наступления события, потом отправляет данные, после чего клиент переоткрывает соединение. Это уже настоящий real-time — нагрузка на сеть и сервер снижается. Но остается необходимость самостоятельно организовывать непрерывное соединение, следить за его обрывами и тем, чтобы передаваемые данные не потерялись в этот момент.
* **Server Sent Events (SSE)**
Поддерживаемая браузерами технология непрерывного HTTP-соединения, в котором данные передаются потоком от сервера к клиенту.
* **WebSocket**
Независимый протокол поверх TCP. Это самое современное и популярное решение задачи организации передачи данных между клиентом и сервером в реальном времени.
Polling и Long Polling мы не рассматривали, потому что это устаревшие и не оптимальные подходы. Поэтому выбор был между SSE и WebSocket.
SSE vs WebSocket
----------------
Давайте кратко пройдемся по плюсам и минусам обеих технологий.
Плюсы SSE:
1. SSE использует HTTP, поэтому на сервере не нужна поддержка дополнительных протоколов и нет проблем с сетевыми экранами.
2. Простой браузерный API и широкая поддержка браузерами.
3. Встроенный механизм переподключения при обрыве соединения и защита от потери данных.
Минусы SSE:
1. Однонаправленная передача данных от сервера к клиенту; передавать можно только текст.
2. SSE позволяет открыть не более шести соединений для одного домена в браузере.
Плюсы WebSocket:
1. Поскольку WebSocket — это независимый протокол, то с его помощью можно передавать бинарные данные и организовать двунаправленную передачу данных.
2. Количество соединений в браузере не ограничено.
Минусы WebSocket:
1. WebSocket является отдельным протоколом, поэтому необходима его поддержка на сервере и возможны проблемы с сетевыми экранами.
2. Необходима самостоятельная реализация протокола на стороне клиента, хотя существуют библиотеки, решающие эту задачу.
В целом можно сказать, что SSE является более простой для реализации и понимания технологией. WebSocket — более сложный, но при этом гибкий подход.
Так как WebSocket является более современной и популярной технологией, которая позволяет более гибко решать задачи, вначале мы начали прорабатывать решение с ее использованием. Однако вскоре вскрылось одно обстоятельство, заставившее нас пересмотреть решение: если использовать WebSocket, то необходимо дублировать авторизацию или придумывать «костыли» для использования осуществленной по HTTP авторизации. В SSE такой проблемы нет, потому что он реализован на основе HTTP, и при его использовании все заголовки авторизации проставляются без дополнительных телодвижений.
Авторизация на нашем сайте является довольно сложным механизмом, и делать его еще сложнее нам совсем не хотелось, поэтому в итоге мы остановились на SSE.
### Реализация real-time с помощью SSE
Рассмотрим, как можно реализовать соединение SSE в браузере и на сервере. На клиенте нам нужно создать объект браузерного API для SSE и подписаться на событие сообщения onmessage. Данные от сервера приходят в параметре коллбека в виде строки.
```
eventSource = new EventSource('/SSE/', options);
eventSource.onmessage = ({ data }) => {
if (typeof data !== 'string') {
log.warn('Unsupported sse data type (should be string)’, { data, dataType: typeof data });
return;
}
try {
const {type, data: message} = JSON.parse(data);
///…
}
});
```
Так как SSE — это технология непрерывного HTTP-соединения, то на сервере необходимо обрабатывать обычный HTTP-запрос.
Мы используем фреймворк Express на Node.js-сервере, поэтому создаем новый роут для клиентского SSE-запроса и в поток ответа отправляем два переноса строки в начале соединения, свидетельствующие о начале передачи данных, а потом и сами данные, каждая порция которых отделяется переносом строки.
```
export const sendSSEEvent = (res, data) => {
if (!data) {
res.write('\n\n');
return;
}
res.write('data: ${JSON.stringify(data)}\n');
res.write('\n');
};
```
Это все, что нужно сделать на сервере, чтобы заработала передача данных.
### Клиент-серверная архитектура
Таким образом у нас сформировалось архитектурное решение передачи данных с сервера в реальном времени:
1. Серверная часть SSE реализуется на Node.js-сервере.
2. В качестве транспорта между PHP-сервером и Node.js используется Redis.
3. Для каждого авторизованного пользователя создается Redis-канал.
4. SSE используется для нотификации о новых данных, а не для передачи данных.
Давайте рассмотрим схему, которая иллюстрирует работу сервера с клиентом.
На клиенте есть браузерное API для SSE и диспетчер сообщений, реализованный в функции processServerMessage. На сервере — express route, библиотека для работы с Redis и пул SSE-каналов для каждого пользователя и его устройства.
Работу схемы можно представить как два потока. Вначале SSE API инициирует соединение, которое обрабатывается на сервере, и создается канал для прослушивания сообщений Redis и канал в пуле SSE-каналов, если они еще не были созданы.
Отмечу, что имя канала Redis включает тип пользователя и его ID, что позволяет идентифицировать, для кого приходит сообщения из системы.
Пул каналов — это хэш-таблица, ключами которой являются тип пользователя и ID пользователя, а значение — это массив из идентификаторов клиентских устройств и открытых соединений express.
После того как закончилась инициализация, возможна передача данных. Backend записывает в Redis нотификацию о том, что произошло некое событие и, возможно, вспомогательные данные (например, ID чата, в который пришло сообщение). Redis передает это в канал, который связан с Node.js-сервером. По имени канала серверная часть нашей системы определяет, какому пользователю предназначено сообщение, и находит в пуле каналов соответствующие открытые соединения для всех устройств, которые в этот момент соединены с сервером. Далее сообщение передается в каждое открытое соединение на клиентские устройства. На клиентском устройстве API SSE получает данные и вызывает диспетчер сообщений, который в зависимости от типа сообщения и вспомогательных данных вызывает API бэкенда для получения данных по HTTP.
Таким образом, мы не используем SSE-соединение для передачи данных — только для нотификации о том, что они появились на сервере. Дальше запрос данных происходит по обычному API бэкенда.
Собственно, так мы организовали доставку сообщений с сервера на клиент в реальном времени. Реализация системы оказалась достаточно простой, так как мы выбрали подходящую технологию и использовали уже имеющиеся механизмы приложения.
От хорошего к лучшему: оптимизация системы
------------------------------------------
Итак, наш чат работает, и на этом можно было бы остановиться, но нам захотелось оптимизаций (шутка!) — в них была потребность.
Для оптимальной работы системы необходимо:
1. Уменьшение объема данных, передаваемых по SSE-соединению, для повышения скорости оповещения клиентов о новых данных.
2. Уменьшение количества открытых SSE-каналов.
С уменьшением передаваемых данных все понятно, а уменьшение количества SSE-соединений необходимо, во-первых, чтобы уменьшить нагрузку на сервер, а во-вторых, из-за лимита в шесть подключений, накладываемого браузерами. Для нас эта оптимизация была особенно важна, так как наши клиенты любят открывать множество вкладок, когда просматривают вакансии, а каждая вкладка — это SSE-соединение.
Уменьшение передаваемых через SSE-соединение данных мы реализовали, решив пересылать по SSE только нотификации, а данные получать по обычному API backend.
Для уменьшения количества соединений по SSE мы использовали два приема.
Первый — режим реального времени доступен только для авторизованных пользователей. На самом деле, это изначально закладывалось в архитектуру, так как имена каналов Redis содержат данные авторизованных пользователей. Все гости сайта живут без режима реального времени.
Второй способ уменьшить количество SSE соединений — для каждого браузера создавать только одно соединение (а не для каждой вкладки сайта). Рассмотренная выше система так не умеет, поэтому нам необходимы некоторые доработки.
Один браузер — одно SSE-соединение
----------------------------------
Итак, чтобы одна вкладка открывала SSE-соединение, а остальные получали сообщения от нее, нам нужны: среда обмена сообщениями, обеспечение контроля работоспособности вкладки с SSE-соединением и механизм выбора вкладки, открывающей соединение. Рассмотрим подробнее, как реализовать каждое требование.
Среда обмена сообщениями
------------------------
В качестве транспорта мы используем локальное хранилище браузера (LocalStorage). Оно позволяет записывать значения с некоторым ключом и подписываться на изменения. Вкладка-отправитель записывает сообщение с помощью функции setItem. Другие вкладки получают сообщение, подписавшись на браузерное событие «storage». Таким образом, мы можем общаться между вкладками.
Контроль работоспособности
--------------------------
Контроль за работоспособностью активной вкладки осуществляется с помощью двух взаимосвязанных механизмов:
1. Heartbeat — периодический сигнал контролируемой системы, который оповещает о ее работоспособности. Если этот сигнал не приходит, то все заинтересованные части системы понимают, что произошла исключительная ситуация и надо ее обработать.
```
const heartbeatIntervalId = setInterval(() => {
setSseId(genUuid()) ;
}, SSE_CONNECTION_HEARTBEAT_INTERVAL) ;
```
1. Сторожевой таймер — схема контроля за зависанием, состоящая из таймера, который периодически сбрасывается контролируемой системой.
```
const setConnectionWatcher = () => {
if (sseConnectionWatchTimer) {
clearTimeout (sseConnectionWatchTimer);
}
sseConnectionWatchTimer = setTimeout(() => {
openConnection();
}, SSE_CONNECTION_WATCH_INTERVAL);
};
```
Механизм выбора активной вкладки
--------------------------------
Для определения того, какая вкладка будет открывать соединение, используется лотерея. В каждой вкладке задается случайная задержка установки соединения. Вкладка с наименьшей задержкой выигрывает.
```
const delayBase = SSE_CONNECTION_WATCH_INTERVAL;
const delayRandom = Math.random() * 1000;
sseConnectionWatchTimer = setTimeout(() => {
openConnection();
}, delayBase + delayRandom);
```
Клиентская архитектура
----------------------
Теперь рассмотрим полную схему работы приложения на клиенте. Схему можно разделить на две части: синхронизация вкладок и обработка SSE-сообщения от сервера.
Синхронизацию вкладок можно описать с помощью трех возможных сценариев:
1. Пользователь открывает браузер, и запускается сразу несколько вкладок. Для каждой вкладки запускается сторожевой таймер и срабатывает лотерея. Вкладка, которая выиграла лотерею, вызывает менеджер соединений, а он, в свою очередь, открывает SSE-соединение и запускает HeartBeat. В остальных вкладках сторожевой таймер начинает регулярно сбрасываться по сигналу HeartBeat, который приходит из local storage. Система приходит в согласованное состояние.
2. Пользователь открывает новую вкладку при уже установленном SSE-соединении. В этом случае для открытой вкладки запускается сторожевой таймер, но он начинает сбрасываться уже работающим сигналом HeartBeat. Таким образом, вкладка становится синхронной со всеми остальными.
3. Пользователь закрывает вкладку с SSE-соединением. В этом случае менеджер соединений закрывает SSE-соединение и останавливает HeartBeat. Срабатывают сторожевые таймеры остальных вкладок, и снова запускается лотерея.
Схема обработки SSE-сообщений похожа на уже рассмотренную ранее схему, за исключением того, что вкладка с установленным SSE-соединением записывает полученное сообщение в local storage, а остальные вкладки, получив его в обработчике события новых данных в хранилище, вызывают свой диспетчер сообщений.
С такой архитектурой достаточно иметь одно SSE-соединение, и все вкладки будут получать сообщения от сервера в реальном времени.
Итоги
-----
Несмотря на то что некоторые считают SSE устаревшей технологией, это далеко не так, и во многих случаях она является оптимальным решением. Это решение позволяет минимизировать трудозатраты и не увеличивать сложность системы. К тому же ряд оптимизаций позволил добиться стабильной работы системы и снизить нагрузку на сеть и сервер.
В качестве бонуса мы получили возможность обновлять в реальном времени любые данные на сайте, так как механизм оповещения сервером клиентов в реальном времени был реализован независимо от чата.
Надеюсь, наш опыт окажется для вас полезным. | https://habr.com/ru/post/649053/ | null | ru | null |
# Классы и метаклассы в Javascript
Хочу рассказать о решении, которое я использую для одиночного наследования в JavaScript. Оно настолько маленькое, что наверняка в том или ином варианте встречается где-нибудь еще. Надеюсь, кому-то из читателей оно окажется полезным.
Это часть фреймворка, который я сделал для своей платформы [Akshell](http://www.akshell.com/), вот [полный код](http://www.akshell.com/apps/ak/code/0.2/base.js#77) решения и [документация](http://www.akshell.com/docs/0.2/ref/ak/base/#Function.subclass). Однако оно может пригодиться в любой Server-Side JavaScript среде, на стороне сервера удобное создание иерархий классов особенно актуально. Его можно использовать и на клиенте, если заменить работу со свойством `__proto__` оператором `new`.
Собственно, все решение заключается в методе `subclass` класса `Function`. Если позволяет среда, его стоит сделать non enumerable.
> `Function.prototype.subclass = function (/\* [constructor] [, prototype] \*/) {
>
> var self = this;
>
> var constructor = (
>
> typeof(arguments[0]) == 'function'
>
> ? Array.prototype.shift.call(arguments)
>
> : (this === Object
>
> ? function () {}
>
> : function () { self.apply(this, arguments); }));
>
> if (arguments[0])
>
> constructor.prototype = arguments[0];
>
> constructor.prototype.\_\_proto\_\_ = this.prototype;
>
> constructor.\_\_proto\_\_ = this.\_\_proto\_\_;
>
> return constructor;
>
> };`
Функция принимает два опциональных аргумента: конструктор и прототип создаваемого класса. Семантика передачи аргументов нестандартная, но в данном случае удобная: если первый аргумент является функцией, это конструктор, в противном случае — прототип.
Игрушечный пример иерархии классов:
> `var Figure = Object.subclass(
>
> {
>
> getArea: function () {
>
> throw Error('Abstract');
>
> }
>
> });
>
>
>
> var Rectangle = Figure.subclass(
>
> function (a, b) {
>
> this.a = a;
>
> this.b = b;
>
> },
>
> {
>
> getArea: function () {
>
> return this.a \* this.b;
>
> }
>
> });
>
>
>
> var Square = Rectangle.subclass(
>
> function (a) {
>
> Rectangle.call(this, a, a);
>
> });`
Т.к. конструкторы являются объектами класса `Function`, то естественным образом подклассы `Function` являются классами классов, или метаклассами. Определяя их можно управлять инстанциированием классов, а также определять статические свойства и методы классов, наследуемые подклассами (подкласс получает метакласс от своего родителя в предпоследней строке метода `subclass`).
Например, мы хотим, чтобы подклассы `Figure` можно было инстанцировать без оператора и каждый из них имел свойство `optionalNew` равное `true`. Для этого нужно написать метакласс для Figure:
> `var FigureMeta = Function.subclass(
>
> {
>
> subclass: function () {
>
> var constructor = Function.prototype.subclass.apply(this, arguments);
>
> var result = function () {
>
> var self = (
>
> this instanceof arguments.callee
>
> ? this
>
> : {\_\_proto\_\_: arguments.callee.prototype});
>
> constructor.apply(self, arguments);
>
> return self;
>
> };
>
> result.prototype = constructor.prototype;
>
> result.\_\_proto\_\_ = this.\_\_proto\_\_;
>
> return result;
>
> },
>
>
>
> optionalNew: true
>
> });
>
>
>
> Figure.\_\_proto\_\_ = FigureMeta.prototype;`
Все подклассы `Figure`, определенные после установки метакласса, получат необходимые изменения.
Конечно, метаклассы не стоит применять слишком широко, в частности, `FigureMeta` является совершенно надуманным примером. Однако в некоторых случаях они могут сделать код гораздо короче и понятнее. Например, при адаптировании в Akshell библиотеки [js-forms](http://code.google.com/p/js-forms/), порта [Django forms](http://docs.djangoproject.com/en/1.2/topics/forms/#topics-forms-index) в JavaScript, метаклассы позволили создавать подклассы форм так же декларативно, как и в Django (там для этого тоже используются метаклассы, только питоновские). Код занимает всего лишь [30 строк](http://www.akshell.com/apps/form/code/0.2/forms.js#1014). | https://habr.com/ru/post/94070/ | null | ru | null |
# Как я ушёл с InDesign'а в LaTeX
InDesign, безусловно, является флагманом в индустрии вёрстки. Но, проработав в нём немалое количество времени, я вернулся к старому ~~доброму~~ TeX'у, с которым познакомился ещё во время своей учёбы в университете. Почему так вышло? Почему от понятного WYSIWYG-редактора я ушёл к языку разметки, и от продукта, поддерживаемого мощнейшей компанией Adobe — к программе, код которой давно заморожен, и лишь появляются новые пакеты, написанные волонтёрами?
История началась с того, что InDesign меня обидел тем, что начал нагло врать в глаза. Я пытался сделать именной указатель и видел в нём не те страницы, на которых реально стояли «якоря», а чуть отличающиеся. Никакие танцы с бубнами не помогали. Делать указатели вручную — не мой жанр. Писать свои скрипты, которые будут отыскивать на страницах какие-то дополнительные скрытые знаки — тоже не очень надёжный вариант. Тем более что список задачек при подготовке издания, был примерно таков:
1. сделать тематический указатель,
2. сделать именной указатель,
3. расставить кучу ударений с учётом того, что в выбранном шрифте, увы, юникодовский знак ударения не работает,
4. добиться того, чтобы эти ударения нужным образом кочевали в колонтитулы, оглавления и указатели,
5. изредка пользоваться конструкциями типа «см. сноску 15 на странице 45»,
6. сделать пробелы вокруг тире поуже, симметричными, а предшествующий тире — ещё и неразрывным,
7. сделать указатель ссылок на Библию (отсортированный по порядку библейских книг, далее — по главам, далее — по стихам глав).
При этом хотелось максимально распараллелить задачи работы над текстом и минимально пользоваться интернетом (рабочее место находится не в городе, а в глуши, где интернет еле живой).
Может быть, среди читателей найдутся эксперты по InDesign, которые подскажут, как именно вышеупомянутые задачи можно решить. Но в тех решениях, которые я представляю себе, много движений мышкой, всякого копирования и вставляния. Например, для того, чтобы указать, где ещё встречается то имя, которое я хочу в именной указатель, мне надо либо заново его вбивать в панельке Index, либо искать в документе этот заветный символ нулевой ширины, копировать его и вставлять. Ширина-то у него нулевая, а вот высота — нет, и потом приходится ловить косяки, что у тебя в сноске интерлиньяж пополз из-за этого «чудо-символа».
Меня эти многочисленные операции в ручном режиме пугали тем, что в тот момент, когда надо будет макет сдавать, наверняка понадобится срочно внести какую-то правку, соответственно, что-то поедет, что-то надо будет заново компилировать, и из тысячи вещей, которые надо не забыть, сотня будет забыта. Кроме того, это «не забыть» означает, что макет, поставленный на полочку, должен быть заморожен — трюки останутся незадокументированными, а потому при повторном издании неповторимыми (ну или, по крайней мере, мучительными).
Возвращение к LaTeX (точнее, к XeLaTeX) было непростым. Пришлось разбираться, как добиться выбранного макета. Пришлось придумывать, как добиться приведённой вёрстки (чтобы строки на просвет совпадали). Пришлось теребить автора одного из пакетов, чтобы добиться возможности использовать Pantone (в некоторых изданиях часть страниц печаталась в CMYK, часть — в 2 краски: чёрную и бордовую). Пришлось освоить азы ещё нескольких языков общения с компьютером: bash, perl, xindy, AppleScript, …
Зато теперь есть некоторый инструментарий, которым можно и поделиться.
Итак, процесс подготовки книги происходит примерно следующим образом.
Начальный документ с текстом и всякими сносками открывается в OpenOffice и через [writer2latex](http://extensions.services.openoffice.org/en/project/writer2latex) выгоняется в LaTeX, где старательно чистится (там полно всякого мусора обычно). При желании документ делится на части, но нам как-то удобнее было работать с одним общим файлом текста произведения.
В рамках представления о том, что надо разделять содержание и оформление, создаётся отдельный файл header.tex, в который потихоньку бузуется куча всяких подгрузок пакетов и определений своих команд.
Все изменения и объединение версий происходит в Git, в нашем случае в приватном репозитории на [bitbucket.org](http://bitbucket.org). Когда кто-то из редакторов или корректоров боится этих штук, он редактирует как умеет и присылает файлы и по почте, но всё же из почты их кто-то отправляет в репозиторий.
За общий вид макета отвечают в первую очередь пакеты `geometry` и `fancyhdr`, за вид и расположение заголовков — `titlesec` (с его помощью я [добивался и приводки вёрстки](http://tex.stackexchange.com/questions/98081/using-fixed-space-aroung-headings-to-get-text-in-sync-with-baseline-grid/245465#245465)). Типографских изысков можно достигать, используя пакеты `microtype` и `fnpct`, которые помогают сделать оптическое выравнивание по краю и лёгкое «загоняние» знаков препинания под предшествующий знак сноски. Сами сноски можно варьировать намного больше, чем в InDesign (хоть на поле выноси, хоть все сноски в один абзац объединяй) — на это есть `footmisc`. Буквицы (и образ их обтекания текстом) вставляются при помощи пакета `lettrine`.
Пока не ушёл далеко, описания пакетов и примеры их использования есть на [www.ctan.org](http://www.ctan.org/) А совершенно замечательная площадка взаимопомощи — [tex.stackexchange.com](http://tex.stackexchange.com)
Вопрос с расстановкой ударений пришлось решать вот так:
```
\usepackage{accentbx}
\def\'#1{\upaccent{\aboxshift[.9ex]{^^^^00b4}}{#1}}
\makeatletter
\let\@acci\'
\makeatother
```
А с тире — вот так (эта штука работает и в тире, обозначающих прямую речь:
```
\usepackage{newunicodechar}
\def\tire{—}
\newcommand\vokrugtire{\hskip .1em plus .1em minus .05em}
\newunicodechar{—}{\ifvmode\tire\kern .1em\ignorespaces\else\unskip\nolinebreak\vokrugtire\nolinebreak\tire\vokrugtire\ignorespaces\fi}
```
Переносы LaTeX расставляет в целом намного лучше, чем стандартный InDesign (хотя [модуль Игоря Владимировича Батова](http://www.batov.ru/) весьма качественно исправляет этот недостаток InD). Но тут есть такая особенность. В LaTeX нет кнопочки «запретить переносы через страницу». Это связано с тем, что LaTeX сначала формирует абзацы, а потом пытается строки распределить по страницам. Впрочем, в InD я этой кнопочкой не пользовался — как мне представляется, запрещать надо только переносы с нечётной страницы на чётную (то есть на оборот страницы). При включении этой кнопочки InDesign запрещает и переносы между колонками (в многоколоночной вёрстке), что мне кажется совсем перебором.
Игры с переносами заключаются в варьировании значений параметров
```
\righthyphenmin
\lefthyphenmin
\hyphenpenalty
\doublehyphendemerits
\finalhyphendemerits
```
Подробнее про эти параметры можете посмотреть [вот тут](http://www.pragma-ade.com/general/manuals/style.pdf). InDesign, конечно, не даёт такой степени контроля над процессом формирования абзаца. И мне приходилось сталкиваться с ситуацией, когда в InD абзац начинал выглядеть мерзко из-за того, что стоял запрет на 4 переноса подряд — но эти 4 переноса не испохабили бы так абзац, как возникшие дыры между словами. Так что подход LaTeX'а с подсчётом общего значения penalty мне кажется очень разумным. Переносы с нечётной страницы можно поймать при помощи `texttopdf` и [скрипта на perl](http://tex.stackexchange.com/questions/266539/hyphenation-across-pages-summary-of-odd-pages-with-last-hyphenated-word/278405#278405).
Работа с указателями становится весьма комфортной, если в преамбуле написать что-то вроде такого:
```
\usepackage{makeidx}
\usepackage{multind}
\makeindex{subj}
\makeindex{name}
\newcommand{\subj}[1]{\index{subj}{#1}}
\newcommand{\name}[1]{\index{name}{#1}}
```
Тогда в тексте можно будет вставлять каждый раз на отдельной строке отбитую несколькими tab'ами (чтобы не сливалось с основным потоком текста `\subj{...}`, потом прогонять
`sed -n "/\\\name/p;/\\\geo/p" main-file.tex | sed "s/|[)(]//g" | LANG=ru LC_COLATE=C sort | uniq > name-and-geo-index.tex`
и без всякой компиляции файла видеть черновик указателя, из которого потом просто брать и копировать в основной файл те гнёзда указателя, которые снова понадобились. Для полноценной компиляции вам придется разобраться с настройками `xindy` и, возможно, что-то доточить самостоятельно. Зато мне удалось сделать в книге единый географический указатель, в котором есть и номера страниц, и квадраты приложенных карт. А также я научил гнёзда младших уровней не оставлять «вдовыми» гнёзда-родители (в InDesign этого нельзя добиться в стилях при помощи «Keep with next/previous»: либо все дети липнут в единый блок, либо сирый родитель липнет к следующему родителю).
А правильным образом доточив напильником пакет `bibleref`, можно добиться того, что при добавлении в основной файл строчки `\bible{Мф. 1:1}` в конце книги будет главка «Указатель ссылок на Священное Писание», где в разделе «Новый Завет» будет подраздел «Евангелие от Матфея», и там строчка 1:1........(номер страницы).
Если на этом абзаце вы готовы вспылить и воскликнуть «Ох уж эти церковники! Даже на Хабр пробрались!», то погодите немножко, сейчас перейдём к самому интересному — к тому, как работать с картинками (заметив в скобках, что TeX совершенно прекрасен для [вёрстки церковнославянских текстов](https://sites.google.com/site/csltex/)).
InDesign типично вбивает картинку в макет как гвоздь в стену — она должна стоять тут, а текст пусть течёт как хочет. TeX воспринимает картинки как плавающие объекты, про которые пользователь говорит: «Картинку хорошо бы где-то тут, вверху страницы (или внизу, или без разницы)». И картинка не уплывает далеко от текста, к которому привязана (даже если вам за полчаса до сдачи макета скажут урезать ширину страницы на два сантиметра). Можно добиться и того, чтобы картинка оказывалась на ближайшей правой полосе:
```
\newcommand{\kartinkavramke}[1]{\fboxrule=2pt\fboxsep=0pt
{\centering\boxkinovar{\includegraphics[height=\textheight]{#1}}\par}}
\newcommand{\kartinkavskoresprava}[1]{
\ifodd\value{page}\afterpage{\kartinkavskoresprava{#1}}%
\else\afterpage{\thispagestyle{empty}\noindent%
\kartinkavramke{#1}}\fi}
```
В приведённом коде заодно решается и та задача, чтобы на странице, содержащей только картинку, не было ни колонтитула, ни колонцифры.
Ну и для ТеХ'а не составляет никаких проблем включить в книгу список иллюстраций (причём элементы этого списка можно сделать отличными от подписи под самой иллюстрацией). В InDesign для этого потребовалось бы, наверное, ставить боксы с белым текстом, обязательно попадающие на страницу (валяющееся на обочине InDesign в индексы не включает).
LaTeX принимает довольно ограниченный список графических форматов: PDF, JPG, PNG. Никаких вам TIFF, никаких PSD. Это не даёт расслабиться, но и жить не мешает. Для быстроты компиляции можно сделать две директории для картинок: `large` и `small`.
```
cd large
for i in *.*; do echo $i; convert -resize 25% -quality 60 $i ../small/$i; done
```
А в самом тексте временно пользоваться
```
\newcommand{\pathtoimg}[1]{small/#1}
\includegraphics[height=\textheight]{\pathtoimg{myself.jpg}}
```
Даже самая умная машина не может сделать всё так, как хотелось бы человеку, и в конце всё равно нужна ручная доводка (которая несколько разрушает идею разделения контента от оформления — но это можно развести уже на уровне веток Git). Нужно заниматься выгонкой и вгонкой, чтобы добиться прекрасного вида. От части работы может избавить вот такой трюк:
```
\setlength{\parfillskip}{0pt plus .75\textwidth}
```
который в переводе на русский означает: «Хочу, чтобы последние строки в абзаце были заполнены не менее, чем на 25%». Остальную работу придётся делать при помощи привычных приёмов: изменения трекинга и межсловных пробелов.
```
\newcommand{\tracking}[2]{{\addfontfeature{LetterSpace=#1}#2}}
\newcommand{\interword}[2]{{\setlength{\spaceskip}{#1\fontdimen2\font plus #1\fontdimen3\font minus #1\fontdimen4\font}#2}}
```
Что не может здесь не радовать, так это то, что верстальщику всё видно: где какие применены инструменты (у InDesign есть режим подсветки трекинга, но значение-то в каждой точке может быть разным, пока не ткнёшь, не узнаешь).
Что не может не огорчать — то, что после каждого изменения параметра приходится заново компилировать документ, чтобы посмотреть, получилось или не получилось. Если документ огромный, на это может уходить пара минут. Но и тут есть трюки: можно пользоваться `\includeonly{...}` или написать свои команды, заставляющие LaTeX компилировать только нужный фрагмент, а остальное пропускать.
И теперь подходим к самому сложному этапу — сдаче макета в типографию. Для начала у нас потребуют отступ (bleed) в 5 мм. Пожалуйста:
```
\usepackage[
layoutsize={140mm,200mm},
papersize={150mm,210mm},
layouthoffset=5mm,
layoutvoffset=5mm,
...]{geometry}
```
Потом потребуют выгонки в PostScript и прогонки через Adobe Disttiller. Я пытался сделать это двумя вариантами
`cupsfilter -P "PrintDriver.ppd" -m "application/postscript" my-book.pdf > my-book.ps` и `pdftops my-book.pdf my-book-another-way.ps`. Но получалась какая-то ерунда. Чёрный текст после прогонки через `cupsfilter` (или `pdftops`), а затем через Distiller превращался в композитный CMYK. Пришлось пользоваться Adobe Acrobat Pro: открыть и сохранить как PostScript. Так чёрный сохранил свою беспримесность.
Чтобы не делать это руками, написал немного AppleScript:
**Скрытый текст**\*acro-pdf-to-ps.scpt\*
```
on replace_chars(this_text, search_string, replacement_string)
set AppleScript's text item delimiters to the search_string
set the item_list to every text item of this_text
set AppleScript's text item delimiters to the replacement_string
set this_text to the item_list as string
set AppleScript's text item delimiters to ""
return this_text
end replace_chars
on run argv
set current_path to "/Volumes/data/process_me"
set in_file to current_path & "/" & item 1 of argv
set out_file to replace_chars(in_file, ".pdf", ".ps")
set in_file_correct to POSIX file in_file
set out_file_correct to POSIX file out_file
with timeout of (8 * 60) seconds
tell application "Acrobat"
activate
open in_file_correct
save document 1 to out_file using PostScript Conversion
close document 1
end tell
end timeout
end run
```
\*acrodist.scpt\*
```
on run argv
set current_path to "/Volumes/data/process_me"
set opt_file to current_path & "/Typo.joboptions"
set in_file to current_path & "/" & item 1 of argv
set out_file to replace_chars(in_file, ".ps", "-distilled.pdf")
with timeout of (8 * 60) seconds
tell application "Acrobat Distiller"
Distill sourcePath in_file destinationPath out_file adobePDFSettingsPath opt_file
end tell
end timeout
end run
```
```
osascript acro-pdf-to-ps.scpt my-book.pdf
osascript acrodist.scpt my-book.ps
```
Все эти скрипты преследуют одну цель: если в последний момент скажут что-то поменять, то должен быть уже отлажен поток, по которому эти изменения войдут в итоговую выгрузку файлов. Особенно если файлов несколько.
Так что переход из InDesign в LaTeX состоялся. Скорее всего, безвозвратный (если не придётся верстать журналы с кучей картинок). Со своими радостями. Со своими горестями. С кучкой открытий. Которыми готов делиться — пишите, спрашивайте.
Как говорится, happy TeXing! | https://habr.com/ru/post/310344/ | null | ru | null |
# PyRegs: анализатор регулярных выражений Python 3
#### Когда не стало Kodos
Беда пришла неожиданно. Из Debian Wheezy изъяли старый, добрый PyQt3. А с ним на покой отправился и [Kodos](http://kodos.sourceforge.net) — мой любимый дебаггер регулярных выражений Питона. Много лет он помогал тестировать красивые и жуткие конструкци и тот факт, что apt-get install kodos больше не работает, вызвал желание немедленно исправить это досадное недоразумение.
#### Pyregs
##### Под капотом
PyRegs писался с нуля и компоненты выбирались с целью «чтобы работало долго и без лишних танцев с бубном». Python 2.7 под определение *долго* уже не подходит по той простой причине, что в какой-то момент времени его уберут из дистрибутивов GNU/Linux и стандартных пакетов других OS, полностью заменив на Python 3.х. PyQT, PySide, PyWx, PyGObject и т.д. — отличные решения, но танцев с бубном скорее не избежать: в одной ОС что-то есть и работает, в другой — нет или не работает. Но зачем использовать сторонние решения, когда
> Tkinter is Python's de-facto standard GUI (Graphical User Interface) package.
У tkinter немало подводных камней, начиная с того, что Python-код транслируется в команды *tcl* и заканчивая отсутствием некоторых стандартных виджетов вроде tooltip. Чем не вызов программисту?! :) Таким образом выбор технологий стал очевидным: Python 3 + tkinter.
##### Что получилось
Пользователям Kodos интерфейс покажется очень знакомым:
В верхнем текстовом поле вводится регулярное выражение, в среднем — текст и ниже — результаты анализа.
Из невидимых глазу особенностей — обработка текста происходит в отдельном потоке, благодаря чему GUI не подвисает и показывает кол-во обработанного текста в процентах (на практике — такое случается лишь с ооочень сложными выражениями и очень длинным текстом).
##### Камрады!
Прошу вашего внимания, советов, замечаний и идей. Попробовать PyRegs очень просто:
```
$ apt-get install python3-tk
$
$ virtualenv env -p python3
$ . env/bin/activate
$ pip install pyregs
$ pyregs
```
Или: [github.com/BasicWolf/pyregs](https://github.com/BasicWolf/pyregs)
Благодарю за внимание! | https://habr.com/ru/post/183486/ | null | ru | null |
# Продолжаем изобретать function
Под влиянием [предыдущей статьи](http://habrahabr.ru/post/159389/) предлагаю продолжить тему создания собственной реализации такой полезной идиомы, как *function* в C++, и рассмотреть некоторые аспекты ее использования.
Что такое function и зачем писать еще одну
------------------------------------------
Попробую дать краткую вольную формулировку: *это объект, обладающий семантикой значения и позволяющий привести свободные функции и функции-члены классов к единому интерфейсу вызова*. При необходимости, объект сохраняет контекст вызова, речь про *this*, что актуально для функций-членов классов.
Продвинутые реализации, вроде [boost](http://www.boost.org/doc/libs/1_52_0/doc/html/function.html), предлагают такие интересные средства, как адаптирование функций с неподходящей сигнатурой под требуемый интерфейс вызова, а также возможность связывания аргументов с параметрами в момент инициализации. Но, на мой взгляд, подобные возможности лежат за рамками основной темы, заметно раздувают реализацию, но, при этом, далеко не всегда необходимы. Такие средства безусловно удобны и даже иногда полезны, но, по моему субъективному мнению, усложняют чтение и отладку кода. Пусть собственная реализация будет в чем-то проще, обладая при этом такими преимуществами, как, относительная лаконичность и простота.
Мотивация к продолжению поиска
------------------------------
Итак, постановка задачи: требуется класс, параметризуемый сигнатурой функции, определяющей интерфейс вызова, позволяющий связывать и позднее вызывать как свободные функции, так и функции-члены классов, сохраняя для последних контекст вызова. Возвращаясь к решению из [предыдущей статьи](http://habrahabr.ru/post/159389/), отвечает ли оно указанным требованиям, какие у него можно заметить недостатки, поддающиеся исправлению? Решение не сохраняет контекст вызова для функций-членов классов и, таким образом, теряет в универсальности применения. Внутри используются виртуальные функции, наследование и динамическое распределение памяти, что, как будет видно дальше, не является необходимым, можно сделать проще. Оговорюсь, что динамическое распределение памяти считаю основным аспектом, требующим улучшения. При необходимости связать и передать куда-то функцию в коде с высокой частотой вызова, от которого требуется не менее высокая производительность, первая мысль, которая возникает при использовании некой *function*, а не будет ли внутри аллокаций памяти?.. Безусловно, внутри *function* можно предусмотреть фиксированный буфер необходимого консервативного размера, использовать размещение по месту, не забыть про правильное выравнивание, но — есть другой путь.
Своя реализация
---------------
Для решения задачи используется язык C++11. Код проверен в среде Xcode 4.5.2. Реализация C++11 в Visual Studio 2012 запаздывает, но при установке [November 2012 Compiler CTP](http://blogs.msdn.com/b/vcblog/archive/2012/11/02/visual-c-c-11-and-the-future-of-c.aspx) можно получить необходимый для сборки примера уровень ее поддержки, хотя о полноценном практическом применении речи пока нет. В коде есть небольшие реверансы в сторону VS2012 для совместимости. При необходимости, решение можно переписать для C++03 ценой значительного увеличения объема кода, но сохраняя основные преимущества.
Начну с конца. Как может выглядеть надуманный пример использования:
```
#include
#include
#include "function.hpp"
int foo(int v)
{
std::cout << "foo: " << v << std::endl;
return v;
}
struct bar
{
int baz(int v)
{
std::cout << "bar::baz: " << v << std::endl;
return v;
}
};
int main()
{
// объявление синонима типа функции с необходимой сигнатурой вызова
typedef bc::function function\_ptr;
std::vector functions;
// связывание со свободной функцией
functions.push\_back(BC\_BIND(&foo));
// связывание с функцией-членом класса и сохранение контекста ее исполнения
bar obj;
functions.push\_back(BC\_BIND(&bar::baz, &obj));
int i = 0, c = 0;
for (auto f : functions)
c += f ? f(++i) : 0;
std::cout << "result: " << c << std::endl;
}
```
Видно, что в одном контейнере могут располагаться объекты, указывающие на разные свободные функции и функции-члены разных классов. Единственное требование к ним — единый формат параметров и тип возвращаемого значения. Из-за особенностей реализации, для более менее короткой и единообразной записи связывания используется макрос — *BC\_BIND*. Интересно отметить, что макрос принимает разное количество аргументов, один и два, но препроцессор не поддерживает перегрузку одноименных макросов по количеству аргументов, однако, он поддерживает передачу переменного количества аргументов через эллипсис, что в совокупности с некоторой магией позволяет добиться симуляции перегрузки по количеству аргументов. Не буду углубляться далее, самостоятельно разобраться при желании совсем не сложно, только замечу, что Visual C++ и тут проявился своим особым видением стандарта и для совместимости с его препроцессором потребовалась чуточку более сильная магия.
Повествование подходит к самому интересному. Как же можно единообразно хранить разные указатели на разные функции и функции-члены, да еще без динамических аллокаций? Стандарт не говорит чего-либо определенного про размер указателей на функции и их структуру, что позволило бы привести их к общему знаменателю. Если для указателей на свободные функции хотя бы POSIX [требует](http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_12_03) их безопасного преобразования к *void\** и обратно, то для функций-членов ничего подобного нет. Тем не менее, выход есть. Пусть спектр обрабатываемых функций, которые требуется привести к единому интерфейсу вызова, в псевдокоде выглядит так:
```
function function\_ptr;
return\_type free\_function(...);
class Class
{
return\_type member\_function(...);
};
```
Похоже, но неодинаково. Преобразуем второй метод:
```
return_type member_function_wrapper(Class *context, ...)
{
return context->member_function(...);
}
```
Уже лучше. Еще одна итерация:
```
return_type free_function_wrapper(void *unused, ...)
{
return free_function(...);
}
return_type member_function_wrapper(void *context, ...)
{
return static_cast(context)->member\_function(...);
}
```
Отлично, обе функции, *free\_function\_wrapper* и *member\_function\_wrapper* имеют одинаковую сигнатуру. Если с первой вопросов быть не должно, то для второй осталось понять, как внести в ее контекст информацию о классе и сам указатель на функцию-член. И такая возможность тоже есть благодаря шаблонам, которые можно параметризовать не только типами и интегральными константами времени компиляции, но и адресами функций и функций-членов. Простой отвлеченный пример:
```
#include
struct bar
{
int baz(int v)
{
std::cout << "bar::baz: " << v << std::endl;
return v;
}
};
template
int function\_wrapper(void \*self, int v)
{
return (static\_cast(self)->\*MemberFunctionPtr)(v);
}
int main()
{
typedef int (\*function\_ptr)(void\*, int);
function\_ptr f = &function\_wrapper;
bar obj;
int const i = f(&obj, 1);
std::cout << "result: " << i << std::endl;
}
```
Таким образом, в *function* достаточно хранить указатель на инстанцированную с необходимыми параметрами шаблонную функцию-обертку и указатель на контекст, который в случае функции-члена будет равен указателю на экземпляр объекта, в контексте которого должна исполняться функция, а иначе просто *NULL*. Никаких аллокаций памяти, тривиальные конструктор копирования и оператор присваивания — по-моему, здорово.
В заключение осталось привести исходный текст хидера с реализацией из первого примера. Построчно разбирать его смысла не вижу, основная идея обозначена. Отмечу, что обработка разного количества параметров функций реализована при помощи шаблонов с переменным количеством аргументов из C++11 и именно это потребует больше всего дополнительного кода в случае переноса на С++03.
**function.hpp**
```
#pragma once
//#define BC_NO_EXCEPTIONS
#include
#include
#define BC\_SUBST(Arg) Arg
#define BC\_BIND\_DISAMBIGUATE2(has\_args, ...) BC\_SUBST(BC\_BIND\_ ## has\_args (\_\_VA\_ARGS\_\_))
#define BC\_BIND\_DISAMBIGUATE(has\_args, ...) BC\_BIND\_DISAMBIGUATE2(has\_args, \_\_VA\_ARGS\_\_)
#define BC\_HAS\_ARGS\_IMPL(TWO, ONE, N, ...) N
#define BC\_HAS\_ARGS(...) BC\_SUBST(BC\_HAS\_ARGS\_IMPL(\_\_VA\_ARGS\_\_, 2, 1, ERROR))
#define BC\_BIND(...) BC\_BIND\_DISAMBIGUATE(BC\_HAS\_ARGS(\_\_VA\_ARGS\_\_), \_\_VA\_ARGS\_\_)
#define BC\_BIND\_1(fp) bc::detail::bind()
#define BC\_BIND\_2(mf, ip) bc::detail::bind(ip)
namespace bc // bicycle
{
template
class function;
namespace detail
{
template
struct function\_traits;
template
struct function\_traits
{
//typedef ReturnType (\*Signature)(ArgumentTypes...); // MS error C3522: parameter pack cannot be expanded in this context
typedef function function\_type;
template
static ReturnType wrapper(void const \*, ArgumentTypes&& ... args)
{
return (\*fp)(std::forward(args)...);
}
};
template
struct function\_traits
{
//typedef ReturnType (Class::\*Signature)(ArgumentTypes...); // MS error C3522: parameter pack cannot be expanded in this context
typedef Class \* class\_ptr;
typedef function function\_type;
template
static ReturnType wrapper(const void \*ip, ArgumentTypes&& ... args)
{
Class\* instance = const\_cast(static\_cast(ip));
return (instance->\*mf)(std::forward(args)...);
}
};
template
struct function\_traits
{
//typedef ReturnType (Class::\*Signature)(ArgumentTypes...) const; // MS error C3522: parameter pack cannot be expanded in this context
typedef const Class \* class\_ptr;
typedef function function\_type;
template
static ReturnType wrapper(void const \*ip, ArgumentTypes&& ... args)
{
Class const \*instance = static\_cast(ip);
return (instance->\*mf)(std::forward(args)...);
}
};
// bind free function
template
typename function\_traits::function\_type bind()
{
typedef function\_traits traits;
return typename traits::function\_type(&traits::template wrapper, 0);
}
// bind member function
template
typename function\_traits::function\_type bind(typename function\_traits::class\_ptr ip)
{
typedef function\_traits traits;
return typename traits::function\_type(&traits::template wrapper, ip);
}
}
template
class function
{
typedef ReturnType (\*StaticFuncPtr)(void const\*, ArgumentTypes&& ...);
public:
function() : func\_(0), data\_(0) {}
function(StaticFuncPtr f, void const \*d) : func\_(f), data\_(d) {}
ReturnType operator () (ArgumentTypes... args) const
{
#ifndef BC\_NO\_EXCEPTIONS
if (!func\_)
throw std::bad\_function\_call();
#endif // BC\_NO\_EXCEPTIONS
return (\*func\_)(data\_, std::forward(args)...);
}
explicit operator bool() const
{
return 0 != func\_;
}
bool operator == (function const &other) const
{
return func\_ == other.func\_ && data\_ == other.data\_;
}
bool operator != (function const &other) const
{
return !(\*this == other);
}
private:
StaticFuncPtr func\_;
void const \*data\_;
};
}
``` | https://habr.com/ru/post/166589/ | null | ru | null |
# Kubernetes 1.16 — как обновиться и ничего не сломать
Сегодня, 18 сентября, выходит очередная версия Kubernetes — 1.16. Как всегда нас ждет много улучшений и новинок. Но я хотел бы обратить ваше внимание на разделы Action Required файла [CHANGELOG-1.16.md](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.16.md). В этих разделах публикуются изменения, которые могут сломать работу вашего приложения, инструментов по обслуживанию кластера или требуют внесения изменений в файлы конфигурации.
В общем, требуют ручного вмешательства…
Начнем сразу с изменения, которое, скорее всего, затронет всех, кто достаточно долго работает с kubernetes. Kubernetes API перестал поддерживать устаревшие версии API ресурсов.
**Если кто не знал, или забыл...**Версия API ресурса указывается в манифесте, в поле `apiVersion: apps/v1`
А именно:
| | | |
| --- | --- | --- |
| Тип ресурса | Старая версия | На что надо заменить |
| Все ресурсы | apps/v1beta1
apps/v1beta2 | apps/v1 |
| **deployments**
daemonset
replicaset | extensions/v1beta1 | apps/v1 |
| networkpolicies | extensions/v1beta1 | networking.k8s.io/v1 |
| podsecuritypolicies | extensions/v1beta1 | policy/v1beta1 |
Также хочу обратить внимание, что у объектов типа `Ingress` также сменился `apiVersion` на `networking.k8s.io/v1beta1`. Старое значение `extensions/v1beta1` еще поддерживается, но есть хороший повод заодно обновить и эту версию в манифестах.
Достаточно много изменений в различных системных метках (Node labels), которые устанавливаются на узлы.
Kubelet запретили устанавливать произвольные метки (раньше их можно было задавать через ключи запуска `kubelet --node-labels`), оставили только вот этот список [разрешенных](https://github.com/kubernetes/enhancements/blob/master/keps/sig-auth/0000-20170814-bounding-self-labeling-kubelets.md#proposal):
```
kubernetes.io/hostname
kubernetes.io/instance-type
kubernetes.io/os
kubernetes.io/arch
beta.kubernetes.io/instance-type
beta.kubernetes.io/os
beta.kubernetes.io/arch
failure-domain.beta.kubernetes.io/zone
failure-domain.beta.kubernetes.io/region
failure-domain.kubernetes.io/zone
failure-domain.kubernetes.io/region
[*.]kubelet.kubernetes.io/*
[*.]node.kubernetes.io/*
```
Метки `beta.kubernetes.io/metadata-proxy-ready`, `beta.kubernetes.io/masq-agent-ds-ready` и `beta.kubernetes.io/kube-proxy-ds-ready` больше не добавляются на новые узлы, и различные дополнительные компоненты стали использовать немного другие метки в качестве node selector:
| | | |
| --- | --- | --- |
| Компонент | Старая метка | Актуальная метка |
| kube-proxy | beta.kubernetes.io/kube-proxy-ds-ready | node.kubernetes.io/kube-proxy-ds-ready |
| ip-mask-agent | beta.kubernetes.io/masq-agent-ds-ready | node.kubernetes.io/masq-agent-ds-ready |
| metadata-proxy | beta.kubernetes.io/metadata-proxy-ready | cloud.google.com/metadata-proxy-ready |
kubeadm теперь удаляет за собой файл начальной конфигурации кублета `bootstrap-kubelet.conf`. Если ваши инструменты обращались к этому файлу, то переключитесь на использование `kubelet.conf`, в котором хранятся актуальные настройки доступа.
Cadvisor больше не отдает метрики `pod_name` и `container_name`, если вы использовали их в Prometheus, переходите на метрики `pod` и `container` соответственно.
Убрали ключи командой строки:
| | |
| --- | --- |
| Компонент | Убранный ключ |
| hyperkube | --make-symlink |
| kube-proxy | --resource-container |
Шедулер стал использовать версию v1beta1 Event API. Если вы используете сторонние инструменты для взаимодействия с Event API, переключитесь на актуальную версию.
Минутка юмора. В процессе подготовки релиза 1.16 были сделаны следующие изменения:
* убрали аннотацию `scheduler.alpha.kubernetes.io/critical-pod` в версии v1.16.0-alpha.1
* вернули аннотацию `scheduler.alpha.kubernetes.io/critical-pod` в версии v1.16.0-alpha.2
* убрали аннотацию `scheduler.alpha.kubernetes.io/critical-pod` в версии v1.16.0-beta.1
Используйте поле `spec.priorityClassName` для указания важности пода. | https://habr.com/ru/post/467883/ | null | ru | null |
# Zustand — руководство по простому управлению состоянием
Эта статья — перевод оригинальной статьи Madushika Perera "[Zustand’s Guide to Simple State Management](https://blog.bitsrc.io/zustands-guide-to-simple-state-management-12c654c69990)"
Также я веду телеграм канал “[Frontend по-флотски](https://t.me/frontend_pasta)”, где рассказываю про интересные вещи из мира разработки интерфейсов.
Вступление
----------
За последние несколько лет управление состоянием в React претерпело значительные изменения. Многие перешли с Flux на Redux и ищут еще более простые решения. Кроме того, появление React Hooks открыло новые возможности для управления состоянием.
Некоторые из новых библиотек управления состоянием, которые появились на горизонте, — это Recoil, Jotai, Radio Active state и Zustand.
В этой статье я расскажу о Zustand, который предоставляет легкий и простой способ управления состоянием в React.
Что такое Zustand?
------------------
Zustand — это библиотека управления состоянием с открытым исходным кодом, разработанная создателями Jotai и React-spring (лучшая библиотека анимации React). Он уже набрал более чем 50 000 еженедельных загрузок.
На данный момент это одна из самых легких библиотек управления состоянием, ее размер составляет 1,5 КБ. Несмотря на то, что она легкая, она решает некоторые важные проблемы, такие как:
* [Zombie Children](https://react-redux.js.org/api/hooks#stale-props-and-zombie-children)
* [Параллельность в React](https://github.com/bvaughn/rfcs/blob/useMutableSource/text/0000-use-mutable-source.md)
* [Потерю контекста](https://github.com/facebook/react/issues/13332)
Чем он отличается от остальных?
-------------------------------
Вы можете задаться вопросом, почему те же создатели Jotai создали Zustand? Это два противоположных подхода. Jotai стремится предоставить простое решение для **useState** и **useContext**, создавая атомарное состояние (точно так же, как Recoil).
Zustand использует внешнее хранилище и предоставляет несколько хуков для его подключения.
Тогда, разве это не больше похоже на Redux? Если мы сравним Zustand с Redux, одно из основных отличий — это требуемый шаблонный код. Zustand требует меньше из-за своего самоуверенного подхода. Кроме того, сочетание следующих функций делает его уникальным;
* Он не оборачивает приложение в провайдеров контекста.
* Он позволяет добавлять функции подписчика, чтобы компоненты могли привязываться к состоянию без повторного рендеринга при мимолётных обновлениях.
* Использует мемоизированные селекторы, а функция React **useCallback** API позволяет оптимизировать производительность в параллельном режиме.
* Он довольно хорошо поддерживает middlewar. Вы можете подключить его к таким библиотекам, как Immer, чтобы сократить код в редьюсерах и внести изменения во вложенное состояние.
Начинаем с React и Zustand
--------------------------
Давайте посмотрим, как Zustand работает с React. Чтобы продемонстрировать его возможности, я создам небольшое приложение Pokemon. Это приложение состоит из хранилища, компонента списка и формы ввода, которая обрабатывает ввод пользователя.
### Шаг 1. Установка
Установка Zustand так же проста, как установка любого из пакетов npm. Давайте установим его с помощью npm или yarn.
```
npm install zustand
yarn add zustand
```
### Шаг 2. Создаём хранилище
Далее давайте создадим хранилище, как и в любой другой библиотеке управления состоянием.
```
import create from "zustand";
const useStore = create((set) => ({
pokemons: [{ id: 1, name: "Bulbasaur" },
{ id: 2, name: "Ivysaur" },
{ id: 3, name: "Venusaur" },
{ id: 4, name: "Charmander" },
{ id: 5, name: "Charmeleon" },
],
addPokemons: (pokemon) =>
set((state) => ({
pokemons: [
{ name: pokemon.name, id: Math.random() * 100 },
...state.pokemons,
]})),
removePokemon: (id) =>
set((state) => ({
pokemons: state.pokemons.filter((pokemon) => pokemon.id !== id),
})),
}));
export default useStore;
```
Хранилище создается с помощью create API, и экшены могут быть созданы, как показано выше. Доступ к этому хранилищу можно получить через приложение без использования какого-либо провайдера HOC (компонента более высокого порядка), как в Redux.
### Шаг 3. Получаем доступ к хранилищу
Zustand не полностью привязан к React. Его можно использовать с любыми другими библиотеками, такими как Vue или Angular. Давайте посмотрим, как мы можем получить доступ к хранилищу из компонента.
Доступ к состоянию хранилища и отображение данных в виде списка
```
import useStore from "../store";
function List() {
const pokemons = useStore((state) => state.pokemons);
const removePokemon = useStore((state) => state.removePokemon);
return (
{pokemons.map((pokemon) => (
* {pokemon.name}
removePokemon(pokemon.id)}>X
))}
);
}
export default List;
```
Обновляем состояния с помощью формы
```
import { useState } from "react";
import useStore from "../store";
function Form() {
const [name, setName] = useState("");
const addPokemons = useStore((state) => state.addPokemons);
const onChange = (e) => {
setName(e.target.value);
};
const addPokemon = () => {
addPokemons({ name: name });
clear();
};
const clear = () => setName("");
return (
addPokemon()}
>
Add
);
}
export default Form;
```
Как видите, Zustand намного точнее и проще, чем Redux, Recoil или Jotai.
### Шаг 4. Обработка асинхронных экшенов
Одним из реальных применений действия Zustand является получение данных через REST API. Эти экшены мы должны выполнять асинхронно.
```
import axios from "axios";
const useStore = create(set => ({
pokemons: [],
getPokemons: async ()=> {
const response = await axios.get('')
set({ pokemons: response.data })
}
}))
```
Асинхронный экшен можно обработать, используя async/await в JavaScript. В приведенном выше примере вы можете увидеть, как асинхронные экшены запускаются через axios.
### Шаг 5: Middleware для Zustand
Zustand имеет несколько уникальных middleware'ов из коробки. Наиболее известными middleware'ами являются dev tools (использующие инструменты разработки Redux) и Persist, которые могут сохранять данные в браузере.
```
let useStore : (set)=>{
/* state and actions */
};
useStore = persist(useStore, { name: 'Bulbasaur' })
useStore = devtools(useStore)
export default useStore = create(useStore);
```
С Zustand вы также можете создать собственный middleware и плагин.
Заключение
----------
В заключение, библиотека Zustand — одна из самых легких библиотек управления состоянием. Он также обеспечивает гибкость для расширения своей функциональности с помощью подключаемых модулей и middlerware для улучшения опыта разработки.
Например, Zustand позволяет получить доступ к хранилищу вне React и совместим с Redux DevTools, Persist и поддерживает React Hooks, TypeScript и т. д.
Таким образом, Zustand выглядит отличным кандидатом на пост управления состоянием в приложении. Простота библиотеки также делает ее хорошим вариантом для начинающих.
Наконец, спасибо, что нашли время, чтобы прочитать это. Я хотел бы видеть ваши вопросы и комментарии ниже.
Ваше здоровье! | https://habr.com/ru/post/661411/ | null | ru | null |
# Интеграция ASP.NET MVC 3 приложений с Facebook OAuth API. Часть 1: Авторизация
Зачем нужна авторизация на вашем сайте через [Facebook](http://facebook.com)?
На данный момент в социальной сети Facebook более 500 млн. пользователей. Многие сайты предоставляют возможность авторизироваться без дополнительной регистрации, где нужно заполнять много полей информации о себе. Если у вас есть аккаунт на Facebook, то вам достаточно войти на сайт используя его. Это экономит время, ведь регистрация нередко требует потратить минут 5-10.
Если вы реализуете авторизацию через Facebook, то скорее всего сможете получить больше пользователей на сайте, ведь не каждому хочется проходить этап регистрации ради написания нескольких комментариев.
Итак, приступим…
Перед созданием приложения необходимо зарегистрировать ваш сайт на Facebook
[developers.facebook.com/setup](http://developers.facebook.com/setup/)
После регистрации вы получите 2 ключа: App ID и App Secret.
А теперь создадим новое приложение ASP.NET MVC 3.
Нам придется работать с Json, поэтому библиотеку вы можете скачать [тут](http://json.codeplex.com/releases/view/64935) и подключить в проекту:
`using Newtonsoft.Json.Linq;`
Или воспользоваться менеджером пакетов NuGet и написать "`Install-Package Newtonsoft.Json`"
Для начала подгружаем JavaScript SDK на нашу страницу.
> `Copy Source | Copy HTML1. $(document).ready(function () {
> 2. if (document.getElementById('fb-root') != undefined) {
> 3. var e = document.createElement('script');
> 4. e.type = 'text/javascript';
> 5. e.src = document.location.protocol + '//connect.facebook.net/en\_US/all.js';
> 6. e.async = true;
> 7. document.getElementById('fb-root').appendChild(e);
> 8. }
> 9. });`
Далее инициализируем нашу страницу при помощи App Id, который был получен при регистрации домена на Фейсбуке.
> `Copy Source | Copy HTML1. FB.init({
> 2. appId:'YOUR\_APP\_ID', cookie:true,
> 3. status:true, xfbml:true
> 4. });`
Отобразим кнопку входа через Facebook на странице сайта.
> `Copy Source | Copy HTML1. <fb:login-button perms="email,user\_checkins"
> 2. onlogin="onConnect();" autologoutlink="false">
> 3. fb:login-button>`
Здесь используется пространство имен `xmlns:fb="http://www.facebook.com/2008/fbml"`.
Сгенерировать кнопку можно [тут](http://developers.facebook.com/docs/reference/plugins/login/).
Событие *onlogin* кнопки *fb-button* вызывается после подтверждения или отмены авторизации в всплывающем окне
На событие *onlogin* вызывается метод *onConnect()*, в котором мы получаем
*access\_token*.
> `Copy Source | Copy HTML1. function onConnect() {
> 2. FB.getLoginStatus(function (response) {
> 3. if (response.session) {
> 4. window.location = "../Account/FbLogin?token=" + response.session.access\_token;
> 5. } else {
> 6. // if user cancel
> 7. }
> 8. });
> 9. };`
Это ключ можно использовать для получения информации о пользователе. Вызывается метод *FbLogin()* контроллера *AccountController*, который получает информацию о пользователе:
> `Copy Source | Copy HTML1. public ActionResult FbLogin(string token)
> 2. {
> 3. WebClient client = new WebClient();
> 4. string JsonResult = client.DownloadString(string.Concat("https://graph.facebook.com/me?access\_token=", token));
> 5. JObject jsonUserInfo = JObject.Parse(JsonResult);
> 6. UInt64 facebook\_userID = jsonUserInfo.Value<UInt64>("id");
> 7. string username = jsonUserInfo.Value<string>("username");
> 8. string email = jsonUserInfo.Value<string>("email");
> 9. //можем сохранить эту информацию
> 10. FormsAuthentication.SetAuthCookie(username, true);
> 11. return RedirectToAction("Index", "Home");
> 12. }`
Какую информацию можно получить у пользователя можно посмотреть [тут](http://developers.facebook.com/docs/reference/api/user/).
Весь код *\_LogOnPartial.cshtml*:
> `Copy Source | Copy HTML1. @if (Request.IsAuthenticated)
> 2. {
> 3. <text>Welcome <strong>@User.Identity.Namestrong>! [ @Html.ActionLink("Log Off", "LogOff", "Account") ]text>
> 4. }
> 5. else
> 6. {
> 7. <fb:login-button perms="email,user\_checkins" onlogin="onConnect();" autologoutlink="false">fb:login-button>
> 8. <div id="fb-script" st yle="display: inline; margin-left: 20px;">
> 9. div>
> 10. @:[ @Html.ActionLink("Log On", "LogOn", "Account") ]
> 11. }
> 12. <script language="javascript" type="text/javascript">
> 13. window.fbAsyncInit = function () {
> 14. FB.init({ appId: '177572352298948', status: true, cookie: false, xfbml: true });
> 15. };
> 16. function afterConnect() {
> 17. FB.getLoginStatus(function (response) {
> 18. if (response.session) {
> 19. window.location = "../Account/FbLogin?token=" + response.session.access\_token;
> 20. } else {
> 21. // if user cancel
> 22. }
> 23. });
> 24. };
> 25. $(document).ready(function () {
> 26. if (document.getElementById('fb-root') != undefined) {
> 27. var e = document.createElement('script');
> 28. e.type = 'text/javascript';
> 29. e.src = document.location.protocol + '//connect.facebook.net/en\_US/all.js';
> 30. e.async = true;
> 31. document.getElementById('fb-root').appendChild(e);
> 32. }
> 33. });
> 34. script>`
До авторизации:
После авторизации:
 | https://habr.com/ru/post/120837/ | null | ru | null |
# Проблема с периодически долго выполняемыми запросами в MS SQL Server
### Предисловие
Есть информационная система, которую я администрирую. Система состоит из следующих компонент:
**1.** База данных MS SQL Server
**2.** Серверное приложение
**3.** Клиентские приложения
Данные информационные системы установлены на нескольких объектах. Информационная система активно и круглосуточно используется одновременно от 2-х до 20-ти пользователей на каждом объекте. Поэтому нельзя выполнять регламентные работы все и сразу. Т е приходится дефрагментацию индексов размазывать на целый день, а не одним махом все нужные фрагментированные индексы дефрагментировать. Аналогично и с другими работами.
Автообновление статистики выставлено в свойствах самой базы данных. Также статистика обновляется по дефрагментированному индексу.
### Проблема
Около года назад столкнулся со следующей проблемой:
Периодически все запросы выполнялись долго. Причем время торможений были случайными. Это происходило на каждом объекте в случайный день. Более того, когда стал анализировать как часто происходят торможения (профайлером), то удалось выяснить, что они происходят каждый день в случайное время. Просто пользователи не всегда обращают на это внимание, а воспринимают как единственную случайную задержку, и потом система опять быстро работает.
### Путь к спасению
Были пересмотрены сами запросы, которые выполнялись долго. Но самое интересное, это то, что все запросы в случайное время выполнялись долго. Даже самые простые типа вытащить последнюю запись из таблицы в несколько тысяч строк.
Далее, были проведены следующие работы:
1. Проанализированы журналы MS SQL Server и Windows Server – причину торможений не удалось найти
2. Проанализированы индексы (фрагментация и т д) – добавлены недостающие и удалены неиспользуемые
3. Проанализированы запросы – улучшены некоторые запросы
4. Проанализированы задания в SQL Agent – не удалось задачи привязать к проблеме торможений
5. Проанализированы задания в Планировщике заданий – не удалось задачи привязать к проблеме торможений
6. Profiler тоже выдавал следствие, а не причину торможений.
7. Проведена проверка на взаимоблокировки – не было выявлено долгих блокировок вообще
В итоге было потрачено более 3-х месяцев на безуспешные поиски причины периодических торможений. Однако, удалось выявить интересный факт – у всех запросов вырастал показатель ожидания Elapsed, а не сам показатель выполнения Worker. Что натолкнуло на то, что возможно что-то с дисками. Тоже их проверил — все нормально.
### Решение
Удивительным было то, что случайным образом удалось установить, что когда запрос в приложении выполняется медленно, то в самом SSMS он выполняется быстро. Тогда для решения помогла [следующая статья](http://www.somewheresomehow.ru/fast-in-ssms-slow-in-app-part1/) (она по крайней мере в последствии натолкнула на идею).
Из этой статьи процитирую следующий абзац:
> На практике наиболее важной опцией SET является ARITHABORT, потому что значение по-умолчанию для этой опции отличается для приложений и для SQL Server Management Studio. Это объясняет, почему вы можете обнаружить медленный запрос в вашем приложении, и затем получить хорошую скорость, выполняя его в SSMS. Приложение использует план, который был построен для набора значений отличающегося от актуальных, правильных значений. Тогда как если вы запускаете запрос в SSMS, то вероятнее всего в кэше пока еще не имеется плана выполнения для ARITHABORT ON, и поэтому SQL Server построит план для ваших текущих значений.
Разница в выполнении была в параметре *SET ARITHABORT*. Для всех запросов, выполняемых в SSMS этот параметр включен, а для запросов из вне (из приложений) – выключен. И его нельзя включить даже простым запросом для приложений:
```
SET ARITHABORT ON;
```
После этого последовала безумная идея – в момент зависания очищать процедурный кэш: [клик](https://msdn.microsoft.com/ru-ru/library/ms174283.aspx).
Для последующей ручной проверки перед запросом в SSMS необходимо писать:
```
SET ARITHABORT OFF;
```
Тогда запрос будет выполняться, как если бы он пришел из приложения. Когда запрос выполнялся долго, то я очищал процедурный кэш. И всегда это лечило. Т е до чистки процедурного кэша, запрос мог выполняться до 20-30 секунд, а после – 0 секунд.
После этого был поставлен еще один эксперимент – чистка всего процедурного кэша для всей базы данных каждый час через SQL Agent:
```
--очищаем кэш по id БД
DBCC FLUSHPROCINDB(@db_id);
```
После этого все запросы стали просто выполняться очень быстро (менее 0,05 сек.), были лишь единичные выбросы до 5-10 секунд выполнения, но пользователи уже зависаний не замечали. Более того, обновление статистики не улучшало результаты, поэтому я убрал обновление статистики.
После еще нескольких месяцев исследований удалось установить, что единичные зависания происходят, когда на самом сервере либо все съедает кэш, и свободной памяти ничего не остается или остается, но меньше 1 ГБ ОЗУ, либо служба MS SQL Server съедает всю выделенную ей оперативную память (через Диспетчер задач). Но второе происходило всего 2 раза за все исследование.
Дело в том, что в кэш записывается в буквальном смысле все, а вот освобождается кэш не всегда вовремя. Проблему с кэшем удалось решить с помощью программы [EmptyStandbyList.exe](http://www.downloadcrew.com/article/34150-empty_standby_list).
Данное приложение настроил через Планировщик задач на выполнение 1 раз каждый час. После проделанных работ уже более полугода нет торможений по запросам на всех объектах.
Единственное, что осталось непонятным, так это редкие случаи, когда один запрос зависнет на 5-10 секунд 1 раз в месяц в случайный день и в случайное время. Всего было за полгода 4 таких случая и то на двух объектах, а не на всех. При этом служба MS SQL Server съедает на короткое время всю выделенную ей оперативную память.
Проделал шаги, описанные [в статье](https://blogs.technet.microsoft.com/sqlruteam/2014/02/09/173/), но данное решение не помогло.
В принципе можно было и не копать глубже, т к пользователи зависания не замечают и все работает, но если у кого есть какие-то соображения-поделитесь, буду признателен.
Данную статью написал с целью помощи тем, кто наткнется на подобные проблемы, т к комплексного ответа в интернете я не нашел, и было потрачено очень много времени на исследование проблемы и ее решения.
### Источники
» [Раз](http://infostart.ru/public/237919/) ⬝ [Два](https://habrahabr.ru/post/226335/) ⬝ [Три](https://blogs.technet.microsoft.com/sqlruteam/2014/02/09/173/) ⬝ [Четыре](https://social.technet.microsoft.com/Forums/ru-RU/cd60a4a5-4bb4-4ad9-b498-457bdf141c89/windows-server-2008-64-bit-?forum=ws2008r2ru) ⬝ [Пять](http://winitpro.ru/index.php/2016/03/21/vysokaya-zagruzka-ram-metafaylom-na-fajlovom-servere-windows/) ⬝ [Шесть](https://habrahabr.ru/sandbox/83961/) ⬝ [Семь](http://www.somewheresomehow.ru/fast-in-ssms-slow-in-app-part1/) ⬝ [Восемь](https://msdn.microsoft.com/ru-ru/library/ms174283.aspx) | https://habr.com/ru/post/313998/ | null | ru | null |
# Как связать Rstudio с Github: актуально для пользователей Mac OS
Design фото создан(а) rawpixel.com - ru.freepik.comВ данной заметке рассмотрим, как связать Rstudio с вашим аккаунтом на Github. Отмечу сразу, данная заметка подойдет тем, кто работает через операционную систему mac os.
Мы будем исходить из трех ограничений:
1. Вы уже установили git.
Тут все просто. Обычно, при запуске Rstudio, mac os выдает уведомление о том, что вам необходимо установить git. Если такого уведомления нет, то скорее всего, git уже установлен.
2. Вы создали аккаунт на Github.
3. Вы знаете, зачем вам связывать Github и Rstudio.
Переходим к настройке в Rstudio
-------------------------------
* Запустите Rstudio на своем macbook.
* Вам понадобится узнать путь, где лежит файл git. Для этого перейдите в терминал и введите команду `which git`. Это можно сделать через Rstudio. Обычно этот путь выглядит как: `/usr/bin/git`
* Далее нужно зайти в настройки Rstudio:
+ *Tools > Global Options > Git/SVN*
+ Активировать “**Enable version control interface for RStudio projects”**
+ Если путь к файлу не добавился автоматически, вам понадобится указать этот путь вручную.
+ Последнее, что вам нужно сделать - это сгенерировать **SSH key** и скопировать его. Он нам понадобится для дальнейшей настройки.
Переходим к настройке в Github
------------------------------
* Заходим в личный кабинет Github
* Переходим в настройки Github
* Находим пункт **SSH and GPU keys**
+ вам необходимо нажать на кнопку (**New SSH key)**
+ Откроется окно, куда необходимо вставить ключ, который ранее был сгенерирован в Rstudio.
+ Добавить ключ (**Add SSH key**)
* После того, как вы настроили свой SSH-ключ и добавили его в свою учетную запись на GitHub.com, вы можете проверить свое соединение.
+ Откройте терминал
+ Введите следующую команду: `ssh -T git@github.com`
+ Вы можете увидеть такое предупреждение:
`> The authenticity of host 'github.com (IP ADDRESS)' can't be established. > RSA key fingerprint is SHA256:nThbg6kXUpJWGl7E1IGOCspRomTxdCARLviKw6E5SY8. > Are you sure you want to continue connecting (yes/no)?`
+ Убедитесь, что ключ совпадает с тем, что вы создавали. Если все верно, введите команду “yes”.
`Hiusername! You've successfully authenticated, but GitHub does not > provide shell access.`
+ Убедитесь, что полученное сообщение содержит ваше имя пользователя. Если вы получили сообщение об отказе — вам [сюда](https://docs.github.com/en/authentication/troubleshooting-ssh/error-permission-denied-publickey)
Если все прошло успешно, то вы можете приступать к работе. | https://habr.com/ru/post/683768/ | null | ru | null |
# FTP-протокол + WinSocks на примере простого FTP-клиента (зеркала) на ASM!
Это еще одна статья «давно гуляющая» по интернету, и опять, как автор, сделаю перепост. Думаю пригодиться и тут.
##### Введение
В этой статье я не ставлю себе целью пересказать все RFC касающиеся протокола FTP, коих не мало, в них вы сможете найти информацию гораздо полнее, попытаюсь лишь в общих чертах познакомить Вас с протоколом FTP и основными приемами работы с ним со стороны клиента.
##### Общие сведения о протоколе FTP
Итак, FTP (File Transfer Protocol) – протокол передачи файлов в сетях стандарта TCP/IP. Этот протокол был специально создан для облегчения и стандартизации программирования алгоритмов передачи файлов между клиентом и сервером. Как и все протоколы высокого уровня, он не занимается непосредственной передачей данных (этим занимается протокол более низкого уровня – TCP, а так же протоколы ниже), а лишь описывает способ «общения» клиент-сервер.
Перейдем непосредственно к описанию протокола. Отличительной его особенностью является использование двух соединений между сервером и клиентом. Одно соединение (командное или управляющее) используется для передачи команд серверу, а так же приема ответов на эти команды. Второе соединение (соединение данных) используется непосредственно для приема или передачи данных. Управляющее соединение всегда происходит со стороны клиента на порт сервера 21 и остается на протяжении всего сеанса работы открытым. Соединение данных открывается и закрывается по мере необходимости в приеме или получении данных.
После того как установлено управляющее соединение клиент может отправлять по нему серверу различные команды. Каждая команда представляет из себя 3 или 4 заглавных символа ASCII, за которыми после одного или более пробелов следуют, в некоторых командах не обязательные аргументы. Любая команда заканчивается парой CR, LF – это, несомненно, известные всем 0dh, 0ah – если речь идет о DOS/Windows. В общих чертах схема команды такая:
**Команда [аргумент(ы)] CR, LF.**
Всего существует чуть более 30 команд (в RFC959 – 33) которые могут быть посланы серверу, но это совсем не значит что сервер все их будет поддерживать. Приведу пример наиболее часто используемых команд.
**USER имя пользователя**
Указывает имя пользователя
**PASS пароль**
Указывает пароль пользователя
**LIST список файлов**
Запрос списка файлов
**PORT n1,n2,n3,n4,n5,n6**
Указание IP и порта для соединения данных
**RETR имя файла**
Получить файл с сервера
**STOR имя файла**
Положить файл на сервер
**TYPE тип**
Тип передаваемых данных
**QUIT**
Отключение от сервера
**ABOR**
Отмена предыдущее команды. Прекращение передачи данных.
При получении запроса сервер, по тому же управляющему соединению отправляет ответ на него. Ответ сервера состоит из трех символов (цифр) в формате ASCII, за которыми следует не обязательный текст, обычно поясняющий цифирный код ответа, за этим пояснением следуют неизменные CR, LF. Ответ например может быть таким: 226 File send OK. – в этом примере сервер сообщает нам о том, что файл отправлен с его стороны (что совсем не означает, что он уже получен со стороны клиента). Первая цифра отклика сервера наиболее значимая, и дает однозначное представление о том как выполнилась (или не выполнилась) команда. Значения могут быть такими:
* **1хх** Команда находится в процессе выполнения, необходимо дождаться еще одного сообщения перед тем, как давать следующую команду.
* **2хх** Команда выполнена. Сервер находится в ожидании следующей.
* **3хх** Команда выполнена, но для продолжения необходима еще одна команда
* **4хх** Команда не была выполнена, необходимо подождать и повторить команду
* **5хх** Команда не была выполнена и не будет выполнена при повторе.
По второй цифре отклика можно судить о том, какая ситуация привела к возникновению отклика:
* **x0x** Ошибка синтаксиса.
* **x1x** Информация.
* **x2x** Отклик относится к состоянию управляющего или соединению данных.
* **x3x** Отклик относится к аутентификации пользователя или состоянию бюджета.
* **x4x** Не определенно.
* **x5x** Отклик относится к состоянию файловой системы.
Ну и наконец третья цифра отклика несет в себе дополнительную информацию.
Следует обратить особое внимание на то, что хотя на большую часть команд сервер отвечает одним откликом, есть и широко используются команды, в ответ на которые сервер генерирует несколько откликов. При этом первая цифра первого отклика будет «1» — т.е. если взглянуть на таблицы выше, сервер сообщает нам о том, что необходимо подождать еще одного сообщения от него, перед тем, как посылать следующую команду. Примером такой команды может служить команда RETR, когда сервер принимает ее и начинает пересылку данных он отвечает нам что-то вроде: «150 Opening BINARY mode data connection for HIDE.ASM (958 bytes).» — смысл сообщения сводится к «начата передача данных». Затем, когда данные им уже будут отправлены (но опять хочу заострить внимание – не факт, что получены клиентом) он отправит по управляющему соединению еще один отклик – «226 File send OK.» — т.е. «файл отправлен». Вот в этом случае только после получения второго сообщения сервер готов к выполнению следующей команды. Вместо последнего сообщения мы вполне можем получить сообщение с ошибкой начинающееся с «4» — в том случае, если возникнут какие-либо проблемы с передачей файла.
В общих чертах это все, что касается управляющего соединения.
Теперь поговорим о соединении данных. Как уже говорилось выше, соединение данных организуется по мере необходимости, и закрывается каждый раз после передачи или приема данных. Так происходит потому, что режим передачи данных между клиентом и сервером – потоковый, а в таком режиме окончание передачи данных – закрытие соединения. Из вышесказанного мы должны сделать один немаловажный вывод – судить об окончании передачи данных со стороны сервера мы можем по закрытию соединения.
Обычно соединение данных открывается следующим образом:
* клиент выбирает свободный порт на своем хосте и осуществляет пассивное открытие на него;
* клиент сообщает серверу по управляющему соединению свой IP-адрес и номер порта, на который сделал пассивное открытие;
* сервер, получив порт и IP-адрес осуществляет его активное открытие;
* передаются или принимаются данные;
* в зависимости от того кто передает, а кто принимает данные осуществляется закрытие порта.
Небольшое отступление: если вы внимательно прочтете второй пункт, может возникнуть вопрос – «А что будет если мы передадим серверу фиктивный адрес и порт?». Ответ неоднозначен, сервер может проверять IP-адрес, но это происходит не всегда, поэтому существуют некоторые интересные «заморочки» с использованием фиктивных адресов.
Что касается порта, выбираемого для соединения данных клиентом. Обычно используется динамически назначаемый ОС порт, — т.е. делается запрос к системе, она дает первый свободный. Если клиент не указывает серверу порт для соединения, оно происходит на порт с которого было проведено управляющее соединение (поступать так не рекомендуется). Сервер всегда осуществляет соединение данных с 20-го порта.
Это все основное, что я хотел рассказать о соединении данных.
Теперь, когда мы знаем для чего и как работают оба соединения, хочу отметить еще один момент (при первом прочтении можно пропустить). Команда LIST возвращает список файлов текущей директории, и возвращает его по соединению данных. Список представляет из себя набор строк ASCII оканчивающихся символами CR, LF. Каждая строка несет в себе информацию об одном из элементов запрашиваемого каталога. Общий шаблон этой строки такой:
**Txxxxxxxxx[ ]uk[ ]user[ ]group[ ]size[ ]mm[ ]dd[ ]yytt[ ]name CR, LF**
где,
**T** – тип элемента («d» — каталог, «-» — файл, «l» — ссылка и т.д.);
**xxxxxxxxx** – атрибуты защиты файла;
**user** – пользователь, владелец файла;
**group** – группа владельца;
**size** — размер элемента;
**mm** – месяц создания элемента в текстовом виде, например «jul»;
**dd** – день месяца создания элемента;
**yytt** – здесь может быть год или время создания элемента;
**name** – имя элемента (файла, каталога, ссылки);
**[ ]** – один или более пробелов.
Да, между этими элементами может быть различное количество пробелов, надо сказать спасибо, что в различных реализациях серверов оставили одно количество значимых столбцов, поэтому при анализе таблицы файлов следует это учитывать. Стоит еще учесть такую вещь, что не всегда первая строка из таблицы есть значимая строка, несущая информацию о первом элементе каталога. В некоторых реализациях FTP-серверов (например ftpd на FreeBSD), первой строкой списка является строка «total NN».
##### Как это должно работать?
Давайте немного отвлечемся и посмотрим, как же должен выглядеть FTP сеанс получения файла «изнутри». Итак, мы запускаем клиента. Сервер в это время уже пассивно открыл и слушает 21-ый порт. В первую очередь нам необходимо создать управляющее соединение – конектимся на сервер на порт 21. Что дальше? Сразу, как только мы удачно законектились с сервером по созданному управляющему соединению нам приходит приветствие от сервера, это будет что-то вроде «220 VSFTP deamon base on Alt Linux 2.2, Shpakovsky».
Следующим шагом должна быть регистрация – допустим мы соединяемся с анонимным сервером — по управляющему соединению клиент посылает серверу команду USER anonymous, на что, если сервер поддерживает анонимного пользователя получаем ответ: «331 Please specify the password.» — «пожалуйста сообщите пароль», заметим цифру «3» в ответе сервера, что означает, что для продолжения требуется еще команда, что собственно и делает клиент – посылаем команду PASS 1@1 – в качестве пароля указав фиктивный e-mail. На что получаем ответ сервера «230 Login successful. Have fun.» — «Регистрация прошла успешно».
Все, теперь наши действия зависят от того что мы хотим, а как говорилось выше, хотим мы получить с сервера файл, пусть к примеру это будет файл «HIDE.EXE», расположенный в корневом каталоге сервера. Перед тем, как осуществлять прием или передачу данных серверу необходимо указать какой тип данных будет передаваться, делается это командой TYPE N, где N = «A», если тип ASCII и N = «I», если файл бинарный. Клиент посылает серверу команду TYPE I, на что получает ответ – «200 Switching to Binary mode.».
Итак, осталось только получить файл. Для этого клиенту необходимо открыть соединение данных. Клиентом выбирается свободный порт, осуществляется пассивное открытие, т.е. клиент его «слушает». Дальше клиенту нужно сообщить серверу свой IP-адрес и номер порта, который только что пассивно открыл (допусти IP-адрес хоста клиента будет 10.21.23.10, а номер порта 2000). Клиент посылает серверу по управляющему соединению команду PORT 10,21,23,10,7,208 – «что за 7,208?» — спросите вы. Это и есть номер порта строится он так – 7\*256+208 = 2000. Сервер после получения этой команды попытается сделать активное открытие указанного порта и в случае удачи вернет что-то вроде «200 PORT command successful. Consider using PASV.».
Все, соединение данных установлено остается дать команду передачи данных серверу, что и делает клиент — RETR HIDE.EXE, на что в случае если все нормально (файл существует и может быть передан) сервер отвечает «150 Opening BINARY mode data connection for HIDE.EXE (4096 bytes).» и начинает сливать файл по соединению данных. Опять обращаю ваше внимание на первую цифру ответа. Когда файл будет полностью отправлен сервер пошлет сообщение «226 File send OK.» и произведет закрытие соединения данных.
Клиент ждет окончания получения данных со своей стороны (о чем свидетельствует получение сообщения от сервера + закрытие соединения данных, тут есть ньюансы, но о них позже) после чего закрывает порт соединения данных со своей стороны.
Итак файл получен клиентом, остается разорвать управляющее соединение, клиент посылает команду QUIT, сервер отвечает «221 Goodbye.» и разрывает соединение.
Вот собственно самое важные теоретические сведения о протоколе. Перед тем как переходить к практике очень советую побаловаться управляющим соединением с FTP-сервером, используя telnet, соединение данных создать не получится, но команды и ответы на них будут на виду. Так же рекомендую поработать с каким-либо консольным клиентом FTP и понаблюдать во время всего этого за созданием и закрытием соединений с помощью какой-нибудь утилиты для этого, коих в Интернете как грязи.
##### Реализация.
Теперь о самой реализации. В этой реализации клиента я использую non-blocking (не блокирующие) сокеты, поэтому модель клиента – событийная, т.е. выполнять те или иные действия, касающиеся используемых клиентом сокетов клиент будет только при возникновении соответствующего события (например закрытие соединения, уведомление о получении данных и т.д.). В качестве событий используются сообщения, приходящие в процедуру главного окна. Кроме того, модель программы поточная, используется поток для чтения соединения данных и поток для чтения управляющего соединения, а так же основной поток клиента, запускающийся при нажатии на кнопку «соединение». Так как программа многопоточная для синхронизации работы этих трех потоков (а так же процедуры сообщений главного окна) используются «event’s» («события», не путать эти события, используемые программой как датчик 1 или 0 – произошло или не произошло событие, и события касающиеся сокетов, которые приходят на процедуру главного окна).
Итак, начнем. При создании основного окна приложения мы проводим основную инициализацию программы, поясню основные моменты:
`call VirtualAlloc,ebx,1024000,MEM_COMMIT+MEM_RESERVE,PAGE_READWRITE
mov ReciveDataBufferOffset,eax
call VirtualAlloc,ebx,10240,MEM_COMMIT+MEM_RESERVE,PAGE_READWRITE
mov ReciveCommandBufferOffset,eax
Здесь выделяется память под буфер приема файла (1 Мб) и под буфер команд (10 Кб).
call CreateEventA,ebx,ebx,ebx,ebx
mov HDataReciveEvent,eax
……
Создаются объекты event (события) более подробно о назначении событий позже.
call CreateThread,ebx,ebx,offset ReciveThread,offset ReciveDataThreadStruc, \
NORMAL_PRIORITY_CLASS,offset ThreadID_data
call CreateThread,ebx,ebx,offset ReciveThread,offset ReciveCommandThreadStruc,\
NORMAL_PRIORITY_CLASS,offset ThreadID_command
Создаются 2 потока – один для чтения данных, другой для чтения управляющего потока. Оба этих потока при старте находятся в приостановленном состоянии, и начинают работать только при установлении соответствующего события.
call gethostname, offset HostName,64
call gethostbyname,offset HostName
…..
mov PortInPort,esi
ret 0`
Смысл строк выше в получении IP-адреса нашего хоста, небольшом преобразовании и записи его в отдельное место, адрес хоста нам потребуется для выполнения команды PORT.
На этом процесс начальной инициализации заканчивается, и программа находится в состоянии ожидания команды пользователя. Давайте посмотрим что происходит при нажатии пользователем кнопки «соединиться».
В основной процедуре окна создается главный поток приложения, рассмотрим его ключевые моменты.
Сразу при старте мы инициализируем переменные относящиеся к приему данных и получаем из окна диалога введенные пользователям параметры соединения (сервер, пароль и.д.). После этого нам необходимо создать управляющее соединение с сервером, что мы и делаем:
`- создаем сокет;
call socket, AF_INET, SOCK_STREAM, IPPROTO_TCP
mov ReciveCommandSock,eax
- выбираем неблокирующий режим для сокета, указываем что хотим получать
сообщения о получении новых данных на сокет, а так же о успешном его
приконекчивании.
call WSAAsyncSelect, ReciveCommandSock, newhwnd, WM_COMMANDSOCK,FD_READ+FD_CONNECT
- получаем информацию об удаленном хосте и конектимся к нему
…..
call connect,ReciveCommandSock,offset sockaddr_in,16
- ждем получения события FD_CONNECT, когда оно приходит в процедуру главного окна
обработчик с помощью call SetEvent,HWaitConnectEvent устанавливает событие,
чего мы и ожидаем в следующей строке, если событие не будет установлено в течении
5 секунд, выводим сообщение об ошибке и заканчиваем сеанс связи.
call WaitForSingleObject,HWaitConnectEvent,5000
call ResetEvent,HWaitConnectEvent
- так как после соединения сервер должен послать нам приветствие, ждем его еще 5
секунд, если оно не поступило - выходим. Процедура WaitAnswerRecive описана ниже.
call WaitAnswerRecive,5000
or eax,eax
jnz errorwithregisration`
— входным параметром к функции является интервал, в течении которого, функция будет
ждать ответа сервера, если за указанный интервал ответ не будет получен, функция
выводит сообщение об ошибке и завершается с ненулевым значением регистра eax.
`WaitAnswerRecive proc TimeToWait:dword
call WaitForSingleObject,HWaitCommandEvent,TimeToWait
- ожидаем возникновение события HWaitCommandEvent, которое устанавливается в потоке
получения данных по управляющему соединению, в случае успешного получения данных.
or eax,eax
jz NoTimeOutGet
call MessageBoxA,newhwnd,offset ErrTimeOutCommand,offset ErrorCap,40h
call ResetEvent,HWaitCommandEvent
- сбросили событие HWaitCommandEvent т.к. истек таймаут, и событие осталось в
сигнальном состоянии.
NoTimeOutGet:
ret
WaitAnswerRecive endp`
Теперь пришло время рассмотреть потоки получения данных, как говорилось выше эти потоки создаются в процессе инициализации главного окна, и находятся постоянно в процессе ожидания новых данных, потоки активизируются в процедуре главного окна при получении ей сообщении о том, что есть новые данные, сообщение для управляющего соединения мы определили в самом начале главного потока функцией WSAAsyncSelect, сообщение для соединения данных определяется при создании этого соединения, как мы увидим позже.
Универсальный трэд для получения данных по управляющему и соединению данных приведен ниже.
`- в качестве параметра поток получает адрес структуры ReciveDataThreadStruc
или ReciveCommandThreadStruc в зависимости от предназначения трэда.
Структура для ReciveCommandThreadStruc такая:
- хэндл события по которому трэд активизируется;
HCommandReciveEvent dd ?
- хэндл события, которое устанавливает трэд если все данные успешно получены;
HWaitCommandEvent dd ?
- адрес буфера получения данных;
ReciveCommandBufferOffset dd ?
- здесь содержится общее количество полученных данных;
BytesCommandRecived dd 0
- и наконец, с какого сокета надо получить данные;
ReciveCommandSock dd ?
ReciveThread proc parametr:dword
mov edi,parametr
InfinityLoop:
- ждем возникновения события, что данные можно принимать;
call WaitForSingleObject,dword ptr [edi],-1
- настраиваем esi на место, куда данные будут считаны - адрес буфера+количество
полученных ранее;
mov esi,[edi+8]
add esi,[edi+12]
- получаем не более 4096 байт;
call recv,dword ptr [edi+16],esi,4096,0
- прибавляем к уже полученным ранее, полученные в данный момент;
add [edi+12],eax
- в ebx заносим хэндл события, которое надо установить, если получены все нужные данные;
mov ebx,[edi+4]
- если мы получаем данные по соединению данных то идем к проверке конца получения
данных по соединению данных, иначе - проверяем получили ли мы все данные по
управляющему соединению;
cmp edi,offset ReciveDataThreadStruc
je comparefordata
- по управляющему соединению получены все данные в случае если последние байты ответа
0dh, 0ah, что мы и проверяем;
mov eax,[edi+12]
mov esi,[edi+8]
cmp byte ptr [esi+eax-1],10
je short CallEvent
jmp InfinityLoop
comparefordata:
- по соединению данных получено все, если количество полученных байт = длине файла;
mov eax,[edi+12]
cmp FileLenght,eax
jne InfinityLoop
CallEvent:
- в случае если все данные получены выставляем соответствующее событие;
call SetEvent,ebx
jmp InfinityLoop
ReciveThread endp`
Вернемся теперь к основному потоку, мы успешно получили ответ от сервера, в том что он готов к приему команд, теперь мы можем передавать ему команды, в данной реализации за отправку команд серверу отвечает функция SendCommandInSocket, в основном потоке далее мы вызываем эту функцию для отправки серверу последовательно команд: USER, PASS, TYPE, CWD, PORT и LIST. Сама функция выглядит так:
`- принимает аргументами сокет, в который нужно передать команду, и смещение на буфер,
в котором содержится команда;
SendCommandInSocket proc uses ebx ecx esi edi, hSocket:dword, OutBufOffset:dword
- сначала определяем длину команды;
mov edi,OutBufOffset
push edi
mov eax,0ah
mov ecx,100
repne scasb
sub edi,OutBufOffset
mov ecx,edi
pop esi
push edi
- переносим команду в буфер для приема ответов для сервера, сделано это для того,
что бы потом его можно было сохранить в удобочитаемом виде лога;
mov edi,ReciveCommandBufferOffset
add edi,BytesCommandRecived
rep movsb
pop edi
add BytesCommandRecived,edi
- посылаем команду в сокет;
call send,hSocket,OutBufOffset,edi,ebx
- ждем ответа сервера, с помощью уже описанной выше функции WaitAnswerRecive;
mov eax,5001
Wait2Answer:
dec eax
push eax
call WaitAnswerRecive
or eax,eax
jnz ErrorProcessed
- ответ получен, ищем первый байт ответа, мы его ИЩЕМ, а не просто используем
смещение на конец предпоследнего полученого сообщения, потому, что нами может
быть получено в одном сеансе получения данных обновременно два ответа от сервера.
Уясните себе этот момент.
mov edi,ReciveCommandBufferOffset
mov ecx,BytesCommandRecived
dec ecx
dec ecx
add edi,ecx
mov al,0ah
std
repne scasb
cld
xor eax,eax
- проверяем первый символ ответа;
mov cl,[edi+2]
cmp cl,'1'
- если это "1" то ждем еще одного сообщения от сервера
jz Wait2Answer
cmp cl,'3'
- если ответ больше "3" - произошла ошибка;
jna NoErrorProcessed
call MessageBoxA,newhwnd,edi,offset ErrorCap,40h
ErrorProcessed:
xor eax,eax
inc eax
NoErrorProcessed:
ret
SendCommandInSocket endp`
Необходимо учесть еще одну вещь – перед отправкой команды PORT, нам надо создать слушающий сокет, это мы делаем с помощью вызова процедуры CreateListenSock.
`CreateListenSock proc
pushad
- создаем сокет;
call socket, AF_INET, SOCK_STREAM, IPPROTO_TCP
mov datasock,eax
- переводим его в не-блокирующий режим, указывая, что хотим получать в процедуре
окна сообщения о подтверждении приконекчивания к этому сокету, о поступлении
новых данных, и о закрытии соединения;
call WSAAsyncSelect, datasock, newhwnd, WM_DATASOCK, FD_ACCEPT+FD_READ+FD_CLOSE
- ввязываем сокет с локальным адресом;
mov sin_port,0 ; указываем ноль, в этом случае система даст нам
; первый свободный порт
mov sin_family,AF_INET
mov sin_addr,INADDR_ANY
call bind, datasock, offset sockaddr_in, 16
- получаем инфу о сокете;
call getsockname,datasock,offset sockaddr_in,offset szSockaddr_in
- преобразуем номер порта к нормальному виду;
xor eax,eax
mov ax,sin_port
call ntohs,eax
push eax
shr eax,8
- дальше преобразуем номер порта в символы ASCII;
call DECtoASCII,eax,PortInPort
- и записываем их в шаблон команды PORT
mov al,','
stosb
pop eax
and eax,0ffh
call DECtoASCII,eax,edi
mov ax,0a0dh
stosw
mov esi,PortInPort
- слушаем сокет;
call listen, datasock, 1
popad
ret
CreateListenSock endp`
Итак последней отправленной командой была команда LIST, после нее на соединение данных должен прийти список файлов текущей директории, соответственно после отправки сообщения нам необходимо подождать пока этот список будет нами получен, т.к. даже если сервер отправил нам сообщение о том, что он успешно завершил отправку всех данных это совсем не значит, что наш поток уже все отработал и получил, поэтому мы ожидаем окончания получения функцией WaitTransferComplete.
`- получает в качестве аргумента в течении которого мы буде ждать ОКОНЧАНИЯ получения
данных, после того, как соединение будет закрыто со стороны сервера.
WaitTransferComplete proc uses ecx edi, TimeToWaitEndTransfer:dword
WaitProgress:
- ждем установления события закрытия соединения со стороны сервера, оно устанавливается
в главной процедуре окна;
call WaitForSingleObject,HWaitCloseEvent,-1
- дальше ждем, события успешного получения данных нашим потоком, которое в нем и
устанавливается;
call WaitForSingleObject,HWaitDataEvent,TimeToWaitEndTransfer
or eax,eax
jz CloseDataSocks
- был таймаут, и если мы получаем директорию, то выходим без ошибки, т.к. при получении
директории у нас всегда таймаут, потому, что мы заранее не знаем количество получаемых
байт и поток получения не может установить событие успешного получения;
cmp TimeToWaitEndTransfer,1000 ;если ждем каталог
jz CloseDataSocks
call MessageBoxA,newhwnd,offset ErrTimeOutCommand,offset ErrorCap,40h
CloseDataSocks:
- сбрасываем событие успешного получения;
call ResetEvent,HWaitDataEvent
- закрываем соединение со своей стороны;
call closesocket,ReciveDataSock
call closesocket,datasock
ret
WaitTransferComplete endp`
В случае успешного завершения процедуры выше в буфере приема данных будет лежать таблица каталога. Ниже по программе мы обрабатываем полученную таблицу и по очереди получаем все найденные в ней файлы, получение файла ничем не отличается от получения директории, поэтому здесь этого я описывать не буду. После того, как все файлы были получены и сохранены мы закрываем управляющее соединение и завершаем поток.
##### Заключение.
Мы разобрали основные принципы работы с протоколом FTP со стороны клиента, конечно же были затронуты далеко не все аспекты этой задачи. Например не была рассмотрена отправка файлов на сервер, но думаю, внимательно изучив материал выше, а так же прилагающийся исходный код, можно без проблем сделать и это, пусть дальнейшее изучение протокола FTP со стороны сервера будет вашим «домашним заданием». | https://habr.com/ru/post/111241/ | null | ru | null |
# План-факт, динамика и прибыль на одной диаграмме c помощью R
Каждый раз, когда подводятся финансовые итоги прошедшего года и готовится соответствующая презентация, люди ломают голову, как бы уместить основные цифры на одной диаграмме. Какова бы ни была сфера деятельности организации, подведение итогов, как правило, начинается с анализа основных финансовых показателей, отдельно по каждому из бизнес-направлений:
* оборот в завершившемся году (фактические цифры);
* установленные ранее планы на завершившийся год (для анализа выполнения);
* оборот годом ранее (для понимания динамики);
* прибыльность.
Стандартная столбчатая диаграмма, которую можно на скорую руку построить в Excel, даёт, мягко говоря, не совсем наглядный результат. К примеру, если у бизнеса четыре направления, то на диаграмме появятся 16 рядом стоящих столбцов, и кто-то может с непривычки спутать передовиков и отстающих.
Специалисты, знакомые с R, могут использовать ggplot2 для программного построения нужной диаграммы, например, такой как здесь. Для примера взяты цифры за 2012 год из годового отчета компании Unilever. Плановые показатели не относятся к публичным данным, поэтому пришлось их выдумать из головы, установив, для определенности, на уровне «прошлый год + 5%».
Исходные цифры находятся в Excel и выглядят так (данные в миллионах евро):
Построенная в RStudio диаграмма выглядит следующим образом:
Проверьте диаграмму на интуитивность, и не глядя на цифры, предположите, какому показателю какой элемент диаграммы соответствует, а объяснения будут далее.
Идея в том, чтобы основной параметр — оборот (Turnover) — показывался в виде залитых цветом столбцов, показатель прошлого года (LastYear) — как контур, находящийся визуально позади, плановые показатели (Forecast) в виде «планок», а прибыльность (точнее, противоположная величина — расходы) — небольшой отметкой.
Для чтения данных из Excel используется пакет XLConnect. Из файла Excel, из указанного листа, в R загружается именованная таблица.
Цвета для диаграммы взяты из таблицы корпоративных цветов Unilever.
Итак, код
```
require(XLConnect)
require(data.table)
require(ggplot2)
require(scales)
indata <- readTable(loadWorkbook("Unilever.xlsx"),
sheet = "FinResults",
table = "Unilever2012",
useCachedValues = TRUE)
finreport <- data.table(indata)[, list(
Segment = reorder(Segment, -Turnover),
Cost = (Turnover - Profit),
Forecast, Turnover, LastYear
)]
turnover_format = function(...){
function(x) paste("€B ", format(x/1000, ..., nsmall = 1L, scientific = FALSE, trim = TRUE))
}
chart <- ggplot(finreport, aes(x = Segment)) +
geom_bar(aes(y = LastYear), stat = "identity", color = "#004976", fill = "white", width = 0.9) +
geom_bar(aes(y = Turnover), stat = "identity", color = "white", fill = "#0085CA", width = 0.6) +
geom_crossbar(aes(ymin = Forecast, ymax = Forecast, y = Forecast), color = "#ED8800", width = 0.4, size = 0.7) +
geom_point(aes(y = Cost), shape = 25, color = "#cedc00", fill = "white") +
scale_y_continuous(breaks = pretty_breaks(20), labels = turnover_format()) +
theme_bw() +
theme ( panel.border = element_blank()
, axis.line = element_line()
, axis.title.x = element_blank()
, axis.title.y = element_blank()
, axis.text = element_text( size = 13, color = "#3C1053")
)
print(chart)
```
Исходные данные: Univeler, [годовой отчет и финансовая отчетность 2012](http://www.unilever.ru/Images/ir_Unilever_AR12_tcm13-348376_tcm63-348639.pdf), страница 92. | https://habr.com/ru/post/220135/ | null | ru | null |
# Подключение сторонних инструментов в IntelliJ IDEA на примере pylint
В этом посте я хочу рассказать про довольно интересную фичу `IntelliJ IDEA` — подключение сторонних утилит, а также продемонстрировать её на довольно типичном примере: я подключу `pylint` — анализатор кода для python проектов.
### External Tools
В IDEA есть интересная возможность использовать сторонние утилиты из интерфейса самой IDE. Добавлять таким образом можно всё что угодно — скрипты, анализаторы кода, средства рендеринга ресурсов и подсчета статистики. И IDEA предоставляет несколько крутых решений, обеспечивающих комфорт использования утилит, которые вы подключите.
Ну что, попробуем подключить какой-нибудь тул?
### pylint
[`pylint`](http://www.pylint.org/) — статический анализатор кода для `python`. Его функциональность частично пересекается со встроенным анализатором кода в IDEA, но это не отменяет его полезность во многих случаях. `pylint` проверяет соответствие кода стандартам [PEP8](http://www.python.org/dev/peps/pep-0008/) и анализирует код на потенциальные ошибки.
Обычно `pylint` используют либо через консоль, либо через плагины, но вот для IDEA плагина нет.
Если посмотреть на вывод программы, можно заметить, что каждое замечание относится к конкретной строчке кода и хотелось бы иметь удобную навигацию по файлам и строчкам. Именно этого мы будем добиваться подключением этого тула к IDEA.
### Подключаем pylint к IDEA
Добавить новый сторонний инструмент можно в настройках `Settings -> External Tools`
Как вы наверняка заметили, всё, что надо для того, чтобы программа работала из интерфейса IDEA, нужно всего ничего — указать имя, путь к программе, аргументы и рабочую директорию. Самое интересное здесь — макро-переменные, мощный инструмент взаимодействия программы, юзера и IDE. Взгляните:
Можно передать всё, что угодно: от путей директорий, файлов и проектов до выделенных фрагментов, номеров строчек и полученного из диалогового окошка текста.
В нашем случае нам понадобился только абсолютный путь до файла (почему абсолютный, поясню чуть ниже).
Наконец, мы перейдём к тому, что мы изначально желали — адресации по замечаниям `pylint`. Перейдем в секцию `Output Filters`:
Именно здесь настраивается то, что нам нужно — по регулярному выражению IDEA находит ссылки на строчки в файле.
Всё, можно пользоваться, вызвать наш тул можно из меню `tools`:
Посмотрим на результат запуска:
It works! Таким образом можно внедрять много других полезных штук.
Осталось только сказать про парочку нюансов:
* На данный момент в IDEA есть баг, из-за которого этот самый `pylint` падает на файлах, где есть символы в UTF-8. Вы можете посмотреть/проголосовать за [тикет](http://youtrack.jetbrains.com/issue/IDEA-97788)
* Парсер путей файлов почему-то понимает только абсолютные пути, пути относительно проекта парсить не получается. Именно поэтому `pylint` настроен довольно странно — рабочая папка `/` нужна для того, чтобы в выводе были абсолютные пути файлов.
* `pylint` запускается с особенным ключем `--output-format=parseable` — он меняет формат вывода на более простой для парсинга и понимаемый многими приложениями. | https://habr.com/ru/post/163227/ | null | ru | null |
# AlertDialog setMultiChoiceItems, баг или неочевидная особенность
Привет, Хабр!
#### Вступление
Последние пару месяцев работаю над одним проектом под Android. Но речь сейчас пойдет не о нем, о нем я постараюсь обязательно написать, но всему свое время
За все время работы над проектом, случалось (и случается) много интересного. Сегодня я хочу рассказать одну небольшую историю.
#### Начало истории
Как-то вечером, совсем перед новогодними праздниками, работая в офисе и попивая любимый чаек, писал я очередную часть функционала для проекта.
Понадобилось мне создать обычный диалог, с возможностью множественного выбора элементов из списка, с возможностью сразу отметить\снять отметку со всех элементов, сохранить выбранные элементы и при последующим отображением диалога сразу их отметить.
Сказано — сделано.
Собственно сам код:
```
protected ArrayList items;
protected ArrayList selectedItems;
protected void showMyDialog() {
int count = items.size();
boolean[] checkedItems = new boolean[count];
for (int i = 0; i < count; i++)
checkedItems[i] = selectedItems.contains(items.get(i));
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMultiChoiceItems(items.toArray(new String[items.size()]),
checkedItems, new DialogInterface.OnMultiChoiceClickListener() {
@Override
public void onClick(DialogInterface dialog, int which,
boolean isChecked) {
ListView list = ((AlertDialog) dialog).getListView();
if (isChecked) {
if (which == 0) {
for (int i = 0; i < list.getCount(); ++i)
list.setItemChecked(i, true);
selectedItems.clear();
selectedItems.addAll(items);
} else
selectedItems.add(items.get(which));
} else {
if (which == 0) {
for (int i = 0; i < list.getCount(); ++i)
list.setItemChecked(i, false);
selectedItems.clear();
} else
selectedItems.remove(items.get(which));
}
}
});
AlertDialog dialog = builder.create();
dialog.requestWindowFeature(Window.FEATURE\_NO\_TITLE);
dialog.show();
}
```
Казалось бы, проблема решена, можно протестировать и идти с чистой совестью отдыхать(ну ладно, поиграть в WOT=) ).
Кнопка отметить\снять отметку со всех элементов работала. Но потом я заметил, если отметить вначале самому пару элементов, потом кнопкой отметить все элементы и сразу же снять отметку со всех, то те пару элементов, которые отмечал сам, остаются отмеченными.
Немного поэкспериментировав, решил, что пора идти отдыхать и продолжить разбираться утром. Перед уходом поднял этот вопрос на [stackoverflow](http://stackoverflow.com/questions/8659858/alertdialog-listview-uncheck).
Утром придя на работу, просмотрев свою тему и не увидев никаких дельных советов, продолжил разбор дальше.
После не продолжительного анализа происходящего, стало понятно, что проблема воспроизводится, только если в функцию
`setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems, OnMultiChoiceClickListener listener)`
передавать массив checkedItems, если вместо него передавал null, проблема не возникала.
Поднял снова вопрос на [stackoverflow](http://stackoverflow.com/questions/8667670/alertdialog-listview-setmultichoiceitems), но к сожалению никто так ничего и не посоветовал.
На дворе уже было 29 декабря, да и по проекту еще было много задач, поэтому переписав немного код, без передачи массива, проблема была решена.
Сообщив о найденной проблеме в [багтрекер гугла](http://code.google.com/p/android/issues/detail?id=23680) и продолжив работу дальше, я и забыл про эту историю.
#### Наши дни
Сегодня, просматривая почту, увидел, что кто-то откликнулся на мой багрепорт. После просмотра стало понятно, что еще пару человек столкнулись с этой же проблемой.
Разобравшись немного с делами, решил ещё раз взглянуть на проблему.
В голову пришла идея, хотя мне казалось, что она уже приходила и я её проверял, я проверил еще раз.
Суть идеи заключалась в том, чтобы массив checkedItems сделать полем класса, и в слушателе работать и с ним тоже.
В итоге, метод onClick принял вид:
```
public void onClick(DialogInterface dialog, int which,
boolean isChecked) {
ListView list = ((AlertDialog) dialog).getListView();
if (isChecked) {
if (which == 0) {
for (int i = 0; i < list.getCount(); ++i)
{
list.setItemChecked(i, true);
checkedItems[i]=true;
}
selectedItems.clear();
selectedItems.addAll(items);
} else
selectedItems.add(items.get(which));
} else {
if (which == 0) {
for (int i = 0; i < list.getCount(); ++i)
{
list.setItemChecked(i, false);
checkedItems[i]=false;
}
selectedItems.clear();
} else
selectedItems.remove(items.get(which));
}
}
```
И таки да, это решило первоначальную проблему.
#### Итог.
Можно сделать вывод, хоть он мне и не нравится:
Если в массиве checkedItems состояние элемента указано как не отмеченное (false), то при отметки он отмечается на экране (но не отмечается в массиве) и при снятии отметки, отметка снимается.
Но если в массиве checkedItems состояние элемента указано как отмеченное (true), то при снятии отметки, элемент все равно остается отмеченным на экране, т.к. он остается отмеченным в массиве.
Вот такая получилась история, надеюсь было интересно и вы не зря потратили время, впрочем как и я.
Спасибо за внимание, если есть вопросы, с радостью отвечу.
В следующей статье хочу рассказать уже о самом проекте, должно быть интересно. | https://habr.com/ru/post/139322/ | null | ru | null |
# $mol — лучшее средство от геморроя
Всем привет, меня зовут Дмитрий Карловский и я… хочу причинить вам боль. Много боли. Я напомню вам обо всех страданиях, что вы исптываете находясь в плену своего любимого js-фреймворка. Я опущу вас на самое дно самой глубокой безысходности. А потом, когда вы совсем отчаетесь и потеряете веру в комьюнити, я подам вам руку помощи и покажу светлое будущее.
Далее вашему представляется текстовая расшифровка одноимённого выступления c [IT Global Meetup #11](http://piter-united.ru/itgm11/). Вы можете [читать её как статью](https://github.com/nin-jin/slides/blob/master/mol/) или же открыть в [интерфейсе проведения презентаций](https://nin-jin.github.io/slides/mol/). Приятного чтения.
Высокоуровневые фреймворки
==========================
Вот выбрали вы фреймворк. Как вы представляете себе работу с ним? Ну, это должен быть богатый набор готовых решений, из которых можно легко и быстро собрать приложение любой сложности.
Примеры таких фреймворков: ExtJS, SAPUI5, VCL.JS, $mol — они предоставляют вам кучу готовых виджетов, от банальных кнопочек, до сложных гридов с сортировками, фильтрацией и прочими прекрасными дамами.
**Но могие ли слышали про них? А многие ли используют их в повседневной работе?**
Не многие. Что странно, не находите?
Низкоуровневые фреймворки
=========================
К сожалению, более популярны сейчас низкоуровневые фреймворки, дающие только самые базовые абстракции над платформой, а всё остальное приходится реализовывать уже руками или искать на просторах интернета, и прикручивать синей изолентой. То есть для каждого проекта мы собираем уникальный высокоуровневый фреймворк на основе низкоуровневого.
Примеры таких фреймворков у всех на слуху. Это: Angular, VueJS, EmberJS и многие другие.
Библиотеки с замашками фреймворка
=================================
В последнее время вновь набрал популярность тренд строить экосистему вокруг отдельных узкоспециализированных библиотек. Тут всё ещё хуже — в каждом проекте приходится сначала собрать из кучи библиотек низкоуровневый фреймворк по своему вкусу, а поверх него уже велосипедить компоненты, которые зачастую не отличаются переиспользуемостью за пределами разрабатываемого проекта.
Наиболее известные примеры: React, Backbone, jQuery
Гибкость или скорость разработки?
=================================
Почему же высокоуровневые фреймворки так не популярны и из проекта в проект мы пилим одни и те же велосипеды?
Дело в том, что большинство из них имеют крайне низкое качество. Они огромные, тормозные, сложные в изучении, а главное — очень дубовые, из-за чего кастомизация их компонент под проект сравнима по трудоёмкости с написанием этих компонент с нуля.
$mol — высокоуровневый, но гибкий
=================================
Но из общего ряда монстров выбивается фреймворк $mol. Он легковесней и шустрее многих низкоуровневых фреймворков, но при этом идет с богатым набором батареек в комплекте, позволяющих собрать сложное приложение буквально несколькими строками кода.
И это богатство совсем не отягощает конечное приложение, ведь включается в него лишь тот код, что реально необходим.
Сравним размеры
===============
Итак, возьмём наиболее ярких представителей из трёх разных уровней: библиотеку React, низкоуровневый фреймворк Angular и высокоуровневый $mol. Создадим каждым из них по тривиальному статичному приложению и посмотрим какие накладные расходы дают разные инструменты.
| | **Level** | **Proj create** (s) | **Proj size** (KB) | **Deps** | **App size** (KB) | **App start** (ms) |
| --- | --- | --- | --- | --- | --- | --- |
| **React** | Lib | 70 | 120 000 | 892 | **45** | 230 |
| **Angular** | Low | 50 | 160 000 | 752 | **80** | 350 |
| **$mol** | High | 0 | 200 | 0 | **15** | 150 |
Вручную создавать проекты на Реакте и Ангуляре — задача не тривиальная, поэтому используем стандартные кодогенераторы (create-react-app и [angular](https://habrahabr.ru/users/angular/)/cli). Они около минуты генерируют кучу файлов, после чего вы уже можете удалить лишние и добавить нужные.
В $mol же новое приложение создаётся просто созданием директории и расположением в ней нужных вам файлов, без установки восьми сотен зависимостей. Как видите высокоуровневый фреймворк $mol даёт в 3 раза меньшую прибавку к размеру страницы чем одна только библиотека React.
Использование сторонних компонент
=================================
Что обычно нужно для того, чтобы воспользоваться сторонним компонентом?
1. Найти в интернете и выбрать из альтернатив.
2. Установить совместимую версию.
3. Импортировать и зарегистрировать.
4. Воспользоваться.
Не очень удобно, правда?
Использование сторонних $mol компонент
======================================
Основной принцип $mol — автоматизация, так что воспользоваться сторонним компонентом крайне просто.
1. Выбрать компонент из [каталога](http://mol.js.org/).
2. Воспользоваться.
Сборщик сам позаботится о скачивании его исходников и включении их в правильные места результирующих бандлов.
Удаление сторонних компонент
============================
А что обычно приходится делать, когда компонент больше не нужен?
1. Перестать использовать.
2. Не забыть удалить импорт и регистрацию.
3. Не забыть удалить зависимость от него.
Столько всего нужно не забыть, чтобы в вашем приложении не было лишнего кода.
Удаление сторонних $mol компонент
=================================
А что же делать, когда вам больше не нужен какой-либо $mol компонент?
1. Перестать использовать.
Другой основной принцип $mol — не платить за то, что не используешь. А это значит, что достаточно перестать использовать компонент, чтобы он перестал включаться в бандл. Всё крайне просто и надёжно, ведь человеческий фактор исключён полностью.
Версионирование
===============
Допустим, вы нашли два замечательных компонента: красивый datepicker и продвинутый datagrid. Но вот беда, один во всю использует возможности новой версии фреймворка, а другой с ней ещё не совместим. Что же делать, если отказываться от одного из них не хочется, а хочется уже и самим использовать новые возможности, но переписывание всех старых компонент может занять не один месяц?
Несколько версий разом
======================
Вы можете попытаться включить в бандл обе версии фреймворка, но это мало того, что существенно раздует объём приложения, так ещё и скорее всего не заведётся. Хотя бы даже потому, что пакетный менеджер не позволит вам установить одновременно две версии одного фреймворка. А если это даже и удастся, то драки между версиями будет не избежать. Поэтому...
Версионирование в $mol
======================
В $mol модули не имеют версий. Вместо этого они разрабатываются в соответствии с принципом "открытости/закрытости".
1. Любой модуль открыт для расширения интерфейса.
2. Любой модуль закрыт для изменения интерфейса.
Это значит, что вы можете безопасно обновлять все модули до последних ревизий, не беспокоясь о том, что у них изменился API.
Обновление API в $mol
=====================
Но что же делать, когда нужно ввести более удобное API не совместимое с уже существующим? А всё просто — если API не совместимо, то это уже другой модуль с другим именем. Имя может быть и похожее. Например, с увеличенным числом в конце. А раз это будут два разных модуля, то и сосуществовать в проекте они смогут одновременно. При этом у них может быть много общего кода, вплоть до: один — это не более чем легковесный фасад для другого.
На диаграмме вы видите, что гипотетическая новая версия движка рендеринга $mol компонент, при сосуществовании с предыдущей, лишь незначительно увеличит общий объём бандла. Могли ли вы себе представить такое в каком-либо другом фреймворке?
Кстати, не удивляйтесь тому, что модули в $mol такие маленькие, ведь при автоматизации работы с зависимостями, создавать и использовать микроскопические модули — одно удовольствие.
Потоки данных
=============
Вручную рулить потоками данных — настоящий ад. Вы вроде бы продумали все варианты, учли все события, но стоит отдать результат тестировщикам, как на вас потоком начинает валиться куча баг-репортов, являющихся следствием противоречивой логики. Для совладания с оной у вас есть два пути.
1. Стримы событий (streams)
2. Реактивные ячейки (cells)
Стримы событий
==============
В Angular ставку сделали на концепцию стримов, где вы статически настраиваете потоки событий и реакции на них. К сожалению, любое нетривиальное приложение имеет много динамики, а значит составить для него эффективную конфигурацию потоков — настоящая головоломка. Посмотрите только как на стримах выглядит правильное условное ветвление по двум переменным.
```
const Result = Rx.Observable.combineLatest( Pos , Start )
.select( ([ pos , start ])={
return pos < start ? Left : Rx.Observable.of( null )
} )
.switch()
.distinctUntilChanged()
.debounce( 0 )
```
И это ещё довольно простой пример.
Реактивные ячейки
=================
Реактивные ячейки же являются просто контейнерами, которые сами отслеживают зависимости между собой, динамически выстраивая потоки данных наиболее оптимальным образом.
```
@ $mol_mem
result() {
return this.pos() < this.start() ? this.left() : null
}
```
Тут мы просто объявляем свойство, которое является функцией от других свойств, при изменении которых наше тоже будет обновлено наиболее эффективным образом.
Ячейки в $mol
=============
Уверен вы слышали про VueJS или MobX — они как раз основаны на концепции ячеек. Но реализация в $mol — самая продвинутая. Вот, что умеет $mol, чего не умеет ни один другой фреймворк.
1. Синхронный код, но без блокировки потока.
2. Двустороннее непротиворечивое движение данных.
3. Автоматическая установка и сброс индикатора ожидания.
4. Автоматическое распараллеливание неблокирующих задач.
5. Падение и восстановление частей страницы, без падения приложения целиком.
6. Контроль времени жизни объектов.
Да-да, у нас есть деструкторы с предсказуемым моментом исполнения.
Всё это — наглядный пример того, как грамотная архитектура позволяет писать гибкий, умный и эффективный код, не теряя при этом в наглядности и не раздувая его размеры.
Очепятки
========
Наверняка каждый, съевший JavaScript собаку, может припомнить в своей практике не одну увлекательную историю, когда из-за одной маленькой опечатки он пол дня бился с каким-нибудь невозможным багом. Проблема в том, что человек — существо по природе своей невнимательное. Он легко допускает самые глупые ошибки, а потом может не видеть их, смотря на них в упор.
Решением этой проблемы является статическая типизация, позволяющая компьютеру автоматически и за конечное время проверить корректность кода, разгружая мозг программиста от кучи мелочей и позволяя ему концентрироваться на действительно важных вещах.
**Но много ли вы знаете фреймворков, написанных на TypeSript?**
Я знаю всего 4. Это низкоуровневые Angular и CycleJS, а также высокоуровневые VCL.JS, и… $mol. Все остальные попросту непригодны для разработки более-менее крупных проектов. Ну как не пригодны… вам просто нужно каждый год удваивать число разработчиков, чтобы только лишь сохранять прежний темп разработки.
Стилизация сторонних компонент
==============================
Ок, прикрутили мы datepicker, и он даже работает. Да вот беда, выглядит он как белая ворона в чёрном квартале.
Если разработчик компонента во имя великой инкапсуляции изолировал стили с помощью css-in-js, css-modules или даже web-components, то можно вас только поздравить с необходимостью стилизовать сторонний компонент через вязанку костылей. Например, такого рода селекторы у вас могут появиться при необходимости стилизовать дни в выпадающем календарике в datepicker-е.
```
/* No isolation */
.my_date .acme_calendar_day { ... }
/* Angular default isolation */
:host ::ng-deep .calendar ::ng-deep .day { ... }
/* CSSModules isolation */
.date [class*="calendar"] [class*="day"] { ... }
```
Инкапсуляция и изоляция
=======================
Важно понимать разницу между инкапсуляцией и изоляцией.
* Инкапсуляция — возможность работать не зная внутренностей
* Изоляция — невозможность работать со внутренностями
Инкапсуляция позволяет работать со сложной штукой через простой интерфейс, но не мешает и погрузиться во внутренности, когда это действительно необходимо. Изоляция же — гораздо более сильное ограничение, которое связывает нас по рукам и ногам, и заставляет форкать сторонний компонент, чтобы органично вписать его в своё приложение.
Стилизация $mol компонент
=========================
$mol пронизан инкапсуляцией с ног до головы. Но изоляции в нём нет. Вообще. Никакой. Даже в скриптах. Зато в $mol есть глобальные уникальные человекопонятные имена и единые правила стилизации, что своих, что сторонних компонент.
```
/* ( $mol_view as "Day" ) from $mol_calendar */
[mol_calendar_day] { ... }
/* Day from ( $mol_calendar as "Calendar" ) from $mol_date */
[mol_date_calendar_day] { ... }
/* Day from Calendar from $my_date that inherits $mol_date */
[my_date_calendar_day] { ... }
```
В приведённом примере, имя "my\_date\_calendar\_day" формируется автоматически по следующему принципу… Сперва берётся глобальное имя компонента ("my\_date"), потом к нему приклеивается локальное имя календарика в контексте владельца ("calendar") и так далее до нужного компонента, как бы глубоко в иерархии он ни находился.
Генерируемый DOM в $mol
=======================
Самое приятное в стилизации $mol компонент — программисту не надо вручную прописывать портянку классов каждому дом-элементу — они генерируются автоматически исходя из сформированного дерева компонент.
```
03
```
Вы только представьте: можно разрабатывать компонент совершенно не думая о его стилизации, но при этом иметь полный контроль за визуализацией любого дом-элемента. Без костылей, гор копипасты, увеличения специфичности селекторов и прочих гадких штук.
Жёсткие шаблоны
===============
Возьмём первый попавшийся шаблон на Angular из документации.
```
{{title}}
=========
My Heroes
---------
* {{hero.id}}
```
**Что не так с этим кодом?**
С точки зрения поддержки у него две беды: отсутствие уникального класса у каждого элемента и его неимоверная дубовость. Что мы будем делать, если на одной странице из 20 нам потребуется убрать подзаголовок, на другой добавить после него параграф с описанием, а на третьей выводить имена героев до идентификатора, а не после? Вариантов тут не очень много...
Копипаста
=========
Самое простое — скопипастить шаблон несколько раз и поправить его по месту.
```
{{title}}
=========
* {{hero.id}}
```
Но тогда мы получаем очень много дублирования и необходимость эти похожие, но разные дубликаты синхронно рефакторить. Эта мартышкина работа — тот ещё рассадник багов.
Логика в шаблоне
================
Другая крайность — это научить компонент любым выкрутасам, которые от него могут где-либо потребоваться. И каждый раз когда кому-то потребуется что-то ещё — расширять компонент новыми возможностями.
```
{{title}}
=========
My Heroes
---------
{{ description }}
* {{hero.id}}
{{hero.name}} {{hero.id}}
```
С таким подходом компонент очень быстро превращается в большой тяжёлый швейцарский нож, который неудобно использовать и очень сложно поддерживать.
И всё-равно в нём появляется копипаста, когда требуется переставлять элементы местами, добавлять обёртки и другим образом изменять структуру в зависимости от состояния.
Любая динамика в шаблонах — это боль и страдания от программирования на HTML.
Что не так с HTML?
==================
Размышление над проблемами шаблонов неизбежно приводят к мысли, что они… вообще не нужны. Если программист оперирует компонентами, а браузер JS и DOM объектами, то зачем нам эта мимикрия под HTML, не обладающего выразительной мощью для описания компонент? У HTML очень ограниченная модель.
* Словарь атрибутов может быть только один.
* Значения атрибутов — только строки.
* Вложенное дерево может быть только одно.
* Внутри может быть много одноимённых элементов.
Это помимо его крайней многословности. А для компонент нужны: строки, числа, флаги, словари, массивы, пользовательские типы данных, двустороннее и одностороннее связывания свойств, уникальное имя каждого подкомпонента, наследование, смешивание, частичное переопределение и, наконец, программная логика написанная на полноценном языке программирования. Всё это с очень тугим скрипом натягивается на стержень HTML. Поэтому..
Композиция во view.tree
=======================
В $mol вообще нет шаблонов.
Никакого больше подражания HTML-у — только компоненты и их взаимоотношения. В $mol есть простой и наглядный язык для композиции компонент, который позволяет в декларативной форме описать какой компонент в каком лежит, какое имя в нём имеет и как с ним связан. Он настолько прост, что я научу вас его основам всего за 5 минут.
Простейший $mol компонент на view.tree
======================================
```
$my_heroes $mol_view
```
Вот, мы создали компонент $my\_heroes, который наследует свойства от самого базового компонента $mol\_view. Одна строчка кода из двух имён. Что может быть проще? В том же Angular вам потребуется минимум 5, плюс ещё 2 на импорт и регистрацию.
Объявление свойств во view.tree
===============================
Чтобы объявить новое или переопределить существующее свойство — просто пишем его имя с отступом, а через пробел — значение по умолчанию.
```
$my_heroes $mol_view
sub /
```
Тут мы переопределили свойство "sub", которое будет возвращать список вложенных компонент.
Вложенные компоненты во view.tree
=================================
Внутри у нас будет 3 компонента: заголовок, подзаголовок и собственно список героев.
```
$my_heroes $mol_view
sub /
<= Title $mol_view
<= Title_sub $mol_view
<= Rows $mol_list
```
Стрелочка влево означает получение значения свойства, а после неё идёт собственно объявление этого свойства указанием его имени и значения через пробел. Всё, что начинается с "$" — это классы компонент. Их свойства тоже можно переопределять.
Глубокая иерархия во view.tree
==============================
Вводя всё новые и новые свойства мы можем построить наглядную иерархию любой нужной нам глубины.
```
$my_heroes $mol_view
sub /
<= Title $mol_view
sub /
<= title \
<= Title_sub $mol_view
sub /
<= title_sub @ \My Heroes
<= Rows $mol_list
rows <= rows /
```
Тут например, сразу видно, что заголовок мы выводим во вложенный компонент по имени Title, подзаголовок — в Title\_sub, а строчки с героями в Rows.
Строковые константы во view.tree
================================
Обратная косая черта предваряет сырые данные, которые могут содержать любые символы, кроме перевода строки.
```
<= descriptions \
\Многострочный текст
\ который может содержать
\ совершенно любые символы
\ без какого-либо экранирования
\ " ' & < \
```
Мечтали ли вы о таком счастье в html или json?
Локализация во view.tree
========================
Зашивать тексты в коде, конечно, просто и быстро, но что насчёт локализации? Просто добавляем собачку и текст после неё будет вынесен в отдельный файл с переводами, а в сгенерированном из view.tree TypeScript классе будет лишь обращение по человекопонятному ключу.
**web.locale=en.json**
```
{
"$my_heroes_title_sub" : "My Heroes"
}
```
**heroes.view.tree.ts**
```
/// title_sub @ \My Heroes
title_sub() {
return this.$.$mol_locale.text( "$my_heroes_title_sub" )
}
```
Обратите внимание, что кусочек исходника, ответственного за данное свойство всегда выводится рядом в комментарии. Что позволяет очень быстро освоить синтаксис view.tree.
Мультисвойства во view.tree
===========================
Обычные свойства возвращают всегда одно значение. Мультисвойства могут возвращать разные значения в зависимости от переданного им ключа.
```
$my_heroes $mol_view
- ...
Row!index $mol_row
sub <= item_content!index /
<= Badge!index $my_badge
title <= hero_id!index \
<= hero_name!index \
```
В данном случае ключом для строк героев и всего, что в них находится у нас будет их порядковый индекс.
Удаляем подзаголовок из $my\_heroes
===================================
Итак, зачем нам вся эта свистопляска с кучей свойств? Дело в том, что каждое такое свойство — это точка расширения. Мы можем изменить в компоненте любой аспект поведения, просто переопределив соответствующее свойство.
```
$my_top_heroes $my_heroes
Title_sub null
```
Тут мы создали новый компонент на основе базового, но вместо вложенного компонента просто возвращаем null, что приводит к полному исключению его из рендеринга.
Добавляем описание в $my\_heroes
================================
Переопределяя списки мы можем добавлять новые компоненты между уже существующих.
```
$my_new_heroes $my_heroes
sub /
<= Title -
<= Title_sub -
<= Description $mol_text
text <= description \
<= Rows -
```
Тут мы объявляем компонент который является точь в точь компонентом $my\_heroes, но после заголовков имеет дополнительный тут же объявленный блок с описанием.
Меняем местами блоки в $my\_heroes
==================================
И разумеется мы можем легко и просто переставлять местами компоненты, где-нибудь в глубине. Например, имя и идентификатор героя.
```
$my_reflect_heroes $my_heroes
item_content!index /
<= hero_name!index -
<= Badge!index -
```
Язык view.tree настолько удобен для описания компонент, что его так и тянет использовать для описания вообще любых классов. И это на самом деле возможно, но только осторожно.
Логика компонент в $mol
=======================
Но иногда ведь нужна нетривиальная логика для вычисления свойств. А логику лучше всего описывать на языке для этого предназначенном. Поэтому мы просто наследуемся от автоматически сгенерированного из view.tree класса и переопределяем его свойства, реализуя любую хитрость.
```
export $my_heroes extends $.$my_heroes {
heroes() {
return $mol_http.resource( '/heroes' ).json()
}
rows() {
return Object.keys( this.heroes() ).map( index =this.Row( index ) )
}
hero_name( id : string ) {
return this.heroes()[ id ].name
}
}
```
Тут мы загрузили json массив с данными героев с сервера, для каждого героя создали по строке отображения, объявленной во view.tree, и объявили мультисвойство возвращающее имя героя по его порядковому номеру.
Как-то лишком просто, не находите? Но в этом вся и суть, что абстракции должны упрощать разработку, а не усложнять её.
Хайп
====
А теперь о грустном — проблеме петуха и яиц.
Разработчики не горят желанием изучать инструмент по которому мало вакансий. А компании — завязываться на инструмент по которому мало специалистов. Так и получается, что светлые идеи упрощающие и удешевляющие разработку помирают в тени более крупных, но менее функциональных библиотек, вынуждающих писать кучу однотипного кода с кучей велосипедов.
Ожидания и реальность
=====================
Примечателен [опыт Тинькофф банка](https://habrahabr.ru/company/tinkoff/blog/303580/), где команда из лучших чем я специалистов долго разрабатывала новую версию интернет-банка на модном Реакте. Получился довольно тормозной монстр с меньшей функциональностью, который потом ещё очень долго оптимизировали. Но результат всё ещё далёк от совершенства.
На $mol меньшей командой за меньший срок можно было бы достигнуть куда большей отзывчивости интерфейса. Причём сразу, а не после жалоб пользователей.
Суровая правда жизни
====================
Или пример с конференции РИТ 2017, где ребята из Wrike рассказывали про Angular и React. Слайды они показывали через специально написанное для выступления приложение, позволяющее аудитории в реальном времени голосовать за один из фреймворков.
**Как вы думаете, на каком же фреймворке они его реализовали?**
На jQuery. Потому что на нём оказалось это сделать проще. Кстати, мне оказалось проще запилить приложение на $mol. Делайте выводы.
Фактор автобуса
===============
Есть более существенный недостаток малого сообщества...
Когда мейнтейнер обессиленно падает оземь, его флаг приходится подхватывать тому, кому это больше всего нужно. Понимая это, я разрабатывал $mol таким, чтобы поддерживать его было не более трудоёмко, чем конечное приложение на его основе. В нём не более 10 тысяч строк кода, сгруппированных в небольшие узкоспециализированные заменяемые модули, имеющие весьма плоскую структуру. Это капля в море по сравнению с любым более-менее крупным приложением. И это та капля в которой разобраться скорее всего будет проще всего.
Сообщество $mol
===============
Не стоит забывать и про социальную составляющую. У нас нет огромных маркетинговых бюджетов, поэтому мы не можем позволить себе фрагментацию сообщества в духе Angular, где одна половина пилит приложения на TypeScript, другая половина на JavaScript, а третяя вообще на Dart. Мы концентрируемся на том, чтобы всё наше небольшое сообщество могло совместными усилиями развивать общую базу компонент.
1. Лёгкое использование стороннего модуля.
2. Лёгкое расшаривание своего модуля.
3. Лёгкое развитие множества модулей одним человеком.
4. Лучшие практики из коробки.
5. Каталог всех компонент.
6. Глобальный рефакторинг всех репозиториев.
Незачем велосипедить каждому в своём проекте одни и те же типовые решения. Лучше посвятить время созданию чего-то по настоящему нового.
Продолжение следует
===================
Надеюсь мне удалось заразить вас идеями $mol. Предлагайте свои. Или просто расскажите о своей боли, а вместе мы что-нибудь придумаем, чтобы её больше не было.
* [nin-jin.github.io/slides/mol](https://nin-jin.github.io/slides/mol/) — эти самые слайды
* [nin-jin.github.io/slides/orp](https://nin-jin.github.io/slides/orp) — чудеса реактивности и недостатки React
* [mol.js.org](http://mol.js.org/) — каталог $mol компонент
* [t.me/mam\_mol](https://t.me/mam_mol) — уютный $mol чатик | https://habr.com/ru/post/341146/ | null | ru | null |
# Как подписать свой первый скрипт за 48 часов
#### Проблема
Когда задача, требующая решения, небольшая, совсем не хочется писать для её решения отдельную утилиту, особенно, если ты — .NET-программист.
Скрипт? Однозначно, да, но ставить на боевую машину под управлением Windows сторонний интерпретатор совсем уж не по-христиански. Так почему бы не воспользоваться Windows Powershell? Готов сразу честно признаться: практически никакого опыта с ним не было, но уж больно заманчиво выглядел.
Скрипт, решающий задачу, был готов через 15 минут, если не учесть одно «но». Скриптом пока назвать это было сложно, потому что это был набор инструкций, непригодный для выполнения в виде скрипта. Непригодный, с точки зрения PowerShell.
Всему есть разумное объяснение — конечно же, на выполнение скриптов накладываются определенные ограничения, задаваемые **политикой исполнения скриптов**. Создав скрипт, я не смог выполнить его тут же на своей машине. Однако проблема, решаемая для локальной машины временным изменением политики исполнения на **Unrestricted** или, правильнее, **RemoteSigned**, на рабочем сервере поднимается всерьез.
Выход есть всегда. Логично, что готовый скрипт для исполнения нужно подписать. Процесс организации механизма подписи достаточно протяжён и тернист, но послужил хорошей почвой для этого поста.
После двух суток мучений дома и в офисе, представляю на суд общественности краткий мануал по подписи скриптов для PowerShell.
#### Решение
По умолчанию, исполнение любых скриптов запрещено. Для начала, необходимо разрешить выполнение только подписанных скриптов от доверенных издателей с доверенным корневым сертификатом. В рамках сеанса администратора Powershell:
`> Set-ExecutionPolicy AllSigned`
Дальнейшие танцы с бубном касаются утилиты по созданию корневого и персонального сертификатов.
Все сертификаты, согласно «инструкции» по подписыванию скриптов
`> Get-Help About_Signing`
создаются с использованием утилиты **makecert.exe**, находящейся в **%Program Files%\Microsoft SDKs\Windows\v7.0A\bin\makecert**
Следующие два действия выполняются в рамках обычного сеанса командной строки:
`> makecert -n "CN=PowerShell Local Certificate Root" -a sha1 -eku 1.3.6.1.5.5.7.3.3 -r -sv root.pvk root.cer -ss Root -sr localMachine
> makecert -pe -n "CN=PowerShell User" -ss MY -a sha1 -eku 1.3.6.1.5.5.7.3.3 -iv root.pvk -ic root.cer`
Первая строка создает корневой сертификат, используя в качестве удостоверяющего центра локальную машину. Наиболее популярный «бесплатный» способ получения сертификата.
Вторая строка создает персональный сертификат пользователя PowerShell, которым будут подписываться скрипты, заверяя его корневым сертификатом. Если всё прошло успешно, обе строки должны показать результат **Succeeded**.
Приведенные выше манипуляции можно и не выполнять, если персональный сертификат X509 уже есть.
После этого, на всякий случай, можно проверить, что ОС в курсе насчет только что созданного сертификата. PowerShell:
`> Get-Childitem cert:\CurrentUser\my -codesigning`
Подписывать скрипты уже можно, но, в таком случае, на подпись скрипта каждый раз будет уходить такая строка Powershell:
`> Set-AuthenticodeSignature "FileName" @(Get-ChildItem cert:\CurrentUser\My -codesigning)[0]`
Было бы логичным создать скрипт, который будет подписывать другие скрипты. Скрипт нужно создавать в любом текстовом редакторе, **кроме** PowerShell ISE. Для скриптов, созданных внутри этой среды, возникнут проблемы с подписыванием в виде *Unknown Error*. Решение взято [здесь](http://johnwheatley.wordpress.com/2010/03/07/unknown-error-signing-powershell-script/).
Сам скрипт выглядит так:
`param([string] $file=$(throw "Please specify a filename."))
$cert = @(Get-ChildItem cert:\CurrentUser\My -codesigning)[0]
Set-AuthenticodeSignature $file $cert`
При помощи инструкций, указанных выше, подпишем сам этот скрипт в интерактивном режиме PowerShell.
После этого, скрипт для выполнения на другой машине может быть подписан так:
`> .\Add-Signature.ps1 MyScript.ps1`
#### О грустном
На любой машине, кроме той, на которой создавался сертификат:
1. Если корневой сертификат не является доверенным, выполнить скрипт не удастся вообще.
2. Если персональный сертификат издателя, подписавшего скрипт, не является доверенным, скрипт выполнится только с подтверждением.
Для того, чтобы добавить корневой и персональный сертификаты в доверенные, нужно воспользоваться админской консолью **mmc** с оснасткой **Certificates**. Сертификаты добавлять в папки **Trusted Root Certification Authorities** и **Trusted Publishers**.
Не претендует на роль единственно верного решения, но результаты исследований показывают, что пока это более или менее нормальный способ. Прошу знающих помочь прояснить ситуацию и ткнуть ссылкой, по возможности. | https://habr.com/ru/post/137884/ | null | ru | null |
# 4,5 года из жизни iOS-команды в пяти историях и одном техрадаре
Привет, я Стас, лид мобильной разработки Туту.ру. Хочу поделиться, к чему мы пришли, к чему только идём, а от чего избавились за пять лет, что я в компании. Часть решений может шокировать. Поехали!
**Как мы пришли к снапшот-тестам и Data-Driven View Controller**
Мы заморачиваемся тестированием и его автоматизацией. Был собран практически полный автоматизированный прогон, для релиза надо получить зелёные тесты и сделать покупку с тестовой карты. С точки зрения видов тестов, помимо стандартных Unit и UI, мы пришли к snapshot-тестированию.
Snapshot-тестирование – этокогда тест рендерит вью, делает скриншот и сравнивает его с референсной картинкой. Это дешевый способ убедиться, что верстка не поехала.
Но так было не всегда, довольно долго в DoD задачи были только unit-тесты. Но в один прекрасный день мы провели внутренний хакатон, посвящённый качеству. У него было две цели: научить разработчиков писать UI-тесты и проработать обвязку в виде хелперов, опенеров и моков сетевых запросов. На том же хакатоне «на сдачу» затащили snapshot-тестирование.
```
class PassengersViewControllerTests: XCTestCase {
func testPassengersViewControllerLoadedState() {
let vc = _makePassengersViewController(.loaded(.mock))
assertSnapshots(matching: vc, as: .images(.config))
}
func testPassengersViewControllerEmptyStateLogined() {
let vc = _makePassengersViewController(.empty(.logined))
assertSnapshots(matching: vc, as: .images(.config))
}
func testPassengersViewControllerEmptyStateNotLogined() {
let vc = _makePassengersViewController(.empty(.notLogined))
assertSnapshots(matching: vc, as: .images(.config))
}
func testPassengersViewControllerLoadingState() {
let vc = _makePassengersViewController(.loading)
assertSnapshots(matching: vc, as: .images(.config))
}
}
```
Писать хорошие снапшотные тесты нам помогает подход Data-Driven View, которого мы придерживаемся на обеих платформах, — его мы подсмотрели в докладе Алексея Демедецкого. Решение намазывается на любую архитектуру, попробуйте, если ещё нет.
СпойлерПо теме можно делать отдельную статью, но лучше [посмотреть выступление](https://www.youtube.com/watch?v=MrFuKB3HY9o) Алексея
Если кратко, идея вот в чём: у вью, особенно в архитектурах с презентерами, часто делают широкий интерфейс. Функция на обновление шапки таблицы, на саму таблицу, на разные состояния. Думаю, вы неоднократно видели экраны, которые находятся в неконсистентном состоянии. На половине экрана — ошибка, на половине — устаревшее состояние. Если сделать интерфейс вью с единственной функцией render(with: Model), это нас с одной стороны заставит заранее готовить консистентную модель, с другой — упростит рендеринг, из-за того, что у нас есть все данные для отображения. В качестве бонуса получаем возможность писать снапшот/скриншот-тесты.
**От зоопарка архитектур к RxFeedback — и обратно**
У нас есть несколько мобильных подкоманд, каждая отвечает за своё продуктовое направление: авиа, ж/д, автобусы. У каждого направления своё приложение и своя команда, а у каждой команды свои подходы — VIPER, MVVM, MVP. Около трёх лет назад у бизнеса появилась потребность объединить приложения, а как следствие, и команды под одним продакт-оунером.
Перед нами возникла необходимость выбрать единый архитектурный стандарт. На Android всё получилось довольно легко и органично, а в iOS возникла идея использовать Composable Architecture. Как всегда, всё началось с идеи одного из разработчиков: мы обкатали её на небольшом проекте и поняли, что с ней можно решать наши кейсы.
Например, у нас была проблема с визардами: когда человек покупает билет, надо брать и заполнять одно состояние заказа на куче экранов. Просто чтобы был понятен масштаб: покупка билета с точки зрения объёма кодовой базы и числа экранов занимает две трети приложения. RxFeedback помогает нам легко шарить состояние на куче экранов. Это же и стейт-машина и она хорошо решает задачу обновления сложных состояний.
[*В своё время мы выступали про это на CocoaHeads*](https://www.youtube.com/watch?v=vB8EUylXdAM)
Но сегодня мы постепенно приходим к тому, что в изолированных проектах — мы называем их солюшенами, команды сами выбирают паттерны. И сейчас я расскажу, как мы к этому пришли.
**От монорепозитория к доменам (солюшенам)**
Всё началось с того, что один из разработчиков между делом сказал: «Вот я уже полтора года в компании, а всё ещё периодически попадаются части проекта, в которые я никогда не заглядывал». В августе 2020-го мы пошли на выделение отдельных команд, которые отвечают за конкретные домены и пользовательские сценарии. Каждая команда начинается с бизнесовой направленности, потом появляется продакт, а потом и вся остальная команда. То есть разбиение касалось не только мобильных разработчиков. В итоге у команд появилась постоянная зона ответственности, за которую они отвечают и могут итерационно улучшать.
В итоге у нас образовалось 4 вида команд:
* Команды, отвечающие за приложения.
* Команды, отвечающие за солюшены aka домены.
* Проектная команда, которая приходит, делает сложный проект и идёт дальше.
* Core — продумывают стандарты, проектируют, делают ревью почти всех, а, когда необходимо, приходят и помогают руками.
Первым отделили поисковую выдачу со всеми её фильтрами. Сейчас в такой же парадигме делаем отели. У них отдельные репозитории — ты владеешь всем кодом, периодически поднимая версию своей зависимости в репозитории приложений. Мы ещё в середине пути и продолжаем резать приложение, чтобы у каждой фича-команды была явная зона ответственности и она не была слишком большой.
**Как мы готовимся к SwiftUI**
В плане SwiftUI и Combine пришла беда откуда не ждали. До последнего года мы придерживались правила, что минимальная версия — это текущая минус две. Это обусловлено процентом пользователей, сидящих на конкретной оси. Где-то в районе 4-5% поднимаем вопрос об отказе от конкретной оси. Всех подставила iOS 12, доля пользователей на которой снижается в два раза медленнее, чем на любой другой оси. А в июле 2021-го пользователей на ней стало даже больше, чем на 13-й.
Наконец процент на iOS 12 упал достаточно, чтобы мы начали отказ от неё. Это даст нам возможность начать выпиливать довольно толстый RxSwift. SwiftUI планируем обкатывать в первую очередь в песочнице.
Благодаря Data-Driven View мы планируем переехать легко, ведь модели для рендеринга уже готовы. Правда сам первый SwiftUI обещает подкинуть проблем, но это уже совсем другая история.
**Что не зашло или не стало обязательным**
Конечно, за столько лет были и не взлетевшие истории. Из памятного — был заход в использование функциональных операторов: но мы свернули эту историю, так как она дико увеличивала порог входа.
Несмотря на требования по тестам на каждую задачу, TDD — является рекомендацией. Лично для меня умение применять этот подход — огромный плюс для разработчика, за который на том же собеседовании я готов простить многое. Сейчас на каждой из платформ активно используют TDD — 2-3 человека. Остальных мы не пушим.
**Что ещё у нас с технологиями**
Кратко расскажу про концепцию техрадара. Всё что использует команда делится на 4 группы: инструменты, платформы, языки/фреймворки и подходы. Каждая группа занимает свой квадрант на радаре. Внутри квадранта у сущности в свою очередь есть 4 состояния: активно используется, пробуем, присматриваемся, отказались.
Техрадар это еще и правила перемещения между этими состояниями. Чтобы начать использовать технологию, надо вначале изучить её на тестовых примерах, затем попробовать на неважных экранах, а уже потом втаскивать в бою на основной флоу пользователя.
> [Наш техрадар](https://cutt.ly/pIgaDT2)
>
> | https://habr.com/ru/post/648073/ | null | ru | null |
# Отладка native-кода под Android: ручное и автоматизированное тестирование
С развитием и ростом популярности ОС Android количество и разнообразие устройств под её управлением неуклонно растёт. Из-за различий в архитектуре, предназначении и оптимизации скорость и стабильность работы исполняемого кода может значительно изменяться. Поэтому, для обеспечения стабильности и оптимизации работы приложений и ОС, особенно использующих особенности конкретной архитектуры, платформы, или кода, портированного с других платформ, стоит особо внимание уделить процессу отладки кода под Андроид. В этой статье пойдёт речь о ключевых моментах и особенностях работы с native-кодом под Android. Всем, кому интересен этот мануал, прошу под кат.
В далёком 2007 году корпорация Google выпустила операционную систему нового поколения – [Android](http://www.openhandsetalliance.com/press_110507.html).
Её появление совершило настоящую революцию на рынке мобильных устройств, подавив гегемонию Microsoft Widows Mobile, Apple iOS и Symbian OS, в последствие став самой популярной и массовой операционной системой для мобильных систем в мире. До сих пор рост популярности системы [продолжается](http://habrahabr.ru/company/apps4all/blog/146683/). За прошедшие шесть лет Android очень сильно разросся и развился, и спектр поддерживаемых устройств продолжает увеличиваться. Теперь это операционная система используется не только в мобильных телефонах, но также и в планшетах, телевизорах, плеерах, фотоаппаратах, ноутбуках, неттопах и прочих экзотических вещах, вплоть до военной техники. Начинки этих устройств могут весьма заметно отличаться друг от друга: за прошедшие годы перечень поддерживаемых архитектур расширился с ARM до MIPS и х86, появилась поддержка различной периферии, не говоря о непременно развивающемся Android API.
Такое огромное количество различных устройств, несмотря на их функциональные и архитектурные различия, управляются одной и той же системой, за вычетом платформозависимых библиотек и оптимизаций под конкретные устройства. Вполне закономерно, что сборки Android и даже зачастую библиотеки приложений отличаются друг от друга, зачастую даже в зависимости от вендора, так как требования к производительности лишь увеличиваются в условиях жесткой конкуренции растущего рынка устройств на платформе Android.
Тем не менее, обеспечение унификации и кроссплатформености, быстроты работы приложений – одно из приоритетных направлений сегодняшнего рынка высокопроизводительных приложений и сборок системы. Это, в первую очередь, означает повышенные требования к самой операционной системе, способной работать и делать это эффективно на различном аппаратном обеспечении, так и высокие требования к приложениям для Android.
Одним из самых эффективных решений для оптимизации и ускорения работы приложений, системы и её компонентов является оптимизация на родном, native-уровне. Другими словами, использование для приложений и системы оптимизированных, часто аппаратно-зависимых библиотек и кода, а в глобальном смысле – целого ряда библиотек, поставляющихся для каждой из целевых платформ. Такое многообразие аппаратных платформ, различных версий операционной системы, платформ API и требований к обеспечению стабильной и быстрой работы приложений требует значительных усилий на тестирование приложений, библиотек под конкретные конфигурации.
Тем не менее, одним из самых удобных инструментов для разработчика Android до сих пор является пакет Android NDK – [Android Native Development Kit](http://developer.android.com/tools/sdk/ndk/index.html), включающий в себя почти всё необходимое для разработки и отладки приложений, библиотек и самой системы.
В данной статье я рассмотрю его использование для тестирования и отладки native-кода Android и автоматизацию тестирования на примере такого фреймворка, как [DejaGnu](http://www.gnu.org/software/dejagnu/).
Android развивается очень динамично, и теперь в поставку DejaGnu входит почти что всё необходимое для быстрого старта тестирования – как с Android NDK, так и без него. Главной задачей данной статьи будет рассказ о нюансах и особенностях тестирования под Android и некоторых подводных камнях, с которыми могут столкнуться инженеры.
 Для начала небольшая ремарка: Android, как известно, является Unix-like операционной системой, очень схожей с обычным Linux или BSD, и большинство исходного кода Android следует лицензии, [ASL2.0](http://source.android.com/source/licenses.html). Кто работал с Android, знает, что немалое количество модулей Android перешли из BSD в большей степени, чем из Linux. Тем не менее, всё, что касается native-кода и архитектуры, если не вдаваться в подробности, очень близко и известно всем тем, кто использовал Linux. Поэтому для разработки и отладки кода вполне возможно использовать точно такие же или схожие инструменты, что и для Unix-like систем. В случае компиляторов – это gcc, clang (llvm), icc и прочие. То же самое можно сказать и насчёт всего GCC toolchain и некоторых других утилит, которые либо уже портированы, либо портировать не так сложно.
Главной причиной включения в приложение native-кода или использования native-библиотек, native-исполнимых файлов является стремление увеличить производительность или переиспользовать ранее написанный код C/C++/ASM с Linux/Unix-like систем.
**Преимущества использования native-кода**:
• Высокая производительность
• Прямое использование CPU/HW особенностей
• Возможность переиспользования существующего Linux кода
**Недостатки использования native-кода**:
• Индивидуальная настройка под CPU/HW
• Недостаточная поддержка системных библиотек
Плюсы и минусы требуют тщательного тестирования, как по качеству кода, стабильности, так и по его производительности на разных платформах. Несмотря на то, что одним из постулатов Android является независимость от железа, для обеспечения работы на различных конфигурациях, в действительно приложения с native-кодом поставляются в так называемых fat binary (apk, включающие в себя native-код/библиотеки для всех возможных конфигураций оборудования, под которым будет работать приложение). Несмотря на то, что в идеале NDK компилятор должен создавать функционально равнозначный код для различных конфигураций и, следовательно, библиотеки для fat binary (или системные – для образа) должны быть равнозначными — это, к сожалению, не всегда соответствует действительности и требует проверки, особенно когда дело касается оптимизации (Neon и SSE например) и использования сторонних библиотек.
Кроме того, с развитием ОС Android и устройств под её управлением, закономерно меняются различные версии ОС, поставка этой ОС, а так же специфика устройств. В некоторых случаях для разработчика оправдано использование каких-то оптимизаций или иного компилятора для сборки native-кода. Оценка производительности, правильности и стабильности этого кода на различных конфигурациях – задача тестировщика, занимающегося Android Native тестированием.
Процесс сборки, отладки и тестирования native приложений под Android не сильно отличается от того же процесса на Linux, с единственной разницей, что мы собираем бинарные файлы (исполнимые и библиотеки) не в Android, а на хосте (Linux, MacOS, Windows) и исполняем на устройстве Android (физическом или эмуляторе). Поэтому универсальным средством коммуникации хоста с устройством под управлением Android является adb – Android Debug Bridge, входящий в состав [Android SDK](http://developer.android.com/tools/sdk). Для сборки и отладки приложений целесообразно использовать тот toolchain и API, который нам нужен, а так же, при необходимости (для c++), интересующую нас версию библиотеки stdc++.
Native-сборка Android может различаться по:
1. версиям используемого API:
2. версиям используемого libstdc++:
3. архитектуре устройства (target):
4. разрядности (32, 64 или x32) target:
5. билд-хосту и его разрядности:
Впрочем, с точки зрения разработчика и тестировщика, различий между получаемым кодом в зависимости от билд-хоста быть не должно, и использовать для проверки и тестирования различные конфигурации билд-хостов вовсе не обязательно.
Количество вариантов для тестирования угрожающе разрастается, и это не беря в расчёт оптимизации по CPU инструкциям: neon, core-avx2, core-i7, atom, slm; по размеру\скорости и прочие. Все это декартово произведение вариантов полученного кода (исходного и бинарного) является отправной точкой для тестирования. В случае же, когда целью тестирования является само устройство или какой-то кастомная сборка Android, то, вполне вероятно, главным весомым различием будет библиотека bionic – аналог библиотеки libc для Android.
Закончив вводную теорию, самое время перейти к практике.
#### Инструменты для ручной сборки и тестирования
Все необходимые инструменты входят в поставку [Android NDK](http://developer.android.com/tools/sdk/ndk/index.html), которая есть для 32 и 64 бит под Linux, MacOS, Windows.
##### Создание и запуск приложения
###### gcc
```
bash-4.2$ #начнём с обычного hello_world.c
bash-4.2$ cat ./hello_world.c
#include
int main(void)
{
printf(“Hello, World!\n”);
return 0;
}
bash-4.2$ #Соберём бинарник для Android, используя gcc 4.7 под x86, платформа 18
bash-4.2$ /users/NDK\_current/toolchains/x86-4.7/prebuilt/linux-x86/bin/i686-linux-android-gcc –sysroot=/users/NDK\_current/platforms/android-18/arch-x86 ./hello\_world.c -o ./hello\_world.exe
bash-4.2$ echo $?
0
bash-4.2$ #собралось, хорошо
bash-4.2$ #теперь запустим
bash-4.2$ ./hello\_world.exe
bash-4.2$ #плохо, нельзя запустить на хосте
bash-4.2$ #давайте посмотрим на доступные устройства
bash-4.2$ adb devices
List of devices attached
0146AFFC18020012 device
bash-4.2$ #хорошо, давайте выберем какое-нибудь и проверим отклик
bash-4.2$ adb -s 0146AFFC18020012 shell echo ‘Hello, Android!’
Hello, Android!
bash-4.2$ #работает, но каждый раз вбивать серийник неудобно
bash-4.2$ export ANDROID\_SERIAL=0146AFFC18020012
bash-4.2$ #поэтому заведём переменную
bash-4.2$ adb shell echo ‘Hello, Android!’
Hello, Android!
bash-4.2$ #так-то лучше, теперь отправим бинарник на устройство
bash-4.2$ adb push ./hello\_world.exe /data/local/
bash-4.2$ #что-то отправилось, теперь запустим
bash-4.2$ adb shell /data/local/hello\_world.exe
Hello, World!
bash-4.2$ #adb ответил, что всё хорошо, теперь убедимся ещё раз, что точно запустилось
bash-4.2$ adb shell “/data/local/hello\_world.exe && echo $?”
Hello, World!
0
bash-4.2$ #работает, но не всегда под рукой есть устройство или эмулятор
bash-4.2$ #можно сделать статическую сборку, которая будет работать везде на совместимых архитектурах
bash-4.2$ #файл будет больше, но мы сможем запустить как на хосте (linux, mac, windows)
bash-4.2$ #так и на устройстве, где может каких-то зависимостей и не быть
bash-4.2$ #чтобы это сделать, надо добавить флажок -static
/users//NDK\_current/toolchains/x86-4.7/prebuilt/linux-x86/bin/i686-linux-android-gcc –sysroot=/users/ /NDK\_current/platforms/android-18/arch-x86 -static ./hello\_world.c -o ./hello\_world.exe
bash-4.2$ echo $?
0
bash-4.2$ #собралось, но не всегда это возможно из-за громоздкости связанных библиотек и наличия нужных статичных версий
bash-4.2$ ./hello\_world.exe
Hello, World!
bash-4.2$ echo $?
0
bash-4.2$ #работает, теперь мы можем запустить и протестировать приложение и на хосте
bash-4.2$
```
###### g++
```
bash-4.2$ #теперь давайте сделаем тоже самое для g++
bash-4.2$ cat ./hello_world.C
#include
int main(void)
{
std::cout << “Hello, World!\n”;
return 0;
}
bash-4.2$ #если мы будем использовать STL, то
bash-4.2$ #нам дополнительно понадобится указать пути к библиотекам и заголовочным файлам
bash-4.2$ #а так же сообщить компоновщику, какую библиотеку надо добавить
bash-4.2$ #обратите внимание, что инструкция -l%STL\_LIB% должна быть в конце командной строки!
bash-4.2$ #динамический вариант имеет суффикс \_shared, а статический \_static соответственно
bash-4.2$ #теперь добавим к вызову g++ -L, -I и одну из библиотек – gnustl/stlport/gabi
bash-4.2$ /users/ /NDK\_current/toolchains/x86-4.7/prebuilt/linux-x86/bin/i686-linux-android-g++ –sysroot=/users/NDK\_current/platforms/android-18/arch-x86 -I/users/NDK\_current/sources/cxx-stl/gnu-libstdc++/4.7/include -I/users/NDK\_current/sources/cxx-stl/gnu-libstdc++/4.7/libs/x86/include -L/users//NDK\_current/sources/cxx-stl/gnu-libstdc++/4.7/libs/x86 ./hello\_world.C -o ./hello\_world.exe -lgnustl\_shared
bash-4.2$ echo $?
0
bash-4.2$ #собралось, но не всегда это возможно из-за громоздкости связанных библиотек и/или наличия нужных статичных/динамических версий
bash-4.2$ adb push ./hello\_world.exe /data/local/
bash-4.2$ #что-то отправилось, теперь запустим
bash-4.2$ adb shell “/data/local/hello\_world.exe && echo $?”
soinfo\_link\_image(linker.cpp:1635): could not load library “libgnustl\_shared.so” needed by “/data/local/hello\_world.exe”; caused by load\_library(linker.cpp:745): library “libgnustl\_shared.so” not foundCANNOT LINK EXECUTABLE
bash-4.2$ #не работает, не хватает библиотеки
bash-4.2$ #libgnustl\_shared.so не входит в поставку Android, поэтому её надо скопировать на устройство
bash-4.2$ adb push /users//NDK\_current/sources/cxx-stl/gnu-libstdc++/4.7/libs/x86/libgnustl\_shared.so /data/local/libgnustl\_shared.so
bash-4.2$ #переписали, запустим ещё раз, явным образом указав LD\_LIBRARY\_PATH
bash-4.2$ adb shell “export LD\_LIBRARY\_PATH=/data/local/:$LD\_LIBRARY\_PATH && /data/local/hello\_world.exe && echo $\?”
Hello, World!
0
bash-4.2$ #либо перенесём библиотеку в путь по умолчанию – /system/lib
bash-4.2$ #запустим
bash-4.2$ adb shell “/data/local/hello\_world.exe && echo $\?”
Hello, World!
0
bash-4.2$
```
В случае совпадения архитектуры host и target (обычно речь идёт о x86) и наличия root привилегий, вполне возможно использовать при желании хитрый трюк с запуском Android x86 бинарников на хосте. Для этого нужно явным образом использовать dynamic linker для Android на системе (/system/bin/linker), а так же использовать non-stripped версию bionic в путях (LD\_LIBRARY\_PATH). См пример Makefile: (<https://android.googlesource.com/platform/bionic/+/master/tests/Android.mk>: bionic-unit-tests-run-on-host).
```
# -----------------------------------------------------------------------------
# Run the unit tests built against x86 bionic on an x86 host.
# -----------------------------------------------------------------------------
ifeq ($(HOST_OS)-$(HOST_ARCH),linux-x86)
ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),x86 x86_64))
ifeq ($(TARGET_ARCH),x86)
LINKER = linker
else
LINKER = linker64
endif
# gtest needs ANDROID_DATA/local/tmp for death test output.
# Make sure to create ANDROID_DATA/local/tmp if doesn't exist.
# bionic itself should always work relative to ANDROID_DATA or ANDROID_ROOT.
bionic-unit-tests-run-on-host: bionic-unit-tests $(TARGET_OUT_EXECUTABLES)/$(LINKER) $(TARGET_OUT_EXECUTABLES)/sh
if [ ! -d /system -o ! -d /system/bin ]; then \
echo "Attempting to create /system/bin"; \
sudo mkdir -p -m 0777 /system/bin; \
fi
mkdir -p $(TARGET_OUT_DATA)/local/tmp
cp $(TARGET_OUT_EXECUTABLES)/$(LINKER) /system/bin
cp $(TARGET_OUT_EXECUTABLES)/sh /system/bin
ANDROID_DATA=$(TARGET_OUT_DATA) \
ANDROID_ROOT=$(TARGET_OUT) \
LD_LIBRARY_PATH=$(TARGET_OUT_SHARED_LIBRARIES) \
$(TARGET_OUT_DATA_NATIVE_TESTS)/bionic-unit-tests/bionic-unit-tests
endif
endif
```
Такой трюк, например, актуален для исполнения бинарных файлов без эмулятора (в случае отсутствия 64-битного образа или использования -mx32).
##### GCOV и профили
```
bash-4.2$ #некоторые файлы, вполне возможно, что-то порождают, и это мы так же можем вытащить с устройства
bash-4.2$ #скомпилируем, например, файл порождающий coverage информацию
bash-4.2$ #обратите внимание, что компилируете вы на хосте, и надо явным образом будет указать директорию профилирования
bash-4.2$ #это можно сделать во время компиляции, добавив флаг -fprofile-dir=%android_exec_dir%
bash-4.2$ #либо перед исполнением, на устройстве, выставив GCOV_PREFIX и GCOV_PREFIX_STRIP
bash-4.2$ #так же обратите внимание, что манипуляции с env действительны лишь на время сессии adb (открытой shell или команды adb shell %command%
bash-4.2$ /users//NDK_current/toolchains/x86-4.7/prebuilt/linux-x86/bin/i686-linux-android-gcc –sysroot=/users//NDK_current/platforms/android-18/arch-x86 ./gcov-1.c -fprofile-arcs -fprofile-dir=. -ftest-coverage -lm -o ./gcov-1.exe
bash-4.2$ adb push ./gcov-1.exe /data/local/gcov-1.exe
bash-4.2$ #adb shell “export GCOV_PREFIX=/data/local && export GCOV_PREFIX_STRIP=13 && /data/local/gcov-1.exe && echo $\?”
bash-4.2$ unset GCOV_PREFIX && unset GCOV_PREFIX_STRIP && cd /data/local && ./gcov-1.exe && echo $\?”
0
bash-4.2$ adb shell ls /data/local/gcov-1.gcda
/data/local/gcov-1.gcda
bash-4.2$ #вытащим профиль
bash-4.2$ adb pull /data/local/gcov-1.gcda .
bash-4.2$ ls ./gcov-1.gcda
./gcov-1.gcda
bash-4.2$ #в состав NDK входит gcov, который достаточно вызвать, как обычно
bash-4.2$ /users/NDK_current/toolchains/x86-4.7/prebuilt/linux-x86/bin/i686-linux-android-gcov gcov-1.gcda
File ‘gcov-1.c’
Lines executed:100.00% of 6
Creating ‘gcov-1.c.gcov’
bash-4.2$
```
##### Дебаг\отладка: GDB/logcat
```
bash-4.2$ #в состав NDK входят так же средства отладки, например, gdb
bash-4.2$ #для удобства отладки бинарники лучше собрать с флагом -g, а так же подгрузить символы
bash-4.2$ /users /NDK_current/toolchains/x86-4.7/prebuilt/linux-x86/bin/i686-linux-android-gcc –sysroot=/users/NDK_current/platforms/android-18/arch-x86 ./hello_world.c -o ./hello_world.exe
bash-4.2$ adb push ./hello_world.exe /data/local/hello_world.exe
bash-4.2$ adb shell gdbserver :5039 /data/local/hello_world.exe &
Process /data/local/hello_world.exe created; pid = 29744
Listening on port 5039
bash-4.2$ adb forward tcp:5039 tcp:5039
bash-4.2$ /users/NDK_current/toolchains/x86-4.7/prebuilt/linux-x86/bin/i686-linux-android-gdb hello_world.exe
Remote debugging from host 127.0.0.1
libthread_db:td_ta_new: Probing system for platform bug.
libthread_db:td_ta_new: Running as root, nothing to do.
Hello, World!
Child exited with status 0
GDBserver exiting
bash-4.2$ cat test.gdb
set sysroot /users/igveresx
set solib-absolute-prefix /users/igveresx/symbols/
set solib-search-path /users/igveresx/symbols/lib
set auto-solib-add on
target remote :5039
stepi
stepi
c
Quit
bash-4.2$ #для отладки и дебаг вывода можно использовать logcat
bash-4.2$ adb logcat *:E >logcat.log &
bash-4.2$ tail -5 logcat.log
E/Intel PowerHAL( 2093): Error in reading vsync hint
E/Intel PowerHAL( 2093): Error reading from /sys/devices/system/cpu/cpufreq/interactive/vsync_count: No such file or directory
E/Intel PowerHAL( 2093): Error in reading vsync count
E/Intel PowerHAL( 2093): Error reading from /sys/devices/system/cpu/cpufreq/interactive/touch_event: No such file or directory
E/Intel PowerHAL( 2093): Error in reading vsync hint
bash-4.2$ #точно так же можно посмотреть сообщения kernel
bash-4.2$ adb shell dmesg | tail -5
<6>[245665.256198] intel_mdf_battery msic_battery: vbus_volt:4974
<6>[245665.265332] intel_mdf_battery msic_battery: vbatt:4116250 temp:300
<4>[245669.213759] kct_daemon: loop.
<4>[245673.213561] kct_daemon: loop.
<4>[245677.213379] kct_daemon: loop.
bash-4.2$ adb shell ‘cat /proc/kmsg’ >kmsg.log
bash-4.2$ tail -5 kmsg.log
<4>[245673.213561] kct_daemon: loop.
<4>[245677.213379] kct_daemon: loop.
<4>[245681.213248] kct_daemon: loop.
<4>[245685.213083] kct_daemon: loop.
<4>[245689.212932] kct_daemon: loop.
bash-4.2$
```
#### Автоматизация тестирования
Для автоматизации тестирования можно использовать такой фреймворк, как dejagnu. Начиная с февраля 2013 в состав DejaGnu входит борд androideabi, позволяющий производить тестирование native-кода на Android через adb.
В целом всё аналогично тому, что было описано выше, за исключением некоторых нюансов.
Для многих тестов dejagnu критичны проверки host/target триплетов. Например, как минимум для того, чтобы понять, возможен ли запуск бинарного файла на устройстве, зачастую выполняется проверка host=target=build (native). Однако, в нашем случае, вообще говоря, *build\_triplet* не равен *target\_triplet*, но при этом мы вполне способны и выполнять, и получать результаты на Android. Кроме того, следует учесть тот факт, что по умолчанию NDK использует флажок **–fpic**, что так же влияет на возможность запуска тестов и их результаты (проверка effective-target pic/nonpic). В случае же статической (*static*) линковки следует иметь в виду, что, возможно, так же не всё будет соответствовать ожиданиям (библиотеки static, dynamic могут разниться между собой и порождать разный код (*-fpic/-fpie*). Также некоторые тесты критичны к директории запуска или указанию директории для результатов; и прежде чем запускать бинарный файл, следует сменить директорию на нужную. Кроме того, во время переноса бинарного файла на устройство, права на запуск могут быть сброшены (из-за прав на папку или прав на файловую систему), поэтому так же стоит убедиться, что для исполнимого файла установлен executable bit. Кроме того, лучшим решением для организации тестирования является использование не sd-карты, а ram-диска с правильными правами, чтобы избежать быстрого износа первой.
Чтобы запустить тестирование на Android достаточно выполнить при установленной dejagnu на хосте:
> **runtest –target\_board=androideabi**
Следует убедиться, что у вас явным образом указана переменная ***ADB\_SERIAL***, соответствующая серийному номеру вашего устройства.
Однако гораздо удобнее и приятнее запускать тестирование через локальный конфигурационный файл — site.exp
Например, конфигурационный файл для запуска [gcc](http://gcc.gnu.org/) testsuite:
```
set rootme “.”
set tmpdir “.”
set srcdir “/path/to/gcc_%version%_release/gcc/testsuite”
set CFLAGS “”
set CXXFLAGS “”
set GDB “/path/to/GDB_UNDER_TEST”
set GCOV_UNDER_TEST “/path/to/GCOV_UNDER_TEST”
set GCC_UNDER_TEST “/path/to/GCC_UNDER_TEST”
set GXX_UNDER_TEST “/path/to/GXX_UNDER_TEST”
set GFORTRAN_UNDER_TEST “no”
set OBJC_UNDER_TEST “no”
set libiconv “”
set HOSTCC “gcc”
set HOSTCFLAGS “”
set TESTING_IN_BUILD_TREE 1
set GMPINC “”
set ENABLE_LTO 1
set HAVE_LIBSTDCXX_V3 1
set host_triplet i686-pc-linux-gnu
set build_triplet i686-pc-linux-gnu
set target_triplet i686-pc-linux-android-gnu
set target_alias i686-pc-linux-android
set android_tmp_dir “/temporary/folder/on/device/with/executable/permissions”
set bridge_tmp_dir “/temporary/folder/on/device/with/executable/permissions”
append boards_dir “/path/to/share/dejagnu/baseboards”
```
и для запуска того же самого gcc:
```
export ADB_SERIAL=$ANDROID_SERIAL
make -j $parallel check DEJAGNU=/path/to/site.exp RUNTESTFLAGS=”–target_board=androideabi”
```
Замечание: обратите внимание, что следует убедиться, что во время запуска проверки gcc кем-то не будет перетёрта переменная *GCC\_EXEC\_PREFIX*, и то, что она unset.
Стоит отметить то, что следует указать не только путь к компилятору, но и следует иметь в виду всё то, что мы делали выше вручную, а именно указать:
* sysroot
* пути к библиотекам и заголовочным файлам
* флаги и подключаемые библиотеки (как минимум для линовки libstdc++)
Исходя из этого, лучшим решением является использование обёртки исполнимого файла из toolchain (wrapper-binaryname), примерно следующего вида:
###### wrapper-gcc
```
#!/bin/bash
/path/to/NDK_folder/toolchains/$arch-%compiler_version%/prebuilt/linux-x86/bin/%arch_prefix%-linux-android-gcc –sysroot=/path/to/NDK_folder/platforms/android-${device_platform}/arch-$arch “$@”
```
###### wrapper-g++
```
#!/bin/bash
echo $@ | grep ” \-nostdlib” 1>/dev/null 2>/dev/null
if [ $? != 0 ]; then
echo $@ | grep ” \-static” 1>/dev/null 2>/dev/null
if [ $? != 0 ]; then
/path/to/NDK_folder/toolchains/$arch-%compiler_version%/prebuilt/linux-x86/bin/%arch_prefix%-linux-android-g++ –sysroot=/path/to/NDK_folder/platforms/android-${device_platform}/arch-$arch -I/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/include -I/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/libs/$arch/include -L/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/libs/$arch “$@” -lgnustl_shared
else
/path/to/NDK_folder/toolchains/$arch-%compiler_version%/prebuilt/linux-x86/bin/%arch_prefix%-linux-android-g++ –sysroot=/path/to/NDK_folder/platforms/android-${device_platform}/arch-$arch -I/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/include -I/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/libs/$arch/include -L/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/libs/$arch “$@” -lgnustl_static
fi
else
/path/to/NDK_folder/toolchains/$arch-%compiler_version%/prebuilt/linux-x86/bin/%arch_prefix%-linux-android-g++ –sysroot=/path/to/NDK_folder/platforms/android-${device_platform}/arch-$arch -I/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/include -I/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/libs/$arch/include -L/path/to/NDK_folder/sources/cxx-stl/%stl lib folder%/%compiler version%/libs/$arch “$@”
fi
```
При необходимости, если надо получить какие-то данные из Android, то мы можем использовать функцию ***remote\_upload*** (***adb\_upload %target\_board% %source% %dest%***). Эта функциональность должна предоставляться со стороны testsuite.
#### Профилирование, тестирование производительности
В рамках данной статьи не будут рассматриваться подробно нюансы сбора и использования профилей, но для Android наиболее распространёнными утилитами для профилирования являются:
* perf
* oprofile
* sep
Например, имея статичную сборку perf, достаточно выполнить:
```
adb push perf /data/local/
adb shell
cd /data/local
chmod 777 perf
perf record ./coremark.exe 0×0 0×0 0×66 0 7 1 2000 # or any arguments required
# data saved at ./perf.data
export PAGER=cat # otherwise it will look for “less”
perf report
```
Тестирование производительности на Android возможно производить не только с помощью бенчмарков, работающих через Dalvik, но так же и на native-уровне, т.е. используя бенчмарки, собранные тем же самым Android NDK. В качестве примера: [SPEC](http://www.spec.org/), [EEMBC](http://www.eembc.org/), [CoreMark](http://www.eembc.org/coremark/).
  
Останавливаться на нюансах портирования фреймворков для Android я не буду (они схожи с описанными выше методами), но стоит заметить, что в основе всего так же лежит принцип использования adb для работы с устройствами или эмуляторами, а так же критичное внимание к процессам, происходящем на устройствах.
Необходимо убедиться, что на результат влияет:
* режим работы процессора
* приложения, запущенные в фоне
* чистота запуска, и ошибки (которые можно и нужно отслеживать через logcat/dmesg)
Релевантные результаты могут быть получены лишь на детерменированных устройствах (если не идёт речь о получении профиля реального использования устройства и приложения). Поэтому, перед запуском необходимо убедиться, что:
* Отключены все второстепенные службы и приложения
* Устройство используется монопольно
* На устройстве жёстко выставлен режим работы
Например, для тестирования CPU типичная практика – это установка всех процессорных ядер и частот в равное значение и их фиксация. При необходимости отключение всех ядер, кроме того, на котором происходит тестирование.
```
adb shell
echo userspace > /sys/devices/system/cpu/cpuX/cpufreq/scaling_governor
echo 2000000 > /sys/devices/system/cpu/cpuX/cpufreq/scaling_max_freq
echo 2000000 > /sys/devices/system/cpu/cpuX/cpufreq/scaling_min_freq
```
Следует убедиться, что значение
***/sys/devices/system/cpu/cpuX/cpufreq/online*** так же установлено правильно в зависимости от бенчмарки\профиля и\или потребностей тестирования.
Только убедившись, что всё работает в нужном режиме (cat /proc/cpuinfo) можно начинать тестирование и анализ.
Для упрощения работы и отладки native-кода, для Android существует набор утилит [busybox](http://www.busybox.net/), который не входит в поставку Android по умолчанию (т.к. поставляется по лицензии GPL 2.0).
`[, [[, ar, arp, awk, base64, basename, bbconfig, beep, blkid, blockdev, bootchartd, bunzip2, bzcat, bzip2, cal, cat, catv, chat, chattr, chgrp, chmod, chown, chpst, chroot, chrt, chvt, cksum, clear, cmp, comm, cp, cpio, crond, crontab, cttyhack, cut, dc, dd, deallocvt, depmod, devmem, diff, dirname, dmesg, dnsd, dos2unix, dpkg, dpkg-deb, du, dumpkmap, echo, ed, egrep, env, envdir, envuidgid, expand, expr, fakeidentd, false, fbset, fbsplash, fdflush, fdformat, fdisk, fgconsole, fgrep, find, findfs, flash_lock, flash_unlock, flashcp, flock, fold, free, freeramdisk, fsync, ftpd, ftpget, ftpput, fuser, getopt, grep, gunzip, gzip, halt, hd, hdparm, head, hexdump, httpd, hwclock, ifconfig, ifdown, ifup, init, inotifyd, insmod, install, iostat, ip, ipaddr, ipcalc, iplink, iproute, iprule, iptunnel, klogd, less, linuxrc, ln, loadkmap, losetup, lpd, lpq, lpr, ls, lsattr, lsmod, lsof, lspci, lsusb, lzcat, lzma, lzop, lzopcat, makedevs, makemime, man, md5sum, mdev, mesg, mkdir, mkfifo, mknod, mkswap, mktemp, modinfo, modprobe, more, mpstat, mv, nbd-client, nc, netstat, nice, nmeter, nohup, od, openvt, patch, pidof, ping, pipe_progress, pmap, popmaildir, poweroff, powertop, printenv, printf, ps, pscan, pstree, pwd, pwdx, raidautorun, rdev, readlink, readprofile, realpath, reboot, reformime, renice, reset, resize, rev, rm, rmdir, rmmod, route, rpm, rpm2cpio, rtcwake, run-parts, runsv, runsvdir, rx, script, scriptreplay, sed, sendmail, seq, setconsole, setkeycodes, setlogcons, setserial, setsid, setuidgid, sha1sum, sha256sum, sha3sum, sha512sum, showkey, sleep, smemcap, softlimit, sort, split, start-stop-daemon, strings, stty, sum, sv, svlogd, switch_root, sync, sysctl, tac, tail, tar, tcpsvd, tee, telnet, telnetd, test, tftp, tftpd, time, timeout, top, touch, tr, traceroute, true, ttysize, tunctl, tune2fs, udpsvd, uname, uncompress, unexpand, uniq, unix2dos, unlzma, unlzop, unxz, unzip, uptime, usleep, uudecode, uuencode, vconfig, vi, volname, watch, wc, wget, which, whoami, whois, xargs, xz, xzcat, yes, zcat`
Использование подхода, описанного в статье, позволяет быстро и легко портировать тестирование из Linux на Android, создавать с нуля и производить отладку для различных конфигураций оборудования и эмуляторов с наименьшими затратами времени. | https://habr.com/ru/post/204642/ | null | ru | null |
# IVR on Webhook
An online chatbot is a recent trend on the market. But how to interact with the clients that are offline? A significant percentage of people prefer to interact over the phone. And the business needs either a large staff of operators or a voice communication automating solution. We are offering a solution to reduce workload and costs (and will barely affect your developers’ busyness).
How to rapidly and easily program any voice menu, auto-informant, robot-secretary with an attached client database?
Spoiler alert: everything is done by implementing webhooks and we are using PHP example.
**What and why?**
For instance, you have a delivery service or an online store with its own logistics in place. Some customers are calling to see what’s with their packages and that can be easily automated. The same goes for cab geolocation, some data collection, or any individual information that can be reported to the client without wasting human power.
It can be easily automated, we’ll provide an example below. Oh, and it can be done completely for free.
**Why not your own asterisk?**
Of course, it can all be done with Asterisk, but aside from the developer, you will also need an administrator, who is also familiar with voice communication security (as they frequently get hacked).
So we will discuss the simplest way to solve the task – with webhooks.
**List of methods**
You will only need two new methods for the job, but each of them provides you with a lot of possibilities, and most importantly – unlimited cycles. With the help of these cycles, you can get a multilevel voice menu and an informant for any subject.
**Main methods:**
* NOTIFY\_START — the beginning of an incoming call in PBX
* NOTIFY\_IVR — callers’ response to a given action
The detailed method description is available to copy-paste in [API description](https://zadarma.com/en/support/api/#webhook).
For NOTIFY\_START and NOTIFY\_IVR requests you can change scenarios during the call by responding with one of the options:
So, a client calls and hears the greeting, then dials a certain number (for example, a tracking code), we send a notification with the entered digits, the script checks with the database and sends the response to us. The response can contain a voice file id or a standard voice reply.
We have a standard number playing system, so you don’t have to record a response ahead; meaning, the appropriate notification is chosen from the database and is played as a number by a robot. Or you can create up to a hundred default voice messages and use them to reply to clients (e.g. “Your delivery is at the warehouse”, “You can receive your package every day between 9 a.m. and 10 p.m.).
**The implementation minimum**
For the responder to answer you need the minimum of a phone number and a PBX. You should also upload or enter the possible responses.
**Set up**
1. [Free PBX](https://zadarma.com/en/services/pbx/) for this task can be set in three clicks (choose the number of employees and the voice menu can be set later)
2. Phone [numbers](https://zadarma.com/en/tariffs/numbers/) for PBX can be connected from 100 countries around the world. The number connects automatically after ID verification is complete (if it is required for the country of your choice). You can also connect one of your own number for free
3. To set the voice menus, go to the “Incoming calls and IVR” page and choose an option that suits you best. Or you can upload your files, or type in a text and the robot will read it automatically. There are 16 languages available with several voices for each one (14 voices in English). You can save up to 100 greetings in your personal account.
**PHP example**
To demonstrate different options, we have created 4 examples of IVR performance on PHP.
1. The system tells last 3 digits from CallerID (example of work with info about numbers and pronouncing digits)
2. The user enters their date of birth in DTMF and the system tells how many days left until the birthday (working with DTMF and pronouncing digits)
3. Endless multilevel menu: the user can enter digits and get to the next/previous menu (example of how with a simple cycle you can create any number of voice menus)
4. Example of authorization to receive the balance status (useful for many life situations)
The first three examples are available on [GitHub](https://github.com/zadarma/user-api-v1/blob/master/examples/webhook.php). There you have all the required elements, you just need to insert the files with the filling (that have to be to prior uploaded to or read in PBX).
**Task 4**: the caller hears the greeting and is asked to enter the identification number, after entering the system tells the balance, says goodbye using a popular phrase from the list and ends the call.
Here’s an example of code for the described task.
**PHP code**
```
$request = new Request();
$notify = self::getEvent([AbstractNotify::EVENT_START, AbstractNotify::EVENT_IVR]);
if (!$notify) {
return;
}
switch ($notify->event){
case AbstractNotify::EVENT_START:
$request
->setIvrPlay(self::INFO_FILE_ID)
->setWaitDtmf(TIMEOUT , ATTEMPTS, MAXDIGITS, DTMF_NAME, DEFAULT_BEHAVIOUR);
break;
case AbstractNotify::EVENT_IVR:
if (!empty($notify->wait_dtmf->digits)) {
$balance = getBalance($notify->wait_dtmf->digits);
$request->setIvrSayNumber($balance, 'en');
} elseif (!empty($notify->ivr_saynumber)) {
$request->setIvrSayPopular(POPULAR_PHRASE_NUM, 'en');
} else {
$request->setHangup();
}
}
$request->send();
```
We looking to further expand our method features and collecting feedback in the comments below. We also have other webhook methods and API available, you can see the full list [on the website](https://zadarma.com/en/support/api/). | https://habr.com/ru/post/474178/ | null | en | null |
# Определяем, что у пользователя заблокирована Википедия
Недавно Роскомнадзор [предпринял попытку блокировки доступа с территории РФ](http://habrahabr.ru/post/265367/) к Википедии. Попытка [провалилась](http://rublacklist.net/12468/), и самое время перейти в контрнаступление. В статье под катом я покажу, что, если пользователь Х зашёл на сайт А, то сайт А может определить, заблокирован ли для пользователя другой сайт Б.  А дальше, по [намечающейся традиции](http://habrahabr.ru/post/256339/), изложение пойдёт в вопросно-ответной форме.
Для чего это вообще нужно?
---------------------------
При обсуждении блокировки Википедии сообщество заметило два обстоятельства, которые весьма выгодны цензуре. Во-первых, Википедия использует HTTPS и, более того, HSTS. Это означает, что заблокирована энциклопедия может быть только целиком (с точностью до домена), но при этом перенаправить на пресловутую страницу с сообщением о блокировке нельзя. Вместо этого высвечивается сообщение об ошибке установления соединения. Это выглядит как внутренняя проблема Википедии и смягчает недовольство пользователя действиями Роскомнадзора; в то же время для развития правового государства необходима обратная связь. Во-вторых, даже если пользователи узнают о блокировке, многие из них просто не будут знать, что делать. Вешать перманентную плашку «Если заблокировали Википедию — качайте Tor Browser!» на неравнодушных сайтах как минимум странно; в то же время, оповещение пользователей о блокировке Википедии и способах её обхода необходимо. Решение поставленной проблемы и пытается дать настоящая статья.
Что это вообще такое?
---------------------
Это — достаточно универсальный способ определить доступность практически любого (предварительно исследованного) сайта на стороне клиента, средствами Javascript.
**UPD:** По совету товарищей [bakhirev](http://habrahabr.ru/users/bakhirev/) и [xobotyi](http://habrahabr.ru/users/xobotyi/) механизм работы изменён. Самая интересная часть с занимательной геометрией оказалось ненужной, определение переписано на событиях. Хочу демку!
------------
[Пожалуйста!](https://nickkolok.github.io/chas-antidot/demo.html)
**Та самая занимательная геометрия - распечатать при запрете кроссдоменных событий для изображений**
Как это работает?
------------------
Создаётся невидимый блок HTML-кода, содержащий два изображения: одно контрольное — с заведомо несуществующего URL, второе сигнальное — любое изображение с проверяемого сайта. Если их размеры через некоторое время совпадают — значит, изображение с проверяемого сайта не загрузилось, то есть он либо «лежит» настолько, что не может отдавать даже статику, либо заблокирован.
А подробнее?
-------------
Изображение в HTML, вставлемое тэгом img, по умолчанию имеет размеры, определяемые самим файлом-картинкой. Изображение, которое загрузить не удалось, тоже имеет какие-то размеры — в разных браузерах разные. Вот они (ширина x высота): * Firefox 37.0 — 24x24
* Chrome 44.0.2403.155 — 0x0 (до загрузки), 20x20 (при неудачной загрузке)
* Opera 12.16 — 114x22
Получить размеры элемента на Javascript можно с помощью свойств элемента .offsetWidth и .offsetHeight
А если вдруг сигнальное изображение по размерам совпадёт с тем, что отобразит браузер при ошибке?
--------------------------------------------------------------------------------------------------
Это достаточно маловероятно, учитывая, что сравниваются и ширина, и высота. Можно запросить два изображения заведомо разных размеров и сравнить их полученные размеры. Если совпадут — загрузка прошла неуспешно. И всё же фавиконы в качестве единственных изображений лучше не дёргать.
А исходники?
-------------
[На гитхабе](https://github.com/nickkolok/chas-antidot) под GPLv3.
И как этим всем пользоваться?
------------------------------
Постарался сделать код читабельным, хотя, конечно, это не освобождает меня от приведения примера.
```
chasAntidot.testSiteWithImg({
url: 'https://ru.wikipedia.org/static/images/project-logos/ruwiki.png', //URL картинки-детектора
ifBlocked: function(){message('заблокирована');}, //callback, если заблокировано
ifNotBlocked: function(){message('не заблокирована');}, //callback, если не заблокировано
time: 3500, //Время ожидания ответа в миллисекундах, по умолчанию 4000
secondImage: 'https://ru.wikipedia.org/favicon.ico', //URL второй картинки - необязательно
});
```
Никаких дополнительных библиотек типа jQuery не требуется, всё на чистом JS.
Хорошо, я готов информировать своих пользователей о возможной блокировке Википедии! Можно мне готовый код?
-----------------------------------------------------------------------------------------------------------
Во-первых, в любом случае саму библиотеку лучше скачать к себе на сайт. github.io не застрахован от блокировок. Во-вторых, для чистого JS возможен, например, такой вариант:
```
chasAntidot.createBanner(
'Вероятно, [Википедия](https://ru.wikipedia.org) заблокирована. [Узнайте, что нужно сделать!](http://rublacklist.net)',
{
url: 'https://ru.wikipedia.org/static/images/project-logos/ruwiki.png',
secondImage: 'https://ru.wikipedia.org/favicon.ico',
}
);
```
Это, конечно, работает, но не очень красиво :) Патчи, добавляющие функции создания баннеров с использованием различных библиотек, приветствуются!
А если действительно Википедия упадёт?
---------------------------------------
На этот случай можно использовать схожий механизм, сравнивая доступность картинки напрямую и через какой-нибудь анонимайзер. Ресурс в таком случае можно считать заблокиованным тогда и только тогда, когда через анонимайзер картинка видна, а напрямую — нет. Правда, анонимайзер тоже может быть заблокирован, и тогда придётся проверять ещё и его доступность — например, запрашивая через него картинку с сайта самого РКН.
Где ещё есть толк от этого в народном хозяйстве?
-------------------------------------------------
* Мобильная версия Википедии сможет точно вовремя предупредить пользователей о блокировке десктопной (они на разных адресах и на разных доменах), и наоборот.
* Вебмастер, установив на страницу скрипт с аналогичным принципом действия, сможет на лету менять ссылки на конечное количество заблокированных ресурсов на ссылки через прокси. Готового решения нет, но патчи принимаются.
* Можно точно выявлять пользователей, у которых заблокирован (неважно, госцензурой или работодателем) любимый сайт (ВКонтакте и т. д.) и предлагать им купить VPN/прокси или использовать бесплатный прокси с рекламой.
* ~~Можно~~[**Нельзя**](http://habrahabr.ru/post/266553/#comment_8567649) на клиенте определить факт использования TOR/I2P, запросив таким образом картинку с домена .onion / .i2p
* Хотите знать, активен ли у вашего пользователя IPv6? Просто загрузите картинку на какой-нибудь IPv6-адрес. Или воспользуйтесь картинками на серверах кого-нибудь крупного (типа Гугла), поддерживающего новый протокол.
* А ещё в некоторых случаях можно определить DNS, которым пользуется клиент. Например, OpenNIC и прочие NameCoin/.bit
* В веб-интерфейсах роутеров тоже бывают картинки! А значит, модель роутера при желании тоже можно определить, даже если веб-интерфейс извне недоступен.
* Наконец, можно проверять принадлежность к определённой сети. Например, у некоторых провайдеров есть целые поддомены с сайтами, доступными только своим абонентам. Неужели там не найдётся ни одной картинки? Можно проверять и принадлежность к корпоративным сетям — если, конечно, знать, какие ресурсы доступны только изнутри. Может быть, вы хотите показывать что-то особенное пользователям, заходящим в сеть по вайфаю из московского метро? Из распространённой сети кафе? Тогда стоит поискать на соответствующей странице авторизации картинки, доступные только изнутри! Хотя нельзя не признать, что определение по IP иногда более оправданно.
* **Нельзя** с помощью chrome extension URLs проверить наличие любого расширения, в котором есть отдельные файлы-картинки. У меня всегда получается «битая» картинка.
* В некоторых старых браузерах (IE6?), не блокирующих доступ к локальным картинкам, вероятно, можно с довольно неплохой точностью определять версии установленных у пользователя прикладных программ (Libre Office, GIMP, MS Office, Adobe Photoshop и т. д.) — достаточно знать, какие картинки какого размера характерны для каждой из версий. Конечно, это сработает, только если программа установлена в директорию по умолчанию, но, например, такой приём позволит вывести на сайте инструкции по установке программы, отсутствующей у пользователя, но необходимой для работы с сайтом. **В современных браузерах, скорее всего, не работает.** | https://habr.com/ru/post/266553/ | null | ru | null |
# DataGrip 2019.1: поддержка новых баз, инициализационные скрипты, новые инспекции и другое
Привет! Посмотрим на новые штуки в [DataGrip 2019.1](https://www.jetbrains.com/datagrip/download). Напомним, что функциональность DataGrip включена и в другие наши платные IDE, кроме WebStorm.
Поддержка новых баз
-------------------
В этом релизе сразу четыре базы получили официальную поддержку в наших инструментах:
**Apache Hive** – система управления базами данных на основе платформы Hadoop.
**Greenplum** – аналитическая СУБД для хранилищ данных на основе PostgreSQL.
**Vertica** – колоночная база для анализа больших данных.
**Snowflake** – облачное хранилище данных. Если говорить о реляционных базах, то Snowflake [просили больше всего](https://youtrack.jetbrains.com/issue/DBE-3024). В этом релизе мы поддержали только SQL, инстропекцию выпустим попозже.
Соединение
----------
Мы сделали изменения в диалоговом окне соединения с базой: постарались сделать более понятно и удобно.
### **General**
В этой вкладке, в основном, произошёл рефакторинг.
Поле **Connection type** раньше называлось **URL type** и было в самом низу. Но, так как значение в этом поле определяет дальнейший процесс, теперь оно наверху.
Поле **Database** расположили после ввода логина и пароля, потому что аутентификация нужна для того, чтобы отобразить список баз по *Ctrl/Cmd+Пробел*.
В комментариях к прошлому посту [много обсуждали](https://habr.com/ru/company/JetBrains/blog/431646/#comment_19458272) сохранение пароля. Добавили новых опций и сделали выпадающий список. Значения этого списка:
– Не сохранять пароль.
– Сохранять до перезапуска DataGrip (раньше так работала опция “не сохранять”).
– Сохранять на сессию: пока вы не отсоединитесь от источника данных.
– Сохранять навсегда.
Чтобы избежать непонятностей, пустой пароль вводите через контекстное меню.
Результаты *Test Connection* теперь показываются в самом окне, никаких лишних кликов и диалогов.
А если драйвера не скачаны, DataGrip предложит это сделать. Раньше кнопка *Test Connection* была в таком случае заблокирована, что путало пользователей.
### **Options**
Сюда из вкладки General переехали настройки *Read-only*, *Auto-sync*, *Transaction control*.
**Новое**:
– *Run keep-alive query each N seconds:* будет тыкать палочкой источник данных каждые N секунд. Для баз, которые мы не поддерживаем, вы можете сами написать keep-alive-запрос. Это делается в настройках драйвера.
– *Auto-**disconnect* *after N seconds*: введенное здесь значение в секундах укажет DataGrip, через какое время автоматически отсоединяться от источника данных.
– *Startup script*: Сюда можно вписать запрос, который будет выполняться при каждом создании подключения. Напомним, что если *Single connection
mode* не включен, для каждой новой консоли создаётся новое подключение.
### **Schemas**
Сюда переехал фильтр отображаемых в дереве объектов.
Навигация и поиск
-----------------
**Список последних местонахождений**
Новое окно Recent locations показывает, где вы недавно были. Элементы списка — это небольшие куски кода, которые вы недавно редактировали или смотрели. Это полезно, если вы помните контекст, но не помните название файла. В DataGrip такое часто происходит, потому что все консоли названы похожим образом :) Сочетание клавиш по умолчанию:
*Ctrl/Cmd+Shift+E.*
Если раньше вы использовали это сочетание клавиш для отображения списка недавно изменённых файлов, то теперь, пожалуйста, пользуйтесь двойным нажатием *Ctrl/Cmd+E*.
**Поиск по пути**
Мы убрали ненужные опции, которые “достались” нам от платформы: *Module* и *Project*. Теперь по умолчанию *Find in path* в DataGrip ищет везде. Ещё добавили новую область поиска *Attached Directories* — она включает в себя только файлы и папки из панели Files.
**Действия из результатов навигации**
Теперь из результатов навигации работают действия, которые применимы к объектам в коде или дереве. Например, вы ищете таблицу. Вот что можно сделать из окна с результатами.
– Посмотреть DDL: *Ctrl/Cmd+B*.
– Открыть данные: *F4*.
– Открыть окно Modify Table: *Ctrl/Cmd+F6*.
– Отобразить в другом контексте: *Alt+F1* (например, показать в дереве).
– Увидеть общую информацию: *Ctrl+Q/F1*.
– Сгенерировать SQL: *Ctrl/Cmd+Alt+G*.
Работа с кодом
--------------
**Комбинированные элементы в автодополнении**
Для `CREATE` и `DROP` автодополнение предлагает комбинированные варианты.
Не забывайте об аббревиатурах.
**Новые инспекции**
DataGrip предупредит, если вы используете курсор, который не открыли.
Следующие две инспекции выключены по умолчанию, но некоторым могут понадобится.
Если используете неименованные аргументы, это будет подсвечено.
Инспекция, которая ругается на оператор GOTO.
Работа с файлами
----------------
Добавили настройку для папки проекта по умолчанию. Новые проекты будут создаваться в этой папке.
Действие *Save as…* для консоли теперь:
– Предлагает проектную папку по умолчанию.
– Запоминает последний выбор.
В дереве файлов добавили действие *Detach Directory*: открепить папку. Раньше, чтобы открепить папку (то есть не показывать её в этом дереве), надо было нажать *Delete*, и DataGrip спрашивал: вы хотите удалить или открепить? Это было неудобно и непонятно :)
Дерево базы данных
------------------
Мы написали свою интроспекцию для DB2. Это означает, что информацию об объектах базы мы получаем при помощи запросов, а не через JDBC-драйвер, как раньше. В дереве, таким образом, появились объекты, которых раньше не было: триггеры, типы, методы, модули, счётчики, роли и другие.
Дерево хранит контекст: имя источника данных залипает сверху.
Для не поддерживаемых баз нарисовали иконки: те, у кого источники данных созданы для таких баз, перестанут путаться.
Ещё нарисовали абстрактных иконок, их можно использовать в настройках драйвера.
Остальное
---------
**Кастомные темы**
Пользователи DataGrip получили возможность делать любые цветовые схемы. Новая схема — это плагин, который надо поставить из раздела *Plugins* в настройках.
О том, как делать свои темы, читайте тут:
[Detailed tutorial about how to create your own custom Theme](http://www.jetbrains.org/intellij/sdk/docs/reference_guide/ui_themes/themes_intro.html).
[Blog post about creating custom themes for IntelliJ Platform](https://blog.jetbrains.com/platform/2019/03/creating-custom-themes-for-intellij-platform-ides)
Мы попробовали сделать пару новых сами. Выглядят они так:
*Cyan*
*Dark purple*
**Редактор данных**
Фильтр предлагает значения из буфера обмена.
Всё!
– [Более подробно тут (на англ.)](https://www.jetbrains.com/datagrip/whatsnew/)
– [Скачать триал на месяц](https://www.jetbrains.com/datagrip/download)
– [Твитер, который мы читаем](https://twitter.com/datagrip)
– Почта, которую мы читаем: datagrip@jetbrains.com
– [Баг-трекер](https://youtrack.jetbrains.com/issues/DBE)
– Комментарии, которые мы читаем ↓↓↓
Команда DataGrip | https://habr.com/ru/post/446620/ | null | ru | null |
# xCSS: придумываем свою спецификацию CSS. Часть 1
Моя предыдущая статья [«Чего я ждал от HTML5 и CSS3»](http://habrahabr.ru/blogs/webstandards/101746/) затронула достаточно щекотливую тему, но не ответила на вполне резонный вопрос, а что я предлагаю взамен. Поэтому мне в голову пришла идея сделать общественную спецификацию CSS, которая будет отражать современные тенденции развития web-технологий и требования к будущему функционалу. Я приглашаю всех поучаствовать в разработке нашей собственной версии спецификации. Если популярность ее будет достаточно высокой, ее могут принять все разработчики браузеров, а от этого выиграют и web-разработчики, и пользователи.
Первый механизм, который я представляю вашему вниманию называется «направляющие»
#### Направляющие
Цель данного механизма — упростить управление позиционированием элементов относительно друг друга. Табличное представление данных не позволяет создавать потоковые структуры, когда неизвестно количество элементов в строке, и элементы нужно переносить на следующую строку при изменении ширины контейнера. Строчные блоки (inline-block) не позволяют формировать автоматически подстраиваемые по высоте или ширине блоки. Именно эти проблемы и будет решать механизм направляющих.
#### Определение направляющих
Направляющие являются блочными элементами нулевой высоты или ширины, в зависимости от типа: горизонтальные или вертикальные. Нельзя управлять ни шириной, ни высотой направляющих, они занимают всегда 100% от ширины или высоты элемента. Направляющие могут иметь margin, padding, border, background, что позволит создавать определенные стилистические приемы.
#### Описание направляющих
Направляющие имеют специфическое поведение даже в рамках текущего CSS стандарта. Привязка их описания к конкретному элементу не позволит гибко управлять отображением в сложных случаях. Я предлагаю немного расширить синтаксис CSS, чтобы развязать руки и не повторять ошибок текущей спецификации, и ввести локальные идентификаторы.
> `$rule1 { /* rule preferences */ }
>
> $rule2 { ... }`
Нельзя использовать уже существующие селекторы идентификатора и класса в качестве локальной переменной, так как имя направляющей используется только внутри CSS, и никогда не должно использоваться напрямую в HTML. Есть еще одна проблема, которая не позволяет использовать идентификаторы и классы, но про нее я расскажу позже.
##### rule-type
Существуют два типа направляющих: *горизонтальные (horizontal)* и *вертикальные (vertical)*. По умолчанию направляющие имеют тип *horizontal*
> Значения свойства: horizontal || vertical
>
> Значение по умолчанию: horizontal
##### rule-repeat
Это свойство управляет повторением направляющих. По умолчанию для направляющих отключен механизм повторения.
> Значения свойства: none || repeat
>
> Значение по умолчанию: none
Механизм повторения необходим для того, чтобы автоматически формировать несколько направляющих с одинаковыми свойствами и идентификацией. Свойство *repeat* применяется только тогда, когда для горизонтального типа направляющих указан *margin-top* или *margin-bottom* или *padding-top* или *padding-bottom*, а для вертикальных направляющих, соответственно *margin-left* или *margin-right* или *padding-left* или *padding-right*.
Количество горизонтальных направляющих рассчитывается по формуле
*kh = containerHeight / ( ruleMarginTop + rulePaddingTop + rulePaddingBottom + ruleMarginBottom)*
Количество вертикальных направляющих рассчитывается по формуле
*kv = containerWidth / ( ruleMarginLeft + rulePaddingLeft + rulePaddingRight + ruleMarginRight)*
**Пример использования**
> `$myRule {
>
> rule-type: vertical;
>
> rule-repeat: repeat;
>
> margin-right: 10px;
>
> margin-left: 20px;
>
> padding-right: 50px;
>
> }`
##### rule
Для использования направляющих в некотором блоке используется директива *rule*
> Значения свойства: $ruleID[ $ruleID]
>
> Значение по умолчанию: none
Можно использовать одну или две переменные с направляющими разного типа. При использовании двух одинаковых типов направляющих данная директива не применяется.
#### Использование направляющих
После определения направляющих необходим механизм управления блоками. Для этого необходимо еще одно свойство *snap-to*, которое будет рассказывать элементам внутри блока с направляющими, как они должны взаимодействовать между собой.
##### snap-to
> Значения свойства: [top($ruleID)] [bottom($ruleID)] [left($ruleID)] [right($ruleID)] || [top] [bottom] [left] [right] || none
>
> Значение по умолчанию: none
В сложных ситуациях, когда блок с направляющими содержит другой блок с направляющими, лучше указывать прилипание к конкретному краю конкретной направляющей. В более простых случаях указывать идентификатор направляющей не обязательно.
Прилипание к краю аналогично поведению элемента с position: relative.
Я специально опущу более детальное поведение, так как это займет не одну страницу текста, и перейду к примерам
**Примеры использования**
Типичная задача — галлерея. Я знаю, что можно использовать inline-block, но добавив еще одну горизонтальную направляющую можно сделать аналог таблицы, что не получится сделать обычными средствами.
> $rule1 { margin-top: 200px; rule-repeat: repeat; }
>
> #gallery { rule: $rule1; }
>
> #gallery div { snap-to: bottom }
>
>
>
>
> …
>
>
>
>
Форма, у которой лейблы выровнены с формами по направляющей
> $rule1 { margin-left; 150px; rule-type: vertical; }
>
> #form { rule: $rule1; }
>
> #form label { snap-to: right }
>
> #form span { snap-to: left }
>
>
>
>
> Label1
>
> Label2
>
> Label3
>
>
>
>
Трехколоночный макет можно сделать вот так:
> $rule1 { margin-bottom; 100%; rule-repeat: repeat; }
>
> #wrapper { rule: $rule1; }
>
> #wrapper > div { snap-to: top($rule1) bottom($rule1) }
>
>
#### Заключение
У направляющих есть множество «белых пятен» в поведении, которые нужно исследовать, моделировать и изучать. Особенно это касается взаимоотношений прилипших элементов и обычного потока, прилипших и плавающих элементов, как должны себя вести элементы, если они прилипают к левому и нижнему краю сетки направляющих и так далее. Однако одно очевидно, что данный механизм не сильно изменяет уже действующие правила CSS2.1, а только дополняет их. Реализация направляющих, по моему мнению, гораздо более проста для разработчиков браузеров, чем реализация тех же темплейтов отображения в CSS3, а возможностей и динамики в моем способе больше.
Жду вашей критики, замечаний, дополнений. | https://habr.com/ru/post/102720/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #16
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [PourOver](http://nytimes.github.io/pourover/)
[](http://nytimes.github.io/pourover/)
Библиотека для реально быстрой фильтрации и сортировки огромных коллекций, где речь идет о сотне тысяч элементов. PourOver построен на идеально простых запросах, которые могут произвольно формироваться друг с другом. Вы сможете объединять, скрещивать и разделять запросы. PourOver будет помнить как были построены ваши запросы и по-умному обновлять их, если появятся новые элементы или будут изменены старые. Работает на IE7+, Firefox 4+, Safari 5+, Opera 9+, Chrome 1+.
Стоит также заметить, что это проект от New York Times, на корпоративном Гитхабе которого есть еще популярный [backbone.stickit](https://github.com/NYTimes/backbone.stickit) плагин для датабиндинга и [Tamper](https://github.com/NYTimes/tamper) — serialization protocol for categorical data. В последнее время гики из западных СМИ прямо раскочегарились — вот недавно я писал про классные проекты от The Guardian и Financial Times.
#### [Superhero.js](http://superherojs.com/#language)
[](http://superherojs.com/)
Superhero — это кладезь полезнейшей информации для JavaScript разработчиков. Это коллекция лучших статей по JavaScript, которые разделены на несколько блоков:
1. [Понимание JavaScript](http://superherojs.com/#language): синтаксис, стиль и подводные камни
2. [Организация вашего кода](http://superherojs.com/#organizing): API дизайн, паттерны и фреймворки
3. [Тестирование вашего приложение](http://superherojs.com/#testing): тестируемый код, читаемые тесты
4. [Профессиональные инструменты](http://superherojs.com/#tools): Workflow, Debugging
5. [Производительность и профилирование](http://superherojs.com/#performance): быстрый и эффективный код
6. [Безопасность](http://superherojs.com/#security): принципы, управление доступом и валидация
7. [Под капотом](http://superherojs.com/#browser): понимание работы браузеров
8. [На горизонте](http://superherojs.com/#next): вещи, на которые нужно обратить внимание
9. [«Удивительная лига»](http://superherojs.com/#resources): другие супергероические ресурсы
#### [Jeet](http://jeet.gs/)
[](http://jeet.gs/)
Простой для понимания и быстрый в использовании инструмент для построения сеток. Основан на препроцессорах SASS и Stylus. Имеет ряд преимуществ перед популярными CSS фреймворками.
#### [Mach.js](https://github.com/mjijackson/mach)
«Лучший путь для построения полностью асинхронного сервера на Node.js».
* Простота: прямой mapping HTTP запросов к JS функциям
* Асинхронность: ответы могут быть отложены, используя standard Promises/A+ compatible promise
* Streaming
* Компонуемость
```
var mach = require('mach');
var app = mach.stack();
app.use(mach.gzip);
app.use(mach.logger);
app.use(mach.contentType, 'text/html');
app.use(mach.file, 'public');
app.map('files.example.com', function (app) {
app.use(mach.file, '/www/static-files');
});
app.use(mach.session, 'session secret');
app.use(mach.params);
app.get('/', function (request) {
return "Hello world!";
});
app.get('/posts/:postId.json', function (request, postId) {
return query('SELECT * FROM posts WHERE id=?', postId).then(function (post) {
return post ? mach.json(post) : 404;
});
});
app.post('/posts/:postId/comments', function (request, postId) {
return createComment(postId, request.params).then(function (comment) {
return mach.json(comment, 201);
}, function (error) {
return mach.json({ error: error.message }, 403);
});
});
app.get('/legacy-url', function (request) {
return mach.redirect('/new-url', 301);
});
mach.serve(app, 3000);
```
#### [Vis.js](https://github.com/almende/vis/)
[](https://github.com/almende/vis/)
Библиотека для динамической визуализации данных. С легкостью позволяет управлять большим количеством данных, а также манипулировать и взаимодействовать с ними. Множество различных вариантов визуализации.
```
var container = document.getElementById('mytimeline');
var data = [
{id: 1, content: 'item 1', start: '2013-04-20'},
{id: 2, content: 'item 2', start: '2013-04-14'},
{id: 3, content: 'item 3', start: '2013-04-18'},
{id: 4, content: 'item 4', start: '2013-04-16', end: '2013-04-19'},
{id: 5, content: 'item 5', start: '2013-04-25'},
{id: 6, content: 'item 6', start: '2013-04-27'}
];
var options = {};
var timeline = new vis.Timeline(container, data, options);
```
Говоря о визуализации, хочу также поделиться проектом Treed — [Powerful Tree Editing Component](https://github.com/jaredly/treed).
#### Западные мысли или что стоило бы перевести на Хабре:
* [How my app got 455K users in the first week](http://alexcican.com/post/455k-users/)
* [5 Essential Elements for E-Commerce Websites](http://designmodo.com/elements-e-commerce-websites/)
* [12 Little-Known CSS Facts](http://www.sitepoint.com/12-little-known-css-facts/)
* [Improve the payment experience with animations](https://medium.com/p/3d1b0a9b810e)
* [Surfing Modern Web With Ancient Browsers](http://virtuallyfun.superglobalmegacorp.com/?p=3866)
* [Stop Worrying About People Stealing Your Ideas](http://speckyboy.com/2014/04/16/stealing-your-ideas/)
* [Understanding CSS Timing Functions](http://www.smashingmagazine.com/2014/04/15/understanding-css-timing-functions/)
* [What You Need To Know About WordPress 3.9](http://www.smashingmagazine.com/2014/04/17/what-you-need-to-know-about-wordpress-3-9/)
* [The Death of the Web Design Agency?](http://alistapart.com/blog/post/the-death-of-the-web-design-agency)
#### Напоследок:
* Не понятно почему Яндекс не сообщили об этом здесь, поэтому с радостью сообщу об этом я — [Яндекс открывает набор участников](http://blog.yandex.ru/post/78842/) по трем своим академическим программам: Школа анализа данных (ШАД), Школа менеджеров Яндекса (ШМЯ) и на летние стажировки.
* Знаменитым комиксам и супергероям от Marvel исполнилось 75 лет. По этому случаю создали шедевральный промо сайт. Буквально пару лет назад "[такого](http://marvel75th.tristanfarneau.fr/#date-2014)" без флеша ~~и прочей черной магии~~ просто не могло быть. А ведь многие до сих пор ругают W3C и постоянно чем то недовольны...[](http://marvel75th.tristanfarneau.fr/#date-2014)
* [HTML5 Security Cheatsheet](https://github.com/cure53/H5SC) — целый сборник XSS примеров.
* [Touchy.js](https://github.com/HotStudio/touchy) — небольшой event плагин для jQuery, помимо стандартных событий в нем есть «вращение» и «вращение с инерцией.
* [Conditioner.js](http://conditionerjs.com/) — построен на RequireJS и выполняет JavaScript только в случае соблюдения заданных условий.
* [PEAS](https://github.com/tombh/peas) — Docker and Ruby based PaaS.
* Документируем с [GitBook](https://github.com/GitbookIO/gitbook).
* [Ripple](https://github.com/ripplejs/ripple) — очередной „реактивный“ MVC с 500+ старов.
* [Mailcover](https://mailcover.com) — простой и приятный сервис для проверки email адресов на валидность c JSONP/XML API и статисткой.
* [html5shiv](https://github.com/aFarkas/html5shiv) теперь поддерживает тег .
* Относительно недавно я написал про [один крутой Gist — whiteboardCleaner](http://habrahabr.ru/post/218195/), после чего хабраюзер на основе этого [сделал веб-сервис](http://api.o2b.ru/whiteboardcleaner#sthash.Vc6qWR8Y.dpbs).
Уважаемые читатели. Последнее время некоторые из вас обращались ко мне с просьбой посмотреть на проект и при возможности упомянуть его в одной из подборок. Если вы считаете, что ваши разработки действительно будут полезны и интересны для хабражителей, то я всегда рад знать об их существовании. Мои контакты в профиле на Хабре, но удобнее всего коротко в Twitter [@ilya\_pestov](https://twitter.com/ilya_pestov). А еще я предлагаю делиться всеми „крутыми штуками“ для веб-дева используя хештег [#задарма](https://twitter.com/search?q=%23%D0%B7%D0%B0%D0%B4%D0%B0%D1%80%D0%BC%D0%B0&src=typd&f=realtime) и возможно некоторые из них появятся в следующей подборке интересностей и полезностей.
[**Предыдущая подборка (Выпуск 15)**](http://habrahabr.ru/post/218197/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание.
**UPD:** кому не нравится хештег #задарма предложите пожалуйста свои варианты в комментариях. Я исходил из следующего: во-первых — я хочу создать тег именно для веб-дев полезностей и именно для аудитории Хабра, чтобы не было всякого шлака; во-вторых — я не хочу использовать американское „freebies“, дабы не смешивать нашу с вам тему и я в принципе против неологизмов, которых и так в нашем языке много; в третьих дословный перевод „freebies“ — »халява", поэтому я отрыл старое русское аккуратное слово «задарма» — за даром.
С великим праздником святой пасхи! | https://habr.com/ru/post/220005/ | null | ru | null |
# Работа с графикой на языке Rust. Часть 2
В этой статье я продолжу перевод и исследование *WGPU*, библиотеки языка Rust для работы с графикой.
Для тех, кто не читал [первую](https://habr.com/ru/post/690514/) статью небольшая вводная информация.
*WGPU* реализует современный стандарт работы с видео подсистемами — *WebGPU и компилируется в разные backend-ы (OpenGL, DirectX12, Metal, Vulkan, WebGL). Он одновременно проще для освоения, чем Vulkan и имеет более продуманное апи, чем OpenGL.*
Приступим!
### Урок 4. Текстуры
Текстурами называют изображения, которые накладывают поверх сетки (фигуры) для того, чтобы придать ей фактуру и/или детализацию.
#### Загрузка изображения
Первым делом, нам нужно добавить само изображение в папку с проектом.
Для этого, я сделал папку `assets` и положил туда картинку:
Для чтения файла я буду использовать `image` crate:
`image = "0.24"`
Далее, я сделаю отдельный модуль — `texture`:
```
use std::error::Error;
pub struct Texture {
pub texture: wgpu::Texture,
pub view: wgpu::TextureView,
pub sampler: wgpu::Sampler,
}
```
Сделаем новый метод `Texture::from_image`:
```
pub fn from_image(
device: &wgpu::Device,
queue: &wgpu::Queue,
img: ℑ::DynamicImage,
label: Option<&str>
) -> Self {
let diffuse_rgba = img.to_rgba8(); // 1
use image::GenericImageView;
let dimensions = img.dimensions();
let size = wgpu::Extent3d { // 2
width: dimensions.0,
height: dimensions.1,
// Мы будем работать в 2D пространстве, поэтому используем только один слой
depth_or_array_layers: 1,
};
let texture = device.create_texture( // 3
&wgpu::TextureDescriptor {
label,
size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
// Указываем режим преобразования цвета из формата sRGB в линейное float [0, 1] значение
format: wgpu::TextureFormat::Rgba8UnormSrgb,
// TEXTURE_BINDING флаг устанавливается, если нужно использовать текстуру в шейдере
// COPY_DST говорит, что позже мы будем копировать позже изображение в эту текстуру
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
}
);
...
```
1. Преобразуем изображение в массив rgba байтов
2. Задаем (эмулируем) размерность в 3D пространстве
3. Создаем тектуру
Сейчас текстура пустая и нужно скопировать туда изображение:
```
...
// Копируем изображение в созданную выше текстуру
queue.write_texture(
// Задаем, куда копировать изображение
wgpu::ImageCopyTexture {
aspect: wgpu::TextureAspect::All,
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
// Массив rgba пикселей
&rgba,
// Схема расположения данных
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: std::num::NonZeroU32::new(4 * dimensions.0),
rows_per_image: std::num::NonZeroU32::new(dimensions.1),
},
size,
);
Self { texture, view, sampler }
}
```
#### Фильтрация текстур
Эту часть я долго не знал, как перевести, потому что не имел дело с `Sampler`-ами. Прежде чем разбираться со следующим фрагментом кода, дам небольшую вводную информацию.
Текстурные координаты не зависят от разрешения самой текстуры или экрана. Это означает, что где-то есть механизм, отвечающий за сопоставление *текстурных пикселей* (иногда их называют **тексели**) с текстурными координатами. И `Sampler` как раз и является этим механизмом, у которого есть несколько режимов работы:
```
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
let sampler = device.create_sampler(
&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge, // 1
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear, // 2
min_filter: wgpu::FilterMode::Nearest, // 3
mipmap_filter: wgpu::FilterMode::Nearest,
..Default::default()
}
);
```
1. Мы можем задать разные режимы для каждой из координат `address_mode_*`
2. Какой фильтр использовать, когда нужно растянуть (magnify) текстуру
3. Какой фильтр использовать, когда нужно сжать (minify) текстуру
`FilterMode` предоставляет две опции:
* `Linear` смешивает цвет ближайших к текстурной координате текселей. Чем ближе тексель к заданой координате, тем больший вклад он внесет в итоговый цвет. Этот метод еще называют билинейной интерполяцией
* `Nearest` берет цвет ближайшего к текстурной координате текселя. В этом режиме при близком рассмотрении можно увидеть угловатые узоры и пикселизацию.
Рассмотрим режимы работы `Sampler` (*AddressMode*):
* `ClampToEdge` любой тексель, выходящий за пределы текстурных координат, примет цвет ближайшего к границе текстуры пикселя
* `Repeat` по-русски — замостить, текстура будет повторяться по всей площади фигуры
* `MirrorRepeat` похоже на `Repeat`, только изображение будет перевернуто, при выходе за границы текстуры
Нам понадобится еще один вспомогательный метод, который будет читать изображение:
```
pub fn from_bytes(
device: &wgpu::Device,
queue: &wgpu::Queue,
bytes: &[u8],
label: &str
) -> anyhow::Result {
let img = image::load\_from\_memory(bytes)?;
Ok(Self::from\_image(device, queue, &img, Some(label)))
}
```
Здесь я использовал `anyhow::Result` из [крейта](https://docs.rs/anyhow/latest/anyhow/) `anyhow = "1.0.64"`, для удобной работы с ошибками.
Теперь можно создать текстуру в методе `State::new`:
```
surface.configure(&device, &config);
// Создаем текстуру
let diffuse_bytes = include_bytes!("../assets/tree.png");
let diffuse_texture = Texture::from_bytes(&device, &queue, diffuse_bytes, "tree.png").unwrap();
```
Мы создали текстуру, `view`, `sampler`, но они пока не выполняют никакой работы. Давайте объедению их вместе!
#### BindGroup
`BindGroup` описывает набор ресурсов и схему данных для шейдеров. Мы объеденим ресурсы, сделанные выше.
Перед созданием `BindGroup`, нужно сделать `BindGroupLayout`:
```
...
let texture_bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0, // 1
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1, // 2
visibility: wgpu::ShaderStages::FRAGMENT,
// Здесь указываем SamplerBindingType::Filtering, потому что выше в sample_type указано filterable: true
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
label: Some("texture_bind_group_layout"),
});
```
Эта схема данных содержит 2 связывания: первое для текстуры, второе для `Sampler`. Они будут видны только во фрагментном (`ShaderStages::FRAGMENT`) шейдере.
Поле `visibility` принимает битовую маску из значений `NONE`, `VERTEX`, `FRAGMENT`, или `COMPUTE`. Для текстур чаще всего используется `FRAGMENT`.
Теперь можно сделать `BindGroup`:
```
...
let diffuse_bind_group = device.create_bind_group(
&wgpu::BindGroupDescriptor {
layout: &texture_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&diffuse_texture.view), // 1
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler), // 2
}
],
label: Some("diffuse_bind_group"),
}
);
```
Я использую `diffuse_texture.view` и `diffuse_texture.sampler`, сделанные выше. `BindGroup` является частным случаем `BindGroupLayout`, поэтому между ними есть некоторое сходство. В *WGPU* их разделили для того, чтобы переключать их динамически (во время выполнения программы), но при этом, чтобы у них была одна схема данных (BindGroupLayout). Позднее, мы будем хранить каждую текстуру в своем `BindGroup`.
Осталось добавить поля в структуру `State`:
```
struct State {
surface: wgpu::Surface,
device: wgpu::Device,
queue: wgpu::Queue,
config: wgpu::SurfaceConfiguration,
size: winit::dpi::PhysicalSize,
render\_pipeline: wgpu::RenderPipeline,
vertex\_buffer: wgpu::Buffer,
index\_buffer: wgpu::Buffer,
num\_indices: u32,
// NEW!
diffuse\_bind\_group: wgpu::BindGroup,
diffuse\_texture: texture::Texture,
}
```
И вернуть `diffuse_bind_group` и `diffuse_texture`:
```
impl State {
async fn new() -> Self {
// ...
Self {
surface,
device,
queue,
config,
size,
render_pipeline,
vertex_buffer,
index_buffer,
num_indices,
// NEW!
diffuse_bind_group,
diffuse_texture,
}
}
}
```
Мы сделали подготовительные действия, теперь можно воспользоваться `diffuse_bind_group` и добавить его в рендеринг:
```
// render()
// ...
render_pass.set_pipeline(&self.render_pipeline);
render_pass.set_bind_group(0, &self.diffuse_bind_group, &[]); // NEW!
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
```
#### PipelineLayout
Помните `PipelineLayout`, который мы сделали во [втором](https://../../lesson2/docs/index.md) уроке? В нем задаются все `BindGroupLayout`, которые будут использоваться в пайплайне.
```
async fn new(...) {
// ...
let render_pipeline_layout = device.create_pipeline_layout(
&wgpu::PipelineLayoutDescriptor {
label: Some("Render Pipeline Layout"),
bind_group_layouts: &[&texture_bind_group_layout], // NEW!
push_constant_ranges: &[],
}
);
// ...
```
Теперь можно будет использовать `texture_bind_group_layout` в пайплайне!
#### Новый вершинный буфер
Посмотрим на структуру `Vertex`:
```
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct Vertex {
position: [f32; 3],
color: [f32; 3],
}
```
Мы напрямую задавали цвет в вершинном буфере. Заменим поле `color` на `tex_coords`, так как теперь цвет будет вычисляться во фрагментном шейдере с помощью текстуры:
```
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct Vertex {
position: [f32; 3],
tex_coords: [f32; 2],
}
```
Так как текстурные координаты кодируются двумя значениями f32, нужно внести соответствующие изменения и в `Vertex::description`:
```
...
wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float32x2, // было Float32x3
}
...
```
Теперь обновим сам вершинный буфер:
```
const VERTICES: &[Vertex] = &[
Vertex { position: [-0.0868241, 0.49240386, 0.0], tex_coords: [0.4131759, 0.99240386], }, // A
Vertex { position: [-0.49513406, 0.06958647, 0.0], tex_coords: [0.0048659444, 0.56958647], }, // B
Vertex { position: [-0.21918549, -0.44939706, 0.0], tex_coords: [0.28081453, 0.05060294], }, // C
Vertex { position: [0.35966998, -0.3473291, 0.0], tex_coords: [0.85967, 0.1526709], }, // D
Vertex { position: [0.44147372, 0.2347359, 0.0], tex_coords: [0.9414737, 0.7347359], }, // E
];
```
#### Шейдеры
Заключительный этап, перед тем, как мы увидим результат — текстуру на нашем пентагоне. Мы изменили структуру `Vertex`, эти же изменения нужно отразить в вершинном шейдере:
```
// Вершинный шейдер
struct VertexInput {
@location(0) position: vec3,
@location(1) tex\_coords: vec2, // NEW!
};
struct VertexOutput {
@builtin(position) clip\_position: vec4,
@location(0) tex\_coords: vec2, // NEW!
};
@vertex
fn vs\_main(
model: VertexInput,
) -> VertexOutput {
var out: VertexOutput;
out.tex\_coords = vec2(model.tex\_coords.x, 1.0 - model.tex\_coords.y); // NEW!
out.clip\_position = vec4(model.position, 1.0);
return out;
}
```
Обратите внимание на строку `out.tex_coords = vec2(model.tex\_coords.x, 1.0 - model.tex\_coords.y)`.
В ней я инвертировал координату `y`, чтобы картинка не была перевернутая. Это связано тем, что в *WGPU* координата `y` направлена вверх, а в текстурах она направлена вниз.
Обновим также фрагментный шейдер:
```
// Фрагментный шейдер
@group(0) @binding(0)
var t_diffuse: texture_2d;
@group(0) @binding(1)
var s\_diffuse: sampler;
@fragment
fn fs\_main(in: VertexOutput) -> @location(0) vec4 {
return textureSample(t\_diffuse, s\_diffuse, in.tex\_coords);
}
```
Должно получиться вот так:
#### Домашнее задание
Добавьте возможность менять текстуру по нажатию на кнопку space.
Ссылка на [код](https://github.com/abritov/rust-wgpu-tutorial/tree/master/lesson4) урока
Ссылка на [оригинал](https://sotrh.github.io/learn-wgpu/beginner/tutorial5-textures/#loading-an-image-from-a-file)
### Урок 5. Uniform буфер и 3D камера
Хотя до этого мы рисовали только двухмерные фигуры, на самом деле, мы работали в трехмерном пространстве. Именно поэтому структура `Vertex::position` имеет 3 координаты, а не 2. Но мы никак не можем увидеть трехмерное пространство. Чтобы это исправить, добавим камеру.
#### Создаем перспективу
Этот туториал больше про *WGPU*, поэтому здесь не будет в деталях рассматриваться математические аспекты работы с камерой, только практика. Если же вы хотите лучше разобраться в этой теме вам [сюда](https://ravesli.com/urok-9-kamera-v-opengl/#toc-0) и [сюда](https://ravesli.com/urok-7-transformatsii-v-opengl/). Мы будем использовать [cgmath](https://docs.rs/cgmath/latest/cgmath/), который возьмет на себя всю работу с вычислениями. Добавьте его в зависимости проекта:
```
cgmath = "0.18.0"
```
Теперь можно сделать структуру для работы с камерой. Я сделаю отдельный файл `camera.rs`:
```
#[rustfmt::skip]
pub const OPENGL_TO_WGPU_MATRIX: cgmath::Matrix4 = cgmath::Matrix4::new(
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.0, 0.0, 0.5, 1.0,
);
pub struct Camera {
pub eye: cgmath::Point3,
pub target: cgmath::Point3,
pub up: cgmath::Vector3,
pub aspect: f32,
pub fovy: f32,
pub znear: f32,
pub zfar: f32,
}
impl Camera {
pub fn build\_view\_projection\_matrix(&self) -> cgmath::Matrix4 {
let view = cgmath::Matrix4::look\_at\_rh(self.eye, self.target, self.up); // 1
let proj = cgmath::perspective(cgmath::Deg(self.fovy), self.aspect, self.znear, self.zfar); // 2
return OPENGL\_TO\_WGPU\_MATRIX \* proj \* view; // 3
}
}
```
Самое интересное происходит в `build_view_projection_matrix`:
1. Матрица `view` перемещает мир в позицию камеры. Она будет преобразовывать мировые координаты в координаты пространства окна
2. Матрица `proj` создает эффект перспективы. Без нее близкие и далекие объекты были бы одного размера
3. В *WGPU* используется координатная система DirectX & Metal. Это значит, что в нормализованных координатах (независимых от размера экрана) *WGPU* оси `x` и `y` находятся в промежутке `[-1.0, +1.0]`, а ось `z` в `[0.0, +1.0]`. В то же время `cgmath` сделан для координатной системы *OpenGL*. Поэтому я использую матрицу `OPENGL_TO_WGPU_MATRIX` для трансляции координат.
Добавим теперь камеру в метод `State::new`:
```
struct State {
// ...
camera: Camera,
// ...
}
async fn new(window: &Window) -> Self {
// let diffuse_bind_group ...
let camera = Camera {
// координаты камеры
eye: (0.0, 1.0, 4.0).into(),
// смотрим на центр
target: (0.0, 0.0, 0.0).into(),
up: cgmath::Vector3::unit_y(),
aspect: config.width as f32 / config.height as f32,
fovy: 45.0,
znear: 0.1,
zfar: 100.0,
};
Self {
// ...
camera,
// ...
}
}
```
Теперь у нас есть камера и проекция, нужно каким-то образом отправить ее в шейдер.
#### Uniform буфер
До этого момента мы использовали буферы для хранения вершинного, индексных массивов и даже текстур. Рассмотрим специальный буфер — *uniform*. Он отличаются тем, что доступен в любом месте в шейдерах (как глобальные переменные). На самом деле, мы уже использовали его для текстуры и *sampler*-а. Давайте сделаем еще один буфер для хранения матрицы проекции!
Добавим в файл `camera.rs` следующий код:
```
// Данные, которые будут отправляться в шейдер нужно пометить специальной аннотацией
#[repr(C)]
// Pod & Zeroable для удобного приведения типов перед отправкой в WGPU
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct CameraUniform {
// We can't use cgmath with bytemuck directly so we'll have
// to convert the Matrix4 into a 4x4 f32 array
view_proj: [[f32; 4]; 4],
}
impl CameraUniform {
fn new() -> Self {
use cgmath::SquareMatrix;
Self {
view_proj: cgmath::Matrix4::identity().into(),
}
}
fn update_view_proj(&mut self, camera: &Camera) {
self.view_proj = camera.build_view_projection_matrix().into();
}
}
```
Теперь сделаем сам буфер в методе `State::new`:
```
// создание камеры
let mut camera_uniform = CameraUniform::new();
camera_uniform.update_view_proj(&camera);
let camera_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Camera Buffer"),
contents: bytemuck::cast_slice(&[camera_uniform]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
}
);
// ...
```
#### Uniform буфер и BindGroup
Чтобы мы могли отправить буфер в видеокарту, нужно создать разметку (схему данных, layout):
```
// ...
let camera_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX, // 1
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false, // 2
min_binding_size: None,
},
count: None,
}
],
label: Some("camera_bind_group_layout"),
});
// ...
```
1. Буфер камеры нужен только в вершинном шейдере
2. Поле `dynamic` обозначает, будет ли изменяться размер этого буфера. Это полезно, если вы храните массивы
После создания схемы данных, создадим `BindGroup` для буфера камеры:
```
// ...
let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &camera_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: camera_buffer.as_entire_binding(),
}
],
label: Some("camera_bind_group"),
});
// ...
```
Так же, как и с текстурой, нужно зарегистрировать схему данных буфера (для если вдруг вы захотите поменять буфер во время выполнения программы):
```
let render_pipeline_layout = device.create_pipeline_layout(
&wgpu::PipelineLayoutDescriptor {
label: Some("Render Pipeline Layout"),
bind_group_layouts: &[
&texture_bind_group_layout,
// NEW!
&camera_bind_group_layout,
],
push_constant_ranges: &[],
}
);
```
Добавим новые поля в структуру `State`:
```
struct State {
// ...
camera: Camera,
camera_uniform: CameraUniform,
camera_buffer: wgpu::Buffer,
camera_bind_group: wgpu::BindGroup,
}
async fn new(window: &Window) -> Self {
// ...
Self {
// ...
camera,
camera_uniform,
camera_buffer,
camera_bind_group,
}
}
```
Теперь у нас есть все для того, чтобы использовать новую камеру в методе `State::render`:
```
render_pass.set_pipeline(&self.render_pipeline);
render_pass.set_bind_group(0, &self.diffuse_bind_group, &[]);
// NEW!
render_pass.set_bind_group(1, &self.camera_bind_group, &[]);
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
render_pass.draw_indexed(0..self.num_indices, 0, 0..1);
```
#### Обращение к uniform буферу в шейдере
Добавьте в ваш шейдер структуру `CameraUniform` (1), uniform буфер (2) и обновите `clip_position` (3) следующим образом:
```
// Вершинный шейдер
struct CameraUniform {
view_proj: mat4x4,
};
// 1
@group(1) @binding(0)
var camera: CameraUniform;
struct VertexInput {
@location(0) position: vec3,
@location(1) tex\_coords: vec2,
}
struct VertexOutput {
@builtin(position) clip\_position: vec4,
@location(0) tex\_coords: vec2,
}
@vertex
fn vs\_main(
model: VertexInput,
) -> VertexOutput {
var out: VertexOutput;
out.tex\_coords = vec2(model.tex\_coords.x, 1.0 - model.tex\_coords.y);
out.clip\_position = camera.view\_proj \* vec4(model.position, 1.0); // 2
return out;
}
```
1. Так как мы добавили новую `BindGroup`, нужно явно указать индекс, какой именно `BindGroup` использовать для данной переменной, который определяется в `render_pipeline_layout`. `texture_bind_group_layout` идет в списке первой, поэтому имеет индекс 0. Поэтому `camera_bind_group` будет идти под индексом 1
2. Порядок умножения важен при использовании матриц. `matrix_a` \* `matrix_b` != `matrix_b` \* `matrix_a`
#### Контроллер камеры
Такой результат должен получиться. Мы как будто смотрим издалека, поэтому картинка уменьшилась. Но пока что все еще не понятно, что мы в 3D пространстве.
Добавим возможность вращать картинку:
```
pub struct CameraController {
speed: f32,
is_forward_pressed: bool,
is_backward_pressed: bool,
is_left_pressed: bool,
is_right_pressed: bool,
}
impl CameraController {
pub fn new(speed: f32) -> Self {
Self {
speed,
is_forward_pressed: false,
is_backward_pressed: false,
is_left_pressed: false,
is_right_pressed: false,
}
}
pub fn process_event(&mut self, event: &WindowEvent) -> bool {
match event {
WindowEvent::KeyboardInput {
input: KeyboardInput {
state,
virtual_keycode: Some(keycode),
..
},
..
} => {
let is_pressed = *state == ElementState::Pressed;
match keycode {
VirtualKeyCode::W | VirtualKeyCode::Up => {
self.is_forward_pressed = is_pressed;
true
}
VirtualKeyCode::A | VirtualKeyCode::Left => {
self.is_left_pressed = is_pressed;
true
}
VirtualKeyCode::S | VirtualKeyCode::Down => {
self.is_backward_pressed = is_pressed;
true
}
VirtualKeyCode::D | VirtualKeyCode::Right => {
self.is_right_pressed = is_pressed;
true
}
_ => false,
}
}
_ => false,
}
}
pub(crate) fn update_camera(&self, camera: &mut Camera) {
use cgmath::InnerSpace;
let forward = camera.target - camera.eye;
let forward_norm = forward.normalize();
let forward_mag = forward.magnitude();
if self.is_forward_pressed && forward_mag > self.speed {
camera.eye += forward_norm * self.speed;
}
if self.is_backward_pressed {
camera.eye -= forward_norm * self.speed;
}
let right = forward_norm.cross(camera.up);
// Корректировка на случай, если нажаты кнопки вперед/назад
let forward = camera.target - camera.eye;
let forward_mag = forward.magnitude();
if self.is_right_pressed {
// Нужно пересчитать расстояние между target и eye чтобы оно не менялось
// Таким образом eye будет находиться в диапазоне между target и eye
camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
}
if self.is_left_pressed {
camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
}
}
}
```
Этот код не идеален, но все же он работает. Можете допилить его под свои нужды!
И, как обычно, нужно добавить контроллер камеры в структуру `State`:
```
struct State {
// ...
camera: Camera,
// NEW!
camera_controller: CameraController,
// ...
}
// ...
impl State {
async fn new(window: &Window) -> Self {
// ...
let camera_controller = CameraController::new(0.2);
// ...
Self {
// ...
camera_controller,
// ...
}
}
}
```
Теперь мы можем добавить обработку событий камеры в метод `State::input`:
```
fn input(&mut self, event: &WindowEvent) -> bool {
self.camera_controller.process_events(event)
}
```
Но, как ни странно, камера все еще не двигается! По факту, мы только меняем состояние камеры в памяти процесса, поэтому итоговая картинка никак не меняется. Чтобы это исправить, нужно обновить uniform буфер камеры. Есть несколько способов, как это сделать:
1. Создать отдельный буфер и скопировать туда содержимое `camera_buffer`. Новый буфер называют staging буфер. Обычно, применяется именно этот способ, потому что ‘camera\_buffer’ доступен только внутри видеокарты, что позволяет сделать GPU оптимизацию скорости
2. Использовать асинхронные методы буфера `map_read_async` и `map_read_async`. В целом, это более сложный подход (потому что асинхронный), вместе с которым нужно будет еще использовать `BufferUsages::MAP_READ` и/или `BufferUsages::MAP_WRITE`
3. Использовать метод `queue.write_buffer`
Я выбираю номер три:
```
fn update(&mut self) {
self.camera_controller.update_camera(&mut self.camera);
self.camera_uniform.update_view_proj(&self.camera);
self.queue.write_buffer(&self.camera_buffer, 0, bytemuck::cast_slice(&[self.camera_uniform]));
}
```
Теперь, когда все готово, нужно вызвать метод `State::update` в главном цикле `main.rs`:
```
Event::RedrawRequested(window_id) if window_id == window.id() => {
// NEW!
state.update();
match state.render() {
Ok(_) => {}
Err(wgpu::SurfaceError::Lost) => state.resize(state.size),
Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
// Все остальные ошибки будут обработаны в следующем кадре
Err(e) => eprintln!("{:?}", e),
}
}
```
Это все, что нужно было сделать. Теперь вы можете управлять камерой с помощью кнопок *wsad*. Этот пентагон напоминает мне карточки из игры Гарри Поттер, сравните:
#### Домашнее задание
Сделайте так, чтобы модель вращалась отдельно от камеры (как на гифке). Подсказка: вам понадобится еще одна матрица.
Ссылка на [код](https://github.com/abritov/rust-wgpu-tutorial/tree/master/lesson4) урока
Ссылка на [оригинал](https://sotrh.github.io/learn-wgpu/beginner/tutorial6-uniforms/#a-perspective-camera)
### Урок 6. Instancing
Сейчас наша сцена очень простая, один объект в точке (0, 0, 0). Как сделать больше объектов? Техника клонирования (отрисовки одного и того же объекта в разных местах) называется **instancing**.
Есть много способов, как можно размножить объекты. Например, можно включить в *uniform* буфер изменяющиеся параметры (позиция и вращение) и обновлять их каждый раз, когда отрисовывается объект.
Это расточительно с точки зрения производительности. Обновление uniform буфера для каждого инстанса увеличить количество операций копирования в *каждом кадре*. Кроме того, потребуется дополнительный буфер для обновленных данных.
Как можно сделать лучше?
Давайте посмотрим на сигнатуру draw\_indexed:
```
pub fn draw_indexed(
&mut self,
indices: Range,
base\_vertex: i32,
instances: Range // <-- Вот сюда
)
```
Аргумент `instances` принимает список инстансов, которые нужно отрисовать. Это и есть решение! Если я укажу `0..5`, тогда будет отрисовано 5 объектов.
Тип `Range` выглядит странно, почему просто не использовать `u32`, если этот аргумент определяет количество объектов?
Причина в том, что иногда нужно отрисовать только некоторые фигуры, чего нельзя было бы достичь с параметром `u32`.
Хорошо, теперь мы знаем, как отрисовать несколько инстансов объекта. Как указать, как именно они должны быть отрисованы? Мы используем *instance буфер.*
#### Instance буфер
*Instance* буфер создается тем же способом, как и uniform буфер.
Первым делом, сделаем структуру `Instance`:
```
// instance.rs
struct Instance {
position: cgmath::Vector3,
rotation: cgmath::Quaternion,
}
impl Instance {
pub fn new(position: cgmath::Vector3, rotation: cgmath::Quaternion) -> Self {
Self {
position, rotation
}
}
}
```
Здесь я использую новый математический структуру — *Quaternion.* Их часто используют для управления вращением. [Здесь](https://mathworld.wolfram.com/Quaternion.html) вы можете подробнее изучить эту тему.
WGSL шейдеры не имеют структур для работы с кватернионами, поэтому сделаем дополнительную структуру, где будет разметка схемы данных:
```
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct InstanceRaw {
model: [[f32; 4]; 4],
}
impl InstanceRaw {
pub(crate) fn description<'a>() -> wgpu::VertexBufferLayout<'a> {
use std::mem;
wgpu::VertexBufferLayout {
array_stride: mem::size_of::() as wgpu::BufferAddress,
// Переключаем режим работы с VertexStepMode::Vertex на VertexStepMode::Instance
// Это значит, что шейдер будет итерироваться по инстансам, а не векторам
step\_mode: wgpu::VertexStepMode::Instance,
attributes: &[
// mat4 имеет размер 4 векторов vec4, поэтому я делаю 4 слота для каждого вектора
wgpu::VertexAttribute {
offset: 0,
// Пока что в вершинном шейдере я использую 0 и 1 location.
// 2, 3 и 4 зарезервирую на будущее, поэтому здесь shader\_location = 5
shader\_location: 5,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size\_of::<[f32; 4]>() as wgpu::BufferAddress,
shader\_location: 6,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size\_of::<[f32; 8]>() as wgpu::BufferAddress,
shader\_location: 7,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size\_of::<[f32; 12]>() as wgpu::BufferAddress,
shader\_location: 8,
format: wgpu::VertexFormat::Float32x4,
},
],
}
}
}
```
Данные из этой структуры попадут в `wgpu::Buffer`. Дополнительное разделение `Instance` и `InstanceRaw` играет нам на руку, тк можно будет менять отдельно `Instance` без возни с матрицами. Нужно только не забыть обновить данные в `InstanceRaw` перед отрисовкой.
Давайте сделаем метод для конвертации `Instance` в `InstanceRaw`:
```
impl Instance {
// …
fn to_raw(&self) -> InstanceRaw {
InstanceRaw {
model: (cgmath::Matrix4::from_translation(self.position) * cgmath::Matrix4::from(self.rotation)).into(),
}
}
}
```
Добавим теперь инстансы в структуру `State`:
```
struct State {
// …
instances: Vec,
instance\_buffer: wgpu::Buffer,
}
```
Я буду использовать трейты вычисления из `cgmath` , их нужно импортировать:
```
use cgmath::prelude::*;
```
Чтобы создать множество объектов, используем двумерный массив 10 х 10, определив в начале константы:
```
const NUM_INSTANCES_PER_ROW: u32 = 10;
const INSTANCE_DISPLACEMENT: cgmath::Vector3 = cgmath::Vector3::new(NUM\_INSTANCES\_PER\_ROW as f32 \* 0.5, 0.0, NUM\_INSTANCES\_PER\_ROW as f32 \* 0.5);
```
В методе `State::new` создаем двумерный массив:
```
// Instancing
let instances = (0..NUM_INSTANCES_PER_ROW).flat_map(|z| {
(0..NUM_INSTANCES_PER_ROW).map(move |x| {
let position = cgmath::Vector3 { x: x as f32, y: 0.0, z: z as f32 } - INSTANCE_DISPLACEMENT;
let rotation = if position.is_zero() {
// Кватернионы могут изменять масштаб, поэтому здесь дополнительная проверка
// на случай, если объект находится в точке (0, 0, 0)
// Так мы избежим ситуации, когда масштаб объекта стал нулевой
cgmath::Quaternion::from_axis_angle(cgmath::Vector3::unit_z(), cgmath::Deg(0.0))
} else {
cgmath::Quaternion::from_axis_angle(position.normalize(), cgmath::Deg(45.0))
};
Instance::new(position, rotation)
})
}).collect::>();
```
Теперь, когда есть массив объектов, можем записать их в буфер:
```
let instance_data = instances.iter().map(Instance::to_raw).collect::>();
let instance\_buffer = device.create\_buffer\_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Instance Buffer"),
contents: bytemuck::cast\_slice(&instance\_data),
usage: wgpu::BufferUsages::VERTEX,
}
);
```
Буфер готов, обновим `render_pipeline`:
```
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
// ...
vertex: wgpu::VertexState {
// ...
// UPDATED!
buffers: &[Vertex::description(), InstanceRaw::description()],
},
// ...
});
```
Последний штрих в методе `State::new`, добавим новые поля в структуру:
```
Self {
// ...
// NEW!
instances,
instance_buffer,
}
```
#### Рендеринг
Мы сделали множество инстансов, которые можно отрисовать. В методе `State::render` я добавлю новый `instance_buffer` в `render_pass` и укажу количество инстансов для отрисовки:
```
// NEW!
render_pass.set_vertex_buffer(1, self.instance_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
// UPDATED!
render_pass.draw_indexed(0..self.num_indices, 0, 0..self.instances.len() as _);
```
Если вы будете добавлять новые инстансы, не забудьте создать ещё раз `instance_buffer` и `camera_bind_group`, иначе инстансы не будут отображаться корректно.
Обновим шейдер. Добавьте следующий код в начало файла:
```
struct InstanceInput {
@location(5) model_matrix_0: vec4,
@location(6) model\_matrix\_1: vec4,
@location(7) model\_matrix\_2: vec4,
@location(8) model\_matrix\_3: vec4,
};
```
Теперь обновим метод `vs_main`:
```
fn vs_main(
model: VertexInput,
instance: InstanceInput,
) -> VertexOutput {
var out: VertexOutput;
let model_matrix = mat4x4(
instance.model\_matrix\_0,
instance.model\_matrix\_1,
instance.model\_matrix\_2,
instance.model\_matrix\_3,
);
out.tex\_coords = vec2(model.tex\_coords.x, 1.0 - model.tex\_coords.y);
out.clip\_position = camera.view\_proj \* model\_matrix \* vec4(model.position, 1.0);
return out;
}
```
Я в начале умножаю `camera.view_proj`, потому что `camera.view_proj` меняет координаты в пространство камеры, а `model_matrix` находится в мировом пространстве. Если их поменять местами, то получим некорректный результат (я проверил!).
Итоговый результат:
#### Домашнее задание
Добавьте вращение инстансов.
Ссылка на [код](https://github.com/abritov/rust-wgpu-tutorial/tree/master/lesson6) урока
Ссылка на [оригинал](https://sotrh.github.io/learn-wgpu/beginner/tutorial7-instancing/#the-instance-buffer) статьи | https://habr.com/ru/post/698426/ | null | ru | null |
# Лучшее время для изучения микроконтроллеров
Признайтесь, как часто вы думали о том, чтоб освоить азы программирования микроконтроллеров? Наверняка у вас есть в голове несколько идей потенциальных проектов, но воплощать их в жизнь вы так и не взялись. Так вот: лучше времени для старта, чем сейчас просто не найти.
Почему я решил, что этот вопрос интересен аудитории Хабра? Достаточно проанализировать количество добавления в избранное некоторых постов и выводы напрашиваются сами собой.
С другой стороны, в моём текущем окружении очень много программистов, но почти нет имбедеров. Когда я разговариваю с ними на тему микроконтроллеров, у меня создаётся впечатление, что мнение о них у многих осталось на уровне 10-летней давности.
Не смотря на то, что писать на asm’е для микроконтроллеров проще, чем под x86 архитектуру, многие его боятся и это служит для них преградой на пути к встраиваемым системам. Друзья, для того, чтоб сейчас запустить микроконтроллер, не обязательно, даже, досконально читать даташиты, не говоря уже о том, чтоб знать его инструкции. Конечно, если это – ваша профессия, то тут уровень погружения гораздо выше, но, скажите мне, как часто вы, вне зависимости от того, профессионалом в каком деле вы являетесь, при создании продуктов стараетесь не нарушать принципа инкапсуляции до последнего и нет нет да и заглядываете в исходники используемых библиотек? Сейчас вы поймёте, что я имею в виду.
Я смутно помню те времена, когда я не программировал микроконтроллеры. Я начинал писать на asm’е, не только потому, что это делали все, но и потому, что нормальных инструментов практически не было. Популярность 8-битных контроллеров от AVR я объясняю тем, что для них создавались очень простые в использовании библиотеки, позволяющие создать новый проект, написать десяток строчек кода и получить вполне себе рабочую программу (адреса регистров периферийных устройств и векторы прерываний любезно заполнены создателями библиотек). Я не проводил исследования, это из моих личных воспоминаний — я уверен, что более толковые библиотеки для других контроллеров существовали ещё раньше, но тогда мы об этом не знали.
Первый действительно массовый 32-битный микроконтроллер создала французская контора STM. Именно в тот момент многие любители познакомились с архитектурой Cortex-M3 и начали её широко использовать. Помню, мне одновременно в руки попало 2 контроллера – [STM32F103](http://www.st.com/web/en/catalog/mmc/FM141/FM141/SC1169/SS1031/LN1565) и LPC1768. Мне надо было как можно быстрее сделать прототип устройства на одном из них. Естественно, мой выбор пал на первый: французы выпустили библиотеку для периферии под названием [Standard Peripherals Library](http://ru.wikipedia.org/wiki/STM32F10x_Standard_Peripherals_Library) и всё, что мне оставалось сделать – это запустить [FreeRTOS](http://ru.wikipedia.org/wiki/FreeRTOS), подключить необходимую периферию и на основе созданного скелета собирать проект уже на следующем уровне абстракции, не отвлекаясь больше на работу с регистрами. Скелет я использовал и в дальнейшем, часто перегибая и засовывая 32-х битный Cortex туда, где хватило бы и самой маленькой ATtiny, но чаще всего цена позволяла (а там, где не позволяла, либо нужно было пониженное энергопотребление, можно было использовать дешёвые MSP430 и STM8, но случалось это редко).
Конечно, я слукавлю, если скажу, что мне так и не пришлось выучить полностью архитектуру Cortex-M3 и скурить даташит F103 – конечно же, пришлось и тут моё увлечение библиотекой [CMSIS](http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php) и StdPeriph\_Lib мне скорее помешало, чем помогло, но скорость вхождения в новое для меня семейство поразила и уже тогда я понял, что мир контроллеров меняется и становится одновременно и проще и сложнее.
И вот мы плавно подобрались к тому, о чём я и хотел вам рассказать. Дело в том, что популярность всяких Arduino сборок долго не давала покоя ребятам из Texas Instruments. Они выпускали [лаунчпады на основе MSP430](http://www.ti.com/ww/en/launchpad/launchpads.html) и продавали их дешевле себестоимости и бесплатной доставкой, они запускали сообщество, в котором можно было выкладывать свои проекты, они создавали [Energia](http://www.energia.nu/) – форк Arduino, они выпускали лаунчпады Stellaris, а затем переименовывали их в Tiva C (хотя тут речь идёт о более глобальном ребрендинге и добавлении некоторых новых функций, суть не поменялась). О последнем я и хочу поговорить.
Купить лаунчпад [EK-TM4C123GXL](http://www.ti.com/tool/ek-tm4c123gxl) можно за 12.99$ вместе с доставкой FedEx (то есть получите вы его достаточно скоро). Плата не изобилует различной электроникой, как, например, Discovery F4 (на борту которой находятся акселерометр, звуковой сенсор, ЦАП, куча светодиодов) – всё, что вы найдёте на Tiva C Launchpad – это RGB диод и 2 кнопки, но его сила заключается не в дополнительных устройствах на плате.
Сила EK-TM4C123GXL в библиотеках, доступных для скачивания с сайта TI под названием TivaWare. Дело в том, что библиотеки для своих контроллеров сейчас пишут все, но многие из них, к сожалению, качеством не особо отличаются и являются скорее традиционными примерами, чем полноценными библиотеками, которые не стыдно использовать в своих проектах (для упомянутого чуть выше LPC1768, NXP написали свою библиотеку почти одновременно с STM, но качеством она тогда не особо отличалась). Библиотека для Tiva C удивляет своей стандартизированностью, документированностью и многообразием.
Чуть позже я предложу вам скачать [TivaWare](http://www.ti.com/tool/sw-tm4c) и, если вам не будет лень, то после установки вы сможете наблюдать следующие каталоги:
* Driverlib – тут находятся непосредственно драйверы для периферийных устройств, таких как adc, gpio и так далее (в том числе и заголовочный файл с макросами для вызова функций из rom – об этом далее)
* Examples – ну тут, понятно, примеры. Делятся на boards, peripherals и project. В первой, естественно, проекты для конкретных отладочных плат, во второй примеры использования периферийных устройств и в третьей пример чистого проекта для различных сред разработки (IAR, Keil, CCS) – файлы доступны под лицензией BSD.
* Inc – различные заголовочные файлы с макросами, в том числе и файл tm4c123gh6pm, который пригодится нам для создания простейшего проекта
* Docs – вот это отличительная черта TI — простая и понятная документация. Внутри находятся несколько User Guide, относящиеся к описанным тут компонентам – DriverLib, Examples, Bootloader, IQmath и так далее, а так-же юзергайд непосредственно к используемому нами лаунчпаду.
* Sensorlib – вот это то, что меня действительно удивило: тут находятся драйвера для различных сенсоров сторонних производителей, таких как sht21, lsm303d, MPU6050 и так далее. Я люблю использовать последний (это такая MEMS сборка из акселерометров и гироскопов на одном кристале) и раньше я всегда подключал выдранную из примеров Invensense либу, так что весьма аккуратно написанные исходники от TI меня прям порадовали (кроме того, тут же я нашёл сырцы для работы с квантерионами).
* IQmath – библиотека алгоритмов, оптимизированных для работы с числами с плавающей запятой на Stellaris (Tiva C) устройствах.
* Utils – часто используемые утилиты, для работы с командной строкой, последовательным портом, планировщик и многое другое.
* Оставшиеся каталоги содержат bootloader, сырцы сторонних производителей (FreeRTOS, например), библиотеку для работы с USB, драйвера для Windows и так далее.
Для того, чтоб запустить любой пример на вашем лаунчпаде, достаточно открыть проект из папки examples/boards/ ek-tm4c123gxl в вашей любимой IDE – там всё уже готово (я использую IAR, по этому я открыл ek-tm4c123gxl.eww и он мне загрузил уже настроенный workspace ). Но, знаете, такие настроенные примеры есть сейчас почти у каждого микроконтроллера, а настоящие трудности начинаются, когда мы пытаемся создать что-то своё.
Ок, давайте откажемся не только от примеров но и от настроенного скелета проекта – запустим всё с нуля (естественно с использованием файл из библиотек). Сразу дисклеймер: работать с лаунчпадом я начал только сегодня, так что я пока не знаю почти ничего ни о нём, ни об исходниках с которыми я буду работать. Это и есть основной лейтмотив всей статьи – человек видит Tiva C первый раз и сразу пытается работать с ней.
Я хотел написать сразу какое-нибудь сложное и интересное приложение, но потом понял, что это займёт некоторое время, а публиковать статью надо срочно и, поэтому я решил сделать простенький пример, а потом, если будут желающие, мы сделаем что-нибудь поинтереснее.
Итак, первое, что нам нужно — это скачать и установить библиотеку (если вы не сделали этого до сих пор). Кроме этого, вам необходимо установить IDE и флэшер.
**Где качать?**Скачать можно по [этой ссылке](http://software-dl.ti.com/tiva-c/SW-TM4C/latest/index_FDS.html).Если трафик позволяет — качайте DK-TM4C123G Kit Full Installer — он содержит библиотеку TivaWare, документацию и инсталяторы IDE (около 3.5Gb).
IDE и Flash Programmer находятся в папке Tools.
Если нет — можете скачать отдельно TivaWare for Tiva C Series, LM Flash Programmer и IDE.
В качестве IDE я буду использовать IAR (следовательно и примеры будут с ним), однако вы можете использовать любую из поддерживаемых.
Кто не знает, у IAR есть 2 варианта бесплатного использования — с ограничением по времени и с ограничением по размеру кода. И, естественно, есть другие варианты, если вам не подходят эти 2 (сами знаете какие). Описывать процедуру установки и регистрации IAR я не буду — там всё просто, но, если у вас возникнут трудности — не стесняйтесь задавать вопросы в комментариях.
Итак, первым делом создадим новый проект. В свойствах проекта изменим некоторые настройки.
**Настройки проекта**Настроек, на самом деле, не так много. Откроем опции проекта и выберем правильный камень. На вкладе General Options -> Target.
В C/C++ Compiler, на вкладке Preprocessor укажем путь к папке TivaWare. На этой же вкладке чуть позже мы добавим некоторые константы.
В Debugger выберем TI Stellaris.
Более детальные настройки (если нужно), можно посомотреть в примерах (например там используется другой файл конфигурации линковщика, не тот, что предложен IAR'ом).
Теперь нам необходимо настроить структуру проекта. Я предлагаю придерживаться структуры, предложенной TI (как в примерах), но с некоторыми отличиями.
В папке (на самом деле «в группе», но папки — както привычнее) Src у нас располагаются наши исходники. В примерах туда добавляют и исходники библиотечных файлов, но я считаю, что это только запутает проект.
В папке Library хранятся файлы из DriverLib. TI добавляют туда уже скомпилированный файл (в случае с IAR это файл driverlib/ewarm/Exe/driverlib.a), вы можете сделать так же, но я бы предложил добавлять вместо этого исходники, причём только в случае необходимости — так проще запомнить где что находится, да и смотреть исходный код полезно. Если вы планируете добавлять в эту же папку файлы из других библиотек (Utils, например), то лучше создать ещё один уровень иерархии.
В примерах упущено, и я тоже этого не делал, но, если вы будете писать свои заголовочные файлы, то создайте папку Inc.
Главное не забывать, что вот эти папки — это только для удобства пользователя, они ничего общего с размещением файлов на диске не имеют и никак не влияют на компиляцию.
Итак, в папке Src создадим файл main.c
В папку Library добавим startup\_ewarm.c — он нужен для правильной инициализации вектора прерываний. Взять можете его из project\_0 (это в examples) проекта, например.
Начнём нашу программу с функции main. Так как к порту F нашего лаунчпада подключен RGB светодиод, то им мы и поморгаем.
```
void main(void)
{
volatile uint32_t ui32Counter;
//Инициализация периферии
while(1)
{
//Тут код для переключения пинов
for(ui32Counter = 0; ui32Counter < 1000000; ui32Counter++)
{
}
//Тут код для переключения пинов
for(ui32Counter = 0; ui32Counter < 1000000; ui32Counter++)
{
}
}
}
```
Думаю всё понятно: использовать типы вроде uint32\_t — хорошая привычка, это помогает решить неоднозначность с размерами переменных на различных контроллерах (кроме того, это соответствует стандартам MISRA-C); volatile — сообщает компилятору, что эту переменную не стоит оптимизировать (потому-что мы её будем использовать для, в общем-то, бесполезной операции). Дальше — беконечный цикл (как учат студентов — программа на микроконтроллерах не должна никогда кончаться) и 2 счётчика для задержек.
Чтоб этот код компилировался, добавим в начало файла.
```
#include
```
Теперь мы приступим непосредственно к миганию светодиодами.
Скачиваем со [стрницы лаунчпада](http://www.ti.com/tool/ek-tm4c123gxl) файл Tiva C Series TM4C123G LaunchPad Evaluation Kit User's Manual и читаем в разделе User Switches and RGB User LED о том, что диод подключен к пинам PF1 (red), PF2 (blue) и PF3 (green).
Теперь открываем SW-TM4C-DRL-UG (в папке docs TivaWare) и просматриваем раздел GPIO. Из введения мы понимаем, что сперва пины должны быть сконфигурированны (конфигураций, естественно, множество) на выход. Тут же читаем, что одни из самых полезный функций — GPIOPinRead() и GPIOPinWrite(). Что они делают — понятно, осталось глянуть в их описание для уточнения списка параметров. Тут же находим, что для регистрации пинов на вывод используется функция GPIOPinTypeGPIOOutput(). Итак, меняем комментарии, в нашем коде на:
```
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2); //для инициализации
//и
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0xFF);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
//и
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0xFF);
```
Для включения и выключения диодов.
Естественно, не забываем добавить файл driverlib/gpio.c в папку Library, а так же
```
#include "driverlib/gpio.h"
```
в заголовки.
Кроме того, уже в процессе компиляци замечаем, что необходимо добавить ещё 2 заголовочных файла:
```
#include // Для поддержки типа bool, который используется в gpio
#include "inc/hw\_memmap.h" //Для поддержки деклараций пинов.
```
Теперь наша программа выглядит вот так:
```
#include
#include
#include "driverlib/gpio.h"
#include "inc/hw\_memmap.h"
void main(void)
{
volatile uint32\_t ui32Counter;
GPIOPinTypeGPIOOutput(GPIO\_PORTF\_BASE, GPIO\_PIN\_1);
while(1)
{
GPIOPinWrite(GPIO\_PORTF\_BASE, GPIO\_PIN\_1, 0xFF);
GPIOPinWrite(GPIO\_PORTF\_BASE, GPIO\_PIN\_2, 0);
for(ui32Counter = 0; ui32Counter < 2000000; ui32Counter++)
{
}
GPIOPinWrite(GPIO\_PORTF\_BASE, GPIO\_PIN\_1, 0);
GPIOPinWrite(GPIO\_PORTF\_BASE, GPIO\_PIN\_2, 0xFF);
for(ui32Counter = 0; ui32Counter < 2000000; ui32Counter++)
{
}
}
}
```
И, если вы её скомпилируете и запустите — сможете наблюдать поочерёдную смену цвета диода.
Но моргание светодиодом — слишком просто для нас. Давайте пойдём чуть дальше и добавим поддержку порта ввода-вывода.
Действия — все те же. Находим к каким портам подключен UART, читаем про конфигурацию модуля в UserGuide, конфигурируем, используем функции для записи в и чтения из uart.
Моя функция инициализации uart получилась похожа на функцию из примера, но с одним интересным отличием. Вот так выглядит инициализация из примера:
```
void ConfigureUART(void)
{
//
// Enable the GPIO Peripheral used by the UART.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Enable UART0
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Configure GPIO Pins for UART mode.
//
ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Use the internal 16MHz oscillator as the UART clock source.
//
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 115200, 16000000);
}
```
Как видите, тут используются странные функции с префиксом ROM\_ — это специальные функции, которые уже сохранены в ROM'е микроконтроллера лаунчпада. Прочитать о них можно в всё том же UserGuide для DRL. Созданны они для того, чтоб уменьшить размер кода в Flash памяти. Нужно оно вам или нет — решать вам, мне идея понравилась (раз уж я всё-равно использую Peripheral Driver Library). Кстати, если вы не знаете, будет код использвоаться на устройстве с кусками библиотеки в ROM или нет — вы можете использовать Mapped ROM Calls. Тогда будет использоваться код из ROM, если он есть и компилироваться, если его нет.
Для работы с ROM необходимо настроить несколько констант: в опциях проекта, в C/C++ Compiler, на вкладке Preprocessor добавить константу TARGET\_IS\_BLIZZARD\_RB1 в поле Defined Symbols. Туда же сразу добавьте PART\_TM4C123GH6PM и ewarm — они нужны для успешной компиляции фалов библиотеки.
**Скрин**
Кроме того, необходимо добавить в дерево проекта недостающие файлы:
Итак, всё, что нам осталось, это вывести что-то в порт (можете использовать для чтения любой эмулатор терминала. Например, для Windows я использовал Real Term). Затем, я предлагаю считать букву из порта, проверить, принадлежит ли она к одному из цветов (r, g, b) и поменять состояние соответствующего пина.
Функция для инициализации UART у вас уже есть. Изменяем инициализацию портов, чтоб добавить третий пин (раньше мы настроили только 2 на выход). Вывести строку в терминал можно с помощью функции UARTprintf(); из библиотеки utils/uartstdio.c (естественно, этот необходимо добавить к проекту и подключить заголовчный файл).
Считываем символ функцией UARTCharGet(). Она входит в цикл до тех пор, пока в уарт не придёт символ. После этого совершаем действия над пинами и возвращаемся в начало цикла.
```
#include
#include
#include "inc/hw\_memmap.h"
#include "inc/hw\_types.h"
#include "driverlib/gpio.h"
#include "driverlib/rom.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"
#include "driverlib/pin\_map.h"
#include "utils/uartstdio.h"
void ConfigureUART(void)
{
ROM\_SysCtlPeripheralEnable(SYSCTL\_PERIPH\_GPIOA);
ROM\_SysCtlPeripheralEnable(SYSCTL\_PERIPH\_UART0);
ROM\_GPIOPinConfigure(GPIO\_PA0\_U0RX);
ROM\_GPIOPinConfigure(GPIO\_PA1\_U0TX);
ROM\_GPIOPinTypeUART(GPIO\_PORTA\_BASE, GPIO\_PIN\_0 | GPIO\_PIN\_1);
UARTClockSourceSet(UART0\_BASE, UART\_CLOCK\_PIOSC);
UARTStdioConfig(0, 115200, 16000000);
}
void main(void)
{
volatile uint32\_t ui32Loop;
uint32\_t ui32Color;
uint8\_t ui8Red = 0xFF;
uint8\_t ui8Green = 0xFF;
uint8\_t ui8Blue = 0xFF;
GPIOPinTypeGPIOOutput(GPIO\_PORTF\_BASE, GPIO\_PIN\_1|GPIO\_PIN\_2|GPIO\_PIN\_3);
ConfigureUART();
UARTprintf("Hello HabraHabr!\n");
while (1)
{
UARTprintf("Please, enter color(r,g,b) \n");
ui32Color = UARTCharGet(UART0\_BASE);
switch (ui32Color)
{
case 'r':
GPIOPinWrite(GPIO\_PORTF\_BASE, GPIO\_PIN\_1, ui8Red);
ui8Red = ~ui8Red;
break;
case 'b':
GPIOPinWrite(GPIO\_PORTF\_BASE, GPIO\_PIN\_2, ui8Blue);
ui8Blue = ~ui8Blue;
break;
case 'g':
GPIOPinWrite(GPIO\_PORTF\_BASE, GPIO\_PIN\_3, ui8Green);
ui8Green = ~ui8Green;
break;
default:
UARTprintf("Incorrect color! \n");
break;
}
}
}
```
В TivaWare я нашёл интересную либу – utils/cmdline. Она позволяет создавать и обрабатывать команды введённые из командной строки. Я хотел сделать интересный проект с использованием её и ещё нескольких интересных библиотек, но время поджимает, так что я могу написать об этом позже, если будет интерес (а так же о прерываниях, которые тут даже не упомянуты и о FreeRTOS).
Ну, а теперь о том, почему я несколько раз написал о том, что время поджимает и почему из всех благоприятных времён для начала изучений контроллеров сейчас самое благоприятное: 22 января на edX стартуют курсы [Embedded Systems — Shape The World](https://www.edx.org/course/utaustinx/utaustinx-ut-6-01x-embedded-systems-1172).
Регистрация бесплатная, но, если вы хотите получить сретификат, то необходимо заплатить взнос (минимум 50$). Лично я заплатил 50$ — не из-за сертификата, а просто из любви к подобным курсам и в их поддержку.
Для участия вам надо купить Tiva C лаунчпад и различную рассыпуху. Последнюю вы можете купить на любом радиорынке, а вот с лаунчпадом придётся поторопиться: TI обычно отправляют через FedEx, но это может занять до 10 дней, в то время, как до начала курса осталась неделя.
Но переживать не стоит: не думаю, что на первом уроке вам сразу понадобится работать с железом, возможно вы сможете просимулировать вашу программу.
Итак, немного выводов. Использование подобных библиотек – палка о двух концах. С одной стороны она упрощает разработку, понижает порог входа, с другой стороны создаёт уровень абстракции, который усложняет понимание основ (во всей статье нет ни одной отсылки к даташиту, и это – неправильно: даташит надо смотреть всегда и это является обязательным условием певращения из любителя в профессионала). Но у подобных библиотек в отличии от ардуино (кстати, Energia поддерживает описанный лаунчпад), есть одно преимущество: они не создают у вас ложного понимания реальности. Если вы используете библиотеку, вы понимаете, что за абстракцией кроется вполне реальное устройство и параллели между функциями и реальными регистрами проследить совсем не сложно.
Я надеюсь, что данный материал подтолкнёт вас к покупке и изучению (пусть и столь поверхностному) этого замечательного устройства. Если у вас есть идеи проектов, которые вы могли бы реализовать на TM4C123G, но возникли сложности в реализации – не стесняйтесь писать об этом в комментариях: будем разбираться вместе. | https://habr.com/ru/post/209218/ | null | ru | null |
# Настройка FreePBX + GoIP
В Интернете довольно много примеров настройки. Но ни один из них у меня не заработал как надо. Одной из проблем с которой я столкнулся было неправильное определение линии при входящем звонке. В свое время нигде не нашел мануал для решения этой проблемы. Поэтому решил выложить свою версию инструкции здесь. Заодно и шпаргалка для себя на будущее.
Настройка GoIP
==============
### «Configurations» — «Preferences»
GSM шлюз находится в локальной сети без доступа в Интернет. Настроим NTP сервер в локальной сети для раздачи времени. При перезагрузке GSM шлюз синхронизируется и правильно показывает текущее время. Можете пропустить этот шаг, тогда придется вручную выставлять время на шлюзе. Если есть выход в Интернет, то укажите один из публичных NTP серверов.
* В Time Server пропишем IP адрес NTP сервера.
* Укажем часовой пояс, у меня Time Zone: GMT+6.
* Отключим Auto Reboot. С последней версией прошивки проблемы с зависанием GSM шлюза не наблюдаются.
* Отключим IVR.
### «Configurations» — «Network»
* LAN Port — Static IP
* IP address — укажем статический IP адрес шлюза
### «Configurations» — «Basic VoIP»
Config Mode — Config by Line.
Для первого канала где «Line 1 Routing Prefix» укажем 1, для второго 2, третьего 3 и т.д.
Authentication ID: прописываем номер сим карты (у меня прописаны без 8/+7), например 9651234567
SIP Registrar Server: IP адрес SIP сервера (192.168.0.10)
```
Line 1
Authentication ID: 9651234567
Password: пароль
Routing Prefix: 1
Sip Proxy:
SIP Registrar Server: 192.168.0.10:5160
Phone Nymber: 9651234567
Display Name: 9651234567
```
То же самое проделываем с остальными линиями.
### «Configurations» — «Advance VoIP»
### «Configurations» — «Call Out»
Для каждой линии указываем префикс, который приходит с Asterisk и будет удалятся на канале шлюза перед совершением исходящего звонка: например для для CH1 Dial Plan: 1:-1, CH2 Dial Plan: 2:-2 и т.д.
```
Dial Plan: 1:-1
```
### «Configurations» — «Call In»
В инструкциях по настройке рекомендуют для CID Forward Mode: выбрать Use CID as SIP Caller ID для правильного определения входящего номера. У меня выбрано Use Remote Party Id. Это было сделано для правильного определения линии, с которой пришел вызов. Входящий номер определяется правильно.
На этом закончили настройку GoIP.
Настройка FreePBX 14
====================
### «Подключения» — «Транки»
Выбираем «Добавить SIP (chan\_sip) транк».
#### Вкладка «Общие»
#### Переходим на вкладку «Правила манипуляции набора номера»
Прописываем шаблоны. Указываем префиксы для каждого транка по порядку. Для первой линии 1, для второй 2 и т.д.
#### Вкладка «sip Общие настройки»
###### Исходящий
У Астериска для нескольких учетных записей использует один и тот же порт. Это создает проблему при определении линии с которой пришел вызов. При входящем звонке всегда используется последний зарегистрированный пир и как следствие неправильно определяется линия на GoIP с которой пришел вызов. Для правильного определения линии, на GoIP был выбран режим **Use Remote Party Id**, а на Астриске **trustrpid=yes**.
```
host=dynamic
username=7712020077
secret=Djfgkjgfd!!!!234%$^%#
type=friend
context=from-trunk-sip-9651234567-custom
trustrpid=yes
```
###### Входящий
```
in-9651234567
secret=Djfgkjgfd!!!!234%$^%#
type=user
context=from-trunk-sip-9651234567-custom
```
Далее создадим внутренние номера и группу вызова. Как это делается описывать не буду. В FreePBX это делается через меню «Приложения» — «Внутренние номера» и «Приложения» — «Группы вызова». Все довольно просто и интуитивно понятно.
### «Подключения» — «Исходящая маршрутизация»
Выбираем «Добавить исходящий маршрут».
#### Вкладка «Настройки маршрута»
Укажем название маршрута, например all\_line. Далее укажем по порядку транки через которые будут совершаться исходящие вызовы.
#### Переходим на вкладку «Правила набора»
Здесь прописываем шаблоны для исходящих номеров.
Остальные вкладки оставляем по умолчанию. На этом настройка исходящего маршрута завершена. Можно попробовать совершить вызов.
Здесь может возникнуть проблема, что звонки будут уходить через транки в том порядке, в каком они указаны в маршруте. Что в свою очередь приведет к тому, что единицы на первых линиях будут уходить больше чем на тех, которые идут за ними. Для решения этой задачи можно переписать правила для исходящего маршрута с помощью extensions\_override\_freepbx.conf.
В зависимости от количества линии, можно использовать рандом. Для двух линии например 1,2. Я использую такой код
```
[outrt-sets](!)
exten => _.,50,Set(a_rand_num=${RAND(1,2)});
same => n,GotoIf($["${a_rand_num}"<"2"]?${n}+1:${n}+2)
same => n,GotoIf($["${GROUP_COUNT(OUT_1)}">="${OUTMAXCHANS_1}"]?${n}+1:out-1-cust)
...
[outrt](outrt-sets) ; all_line
exten => _+7XXXXXXXXXX,3,Goto(50)
exten => _8XXXXXXXXXX,3,Goto(50)
```
### «Подключения» — «Входящая маршрутизация»
Добавить входящий маршрут.
#### Вкладка «Общие»
Указываем его описание, например — «inbound».
Далее выбираем последний пункт «Установить направление», в котором выбираем конечную точку маршрута. В моем случае я указал группу вызова чтобы звонки поступали любому свободному оператору.
На самом деле у меня более сложная логика. С помощью AGI скрипта входящий номер ищу в базе данных, если нашел, то отправлю его оператору за которым он закреплен. До поступления звонка на sip клиент через jabber отправляю сообщение оператору с информацией о клиенте. Если номер не найден в базе, то звонок поступает в группу.
На этом настройка завершена. Можно пробовать звонить и принимать звонки.
#### Заключение
Многие не любят настраивать FreePBX, а ставят голый Астериск. У меня был нулевой опыт работы с IP-телефонией, поэтому в свое время выбор пал на FreePBX. Проблем с правкой конфигов у меня не возникло. Любые изменения можно внести с помощью конфиг файлов extensions\_custom.conf и extensions\_override\_freepbx.conf. Разобраться не так уж и сложно. У нас небольшой колл-центр. GoIP показал себя с лучшей стороны. Единственное не устроил их родной смс сервер. Поэтому был написан свой собственный, который поддерживает отправку и прием смс сообщении, а также показывает статус доставки смс. У нас получился полноценный заменитель телефона.
В качестве sip клиента используем веб телефон написанный на основе JsSip бибилиотеки, отлично работает в Firefox 68 и Chrome 76. Если будет время напишу более подробную инструкцию по применению JsSip библиотеки. А также отдельную статью по созданию своего смс сервера. | https://habr.com/ru/post/464765/ | null | ru | null |
# Arduino и резистивный тачскрин, библиотека KrokoTS
Сейчас почти все устройства управляются сенсорными экранами, и у многих возникает желание оборудовать свой arduino-проект дисплеем и GUI, чтобы даже убеждённые "мышатники" смогли разобраться.
Необходимые компоненты и цена вопроса
-------------------------------------
* Arduino любой модели - Uno: 400p
* Резистивный сенсорный дисплей/панель - мой с разборки: 80p
* Светодиод - 10p
* Компьютер с установленной Arduino IDE
Что такое резистивный сенсор и почему нельзя использовать дисплей от смартфона
------------------------------------------------------------------------------
Резистивный тачскрин состоит резисторов, количество которых определяется АЦП микроконтроллера. В случае Atmega328 это 10 бит - 1024 резистора. Они расположены сеткой:
Сетка из резисторов, пользователь нажал в первую красную точку.Одним из минусов этих тачскринов является отсутствие мультитача - ведь при замыкании сетки резисторов в нескольких местах результат будет один и не верный.
В телефонах используют другие сенсоры - емкостные. Контроллер дисплея измеряет заряд конденсатора и констатирует факт нажатия. Единственное, из МК AVR умеют работать с этими дисплеями Atmega серии PB. Atmega328PB стоит в одном нашем магазине 400р. Обычная Atmega328P - 360p. Возможно, когда-то расскажу и про этот тип сенсоров. Если вы всё-таки решите купить PB, учтите, что они физически несовместимы с обычной Atmega328P
Сборка
------
Резистивный сенсор - далее *дисплей -* имеет 4 контакта: X1, Y1, X2, Y2. Я вывел шлейфом эти контакты и припаялся к Arduino так:
Схема дисплеяДля индикации нам нужен светодиод, который мы подключаем к любому ШИМ пину, в моём случае 11.
Код программы
-------------
Первое и самое важное - библиотека. Для таких *дисплеев* их есть великое множество. Например, от Adafruit. Но я рекомендую использовать KrokoTS из-за одной фишки, о которой я расскажу позднее. Для загрузки можно использовать Менеджер Библиотек Arduino IDE, или скачать с [GitHub](https://github.com/AlexTutorial/KrokoTS).
Начнём с примеров. Идём "Файл-Примеры-KrokoTS-attach".
Разберём код по блокам, которые выделил автор.
```
#include
#define X1 A0
#define X2 A2
#define Y1 A1
#define Y2 A3
#define LED 11
KrokoTS Touch(X1, X2, Y1, Y2);
```
Здесь мы подключаем библиотеку, и задаём пины А0-А3 как контакты *дисплея* согласно схеме, создаем объект Touch, с которым будем работать далее.
```
void setup() {
pinMode(LED, OUTPUT);
Touch.attachClick(0, 1, 500, 1, 900, on);
Touch.attachClick(1, 501, 900, 1, 900, off);
}
```
Теперь инициализируем светодиод, и - главное отличие этой библиотеки от других - attachClick(). Вот её синтаксис:
```
Name.attachClick(id, xmin, xmax, ymin, ymax, function);
```
Таким образом, при обнаружении касания в пределах поля ***xmin-xmax-ymin-ymax*** будет вызвана функция function. В нашем примере клик в области 1-500-1-900 вызовет on. id должен быть **уникальный и в пределах от 0 до MAX\_FIELDS,** если надо больше, измените **MAX\_FIELDS**. Можно динамически менять область, пересоздавая блок с таким же id.
```
void loop() {
Touch.tick();
}
void on() {
digitalWrite(LED, HIGH);
}
void off() {
digitalWrite(LED, LOW);
}
```
В loop'е вызываем метод tick, который проверяет касания. Соответственно, лучше не плодить задержки delay. В блоках on/off мы включаем и выключаем светодиод. Вы ведь поставили его? На этом разбор первого примера окончен. Открываем пример getPos. Нас интересует setup.
```
void setup() {
pinMode(LED, OUTPUT);
}
```
Тут мы просто инициализируем светодиод. Далее loop.
```
void loop() {
int x = Touch.getX();
int y = Touch.getY();
if (x < 1000 && y < 1000) {
if (y < 500) digitalWrite(LED, (x > 500) ? HIGH : LOW);
else analogWrite(LED, map(x, 50, 950, 0, 255));
}
}
```
Используя методы getX/getY мы получаем координаты касания, и условием обрезаем лишнее, ведь ввод у нас - INPUT\_PULLUP. Если клик был в верхней части экрана, то мы через тернарный оператор выбираем уровень сигнала - высокий/низкий, а иначе - масштабируем x к значению 0-255, и пишем как ШИМ сигнал
Заключение
----------
Надеюсь мой пост был вам полезен, и вы узнали что-то новое, а если у вас возникли вопросы, пишите в комментарии, я постараюсь ответить. Можете написать, что улучшить или подкинуть идею для следующего поста, а на этом я с вами прощаюсь, всем удачи и пока! | https://habr.com/ru/post/589143/ | null | ru | null |
# Делаем код в адаптере чище с помощью MergeAdapter
Надоели перегруженные и сложные адаптеры в вашем проекте, напоминающие картинку ниже? Каждый раз, при добавлении нового типа ячейки хочется переписать адаптер для RecyclerView, чтобы код читался проще? Есть множество подходов, чаще всего рекомендуется использовать подход delegate adapter или, например библиотеку для динамического создания списков с различными типами view как groupie о работе с которой вы можете [ознакомиться в этой статье](https://habr.com/ru/post/523768/). Но сегодня расскажем о новом классе, который поможет инкапсулировать логику вашего адаптера для разных ячеек тем самым соответствовать принципам SOLID.
[MergeAdapter](https://developer.android.com/reference/androidx/recyclerview/widget/MergeAdapter) — новый класс, появившейся в [recyclerview:1.2.0-alpha02](https://developer.android.com/jetpack/androidx/releases/recyclerview), который позволит объединить несколько адаптеров для отображения в едином RecyclerView. Это позволит инкапсулировать логику для каждой ячейки в своём адаптере, и позволит переиспользовать её в будущем.
### Проблема
Начнем с примера. Предположим, у нас есть задача отобразить ленту с двумя типами данных — текст с описанием и картинка. Код в методе `onCreateViewHolder` в самом распространённом случае будет выглядеть так:
```
override fun onCreateViewHolder(
parent: ViewGroup, viewType: Int
): RecyclerView.ViewHolder? {
val holder: RecyclerView.ViewHolder
val inflater = LayoutInflater.from(parent.context)
when (viewType) {
TEXT_VIEW_TYPE -> {
holder = TextViewHolder(
inflater.inflate(R.layout.text_item, parent, false)
)
}
IMAGE_VIEW_TYPE -> {
holder = ImageViewHolder(
inflater.inflate(R.layout.image_item, parent, false),
imageClickListener
)
}
else -> {
throw IllegalArgumentException(
"Can't create view holder from view type $viewType"
)
}
}
return holder
}
```
Чем это плохо? Минус такой реализации в нарушении принципов DRY и SOLID (single responsibility и open closed). Чтобы в этом убедиться, достаточно добавить два требования: ввести новый тип данных (чекбокс) и еще одну ленту, где будут только чекбоксы и картинки.
Перед нами встает выбор — использовать этот же адаптер для второй ленты или создать новый? Независимо от решения, которое мы выберем, нам придется менять код (об одном и том же, но в разных местах). Надо будет добавить новый VIEW\_TYPE, новый ViewHolder и отредактировать методы: `getItemViewType(), onCreateViewHolder() и onBindViewHolder()`.
Если мы решим оставить один адаптер, то на этом изменения закончатся. Но если в будущем новые типы данных с новой логикой будут добавляться только во вторую ленту, первая будет иметь лишний функционал, и ее тоже нужно будет тестировать, хотя она не изменялась.
Если решим создать новый адаптер, то будет просто масса дублирующего кода.
### Решение
Новый класс MergeAdapter, позволяет комбинировать разные адаптеры для разного вида ячеек. Например, очень частый кейс использования — отображать spinner на время загрузки данных в ленте, а если, вдруг произошла ошибка загрузки — отображать ячейку с ошибкой в конце ленты.
Решением данной задачи, может быть использование MergeAdapter Предположим, у нас есть 3 адаптера:
```
val firstAdapter: FirstAdapter = …
val secondAdapter: SecondAdapter = …
val thirdAdapter: ThirdAdapter = …val mergeAdapter = MergeAdapter(firstAdapter, secondAdapter, thirdAdapter)
recyclerView.adapter = mergeAdapter
```
RecyclerView отобразит элементы каждого адаптера последовательно, в том же порядке, в котором переданы в конструктор. Разные адаптеры позволяют разделить логику для разных ячеек в списке. Например, если необходимо добавить заголовок к списку, не нужно реализовывать эту логику в адаптере, который отвечает за отображение главного контента в списке, можно разделить адаптеры, для разных видов ячеек. Такой подход помогает инкапсулировать логику и переиспользовать её в будущем для разных экранов.
### Отображение загрузки в заголовке или внизу списка.
Для отображения статуса загрузки вверху или внизу списка нужно добавить адаптеры соответственно:
```
val mergeAdapter = MergeAdapter(headerAdapter, listAdapter, footerAdapter)
recyclerView.adapter = mergeAdapter
```
Верхняя ячейка и нижняя используют тот же layout, ViewHolder и UI логику (отображение статуса загрузки и скрытие). Вообще, достаточно было бы использовать 2 экземпляра одного и того же адаптера для верха и низа списка. Пример можно посмотреть [тут](https://github.com/googlecodelabs/android-paging/pull/46/files) или [тут](https://github.com/Kotlin-Android-Open-Source/MergeAdapter-sample).
Если кратко, то вот таким простым способом вы можете улучшить код вашего проекта, если вы используете сложный адаптер с различными типами ячеек.
Понравилась статья? Не забудьте присоединиться к нам [в Telegram](https://t.me/android_school_ru), а на платформе [AndroidSchool.ru](https://androidschool.ru/) публикуются полезные материалы для Android-разработчика и современные туториалы. | https://habr.com/ru/post/523840/ | null | ru | null |
# Электронная библиотека для PocketBook: автоматическая обработка
Наверное каждому электрочитателю хотелось бы всю свою коллекцию книг содержать прямо на электронной книге-читалке, и при этом, не смотря на общую тормознутость устройства, иметь удобную навигацию.
Зачастую в электронной книге проблематично содержать сотни и тысячи книжек: либо аппарат долго тупит, считывая информацию о каждой книге из ее внутренностей, либо вручную поддерживать коллекцию с разбивкой по каталогам — тот еще геморрой.
#### Преамбула
Помню, в ранних редакциях электрокниг от Sony была такая проблема: закачиваешь туда несколько сотен книжек, и аппарат при включении долго висит, составляя список закачанного. Тогда не было еще поддержки коллекций и Сонька долго бегала по всей карточке, собирая информацию о закачанных книжках. Многие жаловались.
Более удобна была работа с книжками от PocketBook — в них поддерживалась навигация по файловой системе, поэтому можно было вручную раскидать книги по папкам, и считывал аппарат только книги в той папке, в которую мы зашли.
Вручную с компа уже можно было что-то формировать и как-то жить.
Тогда же меня познакомили с ЛибРусЕк'ом(теперь уже более актуальна Флибуста, кто не знает, что это, вам [сюда](http://bit.ly/KBR6xy)). И в какой-то момент мне пришла идея, а не попробовать ли загнать всю библиотеку в электрокнижку, слегка автоматизировав этот процесс?
> *А теперь важное! Чтобы не тратить зря внимание людей, которым данная статья вероятно помочь ничем не сможет(к сожалению такие будут), дам фильтрующую установку:
>
> Если вы являетесь владельцем электронной читалки **PocketBook**, и вас заинтересовала идея загнать в аппарат как можно больше книг с удобной навигацией — вам сюда однозначно. Если вы владелец другой электронной книги, которая тем не менее поддерживает формат **FB2** и навигацию по директориям, вам вероятно тоже сюда, смотрите ближе к концу статьи описание настройки **$no\_leased\_storage**. Остальным, к сожалению, данная статья мало чем сможет помочь. Извините.*
Немного поковырявшись в функционале PocketBook'а, выяснил одну интересную особенность: он поддерживает файлы-ссылки. Что-то вроде ярлыков в Windows или симлинков в юниксах. Я позже объясню, зачем они нам нужны и в чем прелесть этой фичи, а сейчас скажу лишь, что используются они в покетбуке штатно для функционирования раздела «Избранное». Когда вы посмещаете туда книгу, в специальную папку на устройстве помещается лишь ссылка на реальный файл книжки. Сама книжка в избранное не копируется.
Так же, пообщавшись с разработчиками, было установлено, что на тот момент уже поддерживались SDHC емкостью вплоть до 32Gb. В общем-то для современных моделей, которые со слотом microSD, в ТТХ указаны те же 32Gb, что несколько разочаровывает. Но не сильно. Да и проверить надо, спецификации спецификациями, а реально поддерживать может и больше. Только карточку на 64Gb ради негарантированной проверки влом покупать.
Ну и еще есть замечательная фича — поддержка .fb2.zip, это когда каждая книжка формата fb2 упакована в свой zip-архив. PocketBook такие книги видит прозрачно, то есть так же, как и неупакованные.
Сразу стоит пояснить один момент, упреждая необдуманные вопросы: никто не собирается читать сотни тысяч книг(а речь идет о таких количествах). Держать такую коллекцию на устройстве в надежде все это когда-либо прочесть — просто безумие.
Удобство такого каталогизированного объема вовсе в другом. Например, кто-то вам советует почитать конкретную книгу, вы глядь, а у вас это уже есть. Или конкретного автора например. Вы сразу находите это в своей книге, и делаете закладку в избранное. Да-да, директорию автора тоже можно положить в избранное, ссылки на директории в Покетбуках тоже работают.
Типа «Почитай Гаррисона», «ОК, почитаю», и сразу его шмяк в избранное. Иначе ведь забудется, не в блокноты же записывать.
#### Теоретическая часть
Так вот, перейдем к делу. Был написан скрипт на PHP, который берет из исходной папки файлы fb2, включая заархивированные пачками в zip-архивы, и создает основанную на файловой системе коллекцию книг, предназначенную для заливки в PocketBook.
Создает он ее хитро. Тут нужно отдельно сказать о нюансах формата fb2.
Во-первых, книга свое название(а так же информацию об авторах, жанрах и сериях) хранит внутри себя. Имя файла здесь не важно в принципе.
Во-вторых, книга может быть написана несколькими авторами, относиться к нескольким жанрам и входить в несколько серий. А поиск и каталогизацию хотелось бы иметь и по авторам, и по жанрам и по сериям. При чем, если написана двумя авторами, хотелось бы, чтобы книжка присутствовала в каталогах обоих.
Копировать в каждую соответствующую директорию книгу? Некомильфо.
И вот тут нам на помощь приходят файлы-ссылки.
Скрипт помещает тела книг(в zip'ах) в отдельную директорию, создавая внутри вложенные поддиректории и раскидывая их таким образом, чтобы в конечной директории было не более сотни книг, да и в промежуточных директориях — не более сотни поддиректорий. Это чтобы книжка не тупила при доступе к конкретному zip'у, перебирая много файлов в одной директории.
Рядом, например в корне флешки, создается директория каталогизатора, в которой внутри сделана вся необходимая навигация по авторам, сериям и жанрам, и которая в конечных нодах вместо книг содержит вышеописанные файлы-ссылки, ссылающиеся на соответствующие zip'ы. Умный покетбук на месте этих ссылок покажет сами книжки, и будет открывать их так же, как если бы они и лежали в каталогизаторе.
Для примера я покажу вам, как в итоге будут храниться произвольные 10 книг, во что они превратятся в файловой системе SD-карты:
```
/_zipstorage_/00000000/00000000/00000001.zip
/_zipstorage_/00000000/00000000/00000002.zip
/_zipstorage_/00000000/00000000/00000003.zip
/_zipstorage_/00000000/00000000/00000004.zip
/_zipstorage_/00000000/00000000/00000005.zip
/_zipstorage_/00000000/00000000/00000006.zip
/_zipstorage_/00000000/00000000/00000007.zip
/_zipstorage_/00000000/00000000/00000008.zip
/_zipstorage_/00000000/00000000/00000009.zip
/_zipstorage_/00000000/00000000/0000000a.zip
/Библиотека/Авторы/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000001.flk
/Библиотека/Авторы/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000002.flk
/Библиотека/Авторы/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000003.flk
/Библиотека/Авторы/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000004.flk
/Библиотека/Авторы/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000005.flk
/Библиотека/Авторы/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000006.flk
/Библиотека/Авторы/Буквы А-Я/Д/Дун/Дункан Дэйв/00000008.flk
/Библиотека/Авторы/Буквы А-Я/М/Мил/Милкова Елена/0000000a.flk
/Библиотека/Авторы/Буквы А-Я/П/Пал/Пальм Карл Магнус/00000007.flk
/Библиотека/Авторы/Буквы А-Я/С/Сем/Семенова Мария Васильевна/00000009.flk
/Библиотека/Жанры_Авторы/Деловая литература/Искусство и Дизайн/Буквы А-Я/П/Пал/Пальм Карл Магнус/00000007.flk
/Библиотека/Жанры_Авторы/Детективы и Триллеры/Детектив/Буквы А-Я/М/Мил/Милкова Елена/0000000a.flk
/Библиотека/Жанры_Авторы/Поэзия, Драматургия/Поэзия/Буквы А-Я/С/Сем/Семенова Мария Васильевна/00000009.flk
/Библиотека/Жанры_Авторы/Проза/Современная проза/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000001.flk
/Библиотека/Жанры_Авторы/Проза/Современная проза/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000002.flk
/Библиотека/Жанры_Авторы/Проза/Современная проза/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000003.flk
/Библиотека/Жанры_Авторы/Проза/Современная проза/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000004.flk
/Библиотека/Жанры_Авторы/Проза/Современная проза/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000005.flk
/Библиотека/Жанры_Авторы/Проза/Современная проза/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000006.flk
/Библиотека/Жанры_Авторы/Фантастика/Фэнтези/Буквы А-Я/Д/Дун/Дункан Дэйв/00000008.flk
/Библиотека/Жанры_Авторы/Юмор/Юмористическая проза/Буквы А-Я/Д/Дро/Дрозд Володимир Григорович/00000001.flk
/Библиотека/Жанры_Серии/Деловая литература/Искусство и Дизайн/Буквы А-Я/А/Амфора/00000007.flk
/Библиотека/Жанры_Серии/Деловая литература/Искусство и Дизайн/Весь список/Амфора/00000007.flk
/Библиотека/Жанры_Серии/Детективы и Триллеры/Детектив/Буквы А-Я/Э/Эгида/0000000a.flk
/Библиотека/Жанры_Серии/Детективы и Триллеры/Детектив/Весь список/Эгида/0000000a.flk
/Библиотека/Серии/Буквы А-Я/А/Амфора/00000007.flk
/Библиотека/Серии/Буквы А-Я/Д/Дискография/00000007.flk
/Библиотека/Серии/Буквы А-Я/Э/Эгида/0000000a.flk
/Библиотека/Серии/Весь список/Амфора/00000007.flk
/Библиотека/Серии/Весь список/Дискография/00000007.flk
/Библиотека/Серии/Весь список/Эгида/0000000a.flk
```
Внутри каждого zip-файла в директории "\_zipstorage\_" лежит книга в формате .fb2 с тем же именем, что и у zip-файла.
Внутри каждого flk-файла находится путь к соответствующему zip-файлу с книгой.
На месте файлов .flk в устройстве отображаются соответствующие книжки, и ведут себя они точно так же, как если бы они и лежали вместо .flk файлов. То есть никаких «00000007.flk», «00000007.zip» и «00000007.fb2» пользователь электрокнижки не увидит.
Как видите, без ссылок .flk, если бы нам пришлось копировать каждый файл туда, где он должен присутствовать, наших 10 файлов превратились бы уже 31 файлик с теми же размерами на флешке.
Но, благодаря использованию этой феньки со ссылками, этого не произошло.
Вам в директорию "\_zipstorage\_" ходить не надо совсем — это хранилище.
Ходить нужно в каталогизатор под названием «Библиотека».
Там вам выпишут карточку посетителя, по вашему запросу библиотекарь сам пойдет в хранилище и принесет вам оттуда…
Вам может быть не сразу понятно, почему внутри этой библиотеки добираться до книжки «Кубик из красной пластмассы» нужно по такому длинному пути: "/Авторы/Буквы А-Я/С/Сем/Семенова Мария Васильевна".
Но я напомню, что речь идет не о десятке файлов, а о сотнях тысяч. Гораздо быстрее будет войти последовательно в директории «Буквы А-Я», «С», «Сем» и найти там «Семенову Марию Васильевну», чем долго-долго ждать отображения, а потом долго-долго листать полный список авторов, пока доберемся до буквы «С».
Точно так же, если нужно найти все книги Гарри Гаррисона, можно вполне логично предположить, что путь будет "/Авторы/Буквы А-Я/Г/Гар/Гаррисон Гарри". Так как к примеру на букву «Г» авторов дофигища, пришлось ввести дополнительный уровень директорий с первыми тремя буквами фамилии. Это кстати рулится в скрипте «process.php» параметрами к вызовам функции get\_splitten\_dirs().
Кроме всего прочего, вам не нужно каждый раз ходить в «библиотеку», чтобы начать чтение очередной книжки Гаррисона — вам нужно туда добраться только один раз. А дальше, как я уже писал выше, кидаем всего Гаррисона в избранное и имеем всегда под рукой. Это действительно удобно.
И я этим всем пользуюсь почти «в одно лицо»(не считая нескольких друзей, которые брали у меня уже готовую «заливку», либо просто дублировали мою SD-карту) уже года три, или около того. Непорядок, наверное, пришло время делиться.
#### Практическая часть
Ладно, думаю, о теории достаточно. Кто в теме, поймут все сразу, в т.ч. где на флибусте брать нужное «сырье», а кто не в теме и кому не интересно, вряд ли дочитают до этого места.
Так что перейдем к описанию самого скрипта, ссылку на zip-архив с которым вы найдете в конце статьи.
Я не буду описывать проблемы и решения, которые пришлось пережить. Это тема для отдельной статьи, вероятно в разделе о PHP.
Опишу только общую схему работы скрипта и его настройки.
#### Начнем с того, что скрипт делает снаружи себя
Кроме вычитки исходной директории и формирования каталогизатора, скрипт так же пропускает каждый fb2-файл сквозь себя. То есть разбирает структуру и пересохраняет файл заново — парсит.
Это нужно для исправления ошибок формата. Некоторые файлы изначально приходят битыми — то недопустимый символ не переведен в HTML-код, то левые теги встречаются, которые содраны с интернет-страничек, но недопустимы в fb2-формате, то незакрытые теги, то еще что-то. Не то, чтобы этих ошибок так уж много, но они встречаются относительно регулярно, и электрокнижка такие файлы открыть не может.
Так же скрипт переводит жанры в более читаемые названия.
Итак. Когда вы скачаете zip-архив, в нем вы обнаружите несколько php-файлов и в поддиректориях несколько книжек для примера.
Есть директория «out\_dir\src», из которых будем читать книжки, в т.ч. в зипах.
И есть директория «out\_dir\dest», в которую будем складывать каталогизатор и хранилище. Собственно после работы скрипта все, что будет находиться в этой директории, нужно перенести в корень SD-карты.
Ну либо можно скрипт настроить сразу, чтобы писал прямо на флешку.
Тут надо оговориться о паре нюансов касательно записи на SD-карты. Приготовьтесь сразу к тому, что процесс этот не быстрый, учитывая количество информации и фрагментацию.
* Файлов будет очень много. Кроме количества исходных файлов, на флешку так же запишется минимум в три раза больше мелких flk-файлов. Каждый из них содержит ссылку на zip-архив и занимает всего несколько байт, но на носителе занимает целый кластер. Нужно это помнить. Поэтому есть смысл отформатировать флешку с как можно меньшим размером кластера. Иначе мегабайт этих файлов по сумме их размеров в реальности может запросто сожрать на флешке уже гигабайт места.
* Флешка(SD-карта, не важно) будет греться. Кроме того, что она затормозит через короткое время из-за заполненности буфферов, она еще и по мере разогрева будет снижать скорость записи. Я не знаю, почему так происходит, но есть такое дело. Ей нужно давать перерывы, чтоб остыла. Я обычно формирую скриптом библиотеку на жесткий диск, а потом с него уже копирую на флешку пачками. Еще возможно есть смысл использовать какой-либо контейнер типа TrueCrypt, на который можно сформировать библиотеку как на флешку, потом содрать образ диска и развернуть на SD-карту. Это будет самый быстрый способ записи на флешку.
* SD-карту, если у вас еще нет карты большого объема, лучше покупать классом повыше(например Class10), это выйдет немного дороже, но значительно ускорит процесс записи. Class10, кстати, уже вполне терпимо можно забить до упора за рабочий день. Это я еще раз напоминаю, что речь о сотнях тысяч мелких файлов. По скорости записи это кардинально отличается от «закатать фильмец на 4 Гига». Вот прям абсолютно не похоже.
Скрипт писался для машины на Windows, и соответственно PHP был установлен под Windows, версия 5.2.9-2. По идее ему пофиг на какой системе работать, но может у кого-то что-то не завестись.
Именно из-за Windows в арихиве пристутсвуют .bat-файлы для запуска скриптов.
Здесь представлена обрезанная версия скрипта. Полная состоит из двух частей и базы данных под Interbase, в которую сначала все книги импортируются, там фильтруются, убираются дубляжи, исправляются разночтения авторов, жанров, серий и названий(типа «Пушкин А.С.»=>«Пушкин Александр Сергеевич»), собираются хеши MD5 для дальнейших пополнений библиотеки и т.п.
Сюда не вижу смысла это все вываливать, ибо одно дело поднять PHP для выполнения скрипта, другое — настроить базу данных, установить все библиотеки и т.п. Врядли многие из вас будут с этим заморачиваться. Проще каждому для себя допилить свой функционал БД к скрипту, если понадобится. Поэтому скрипт обрезан для автономной работы без всяких БД. Чуть меньше функционала, но не критично.
Рядом со скриптом во время его работы будет создан лог-файл с ошибками(«prc\_errors.txt»). Это задано в bat-файле запуска — перенаправление STDERR в этот файл. Если ошибок не было, он будет нулевого размера.
#### Внутренняя кухня
Собственно основной скрипт находится в файле «process.php», его и надо запускать.
Настройки хранятся в нем же в начале. Вот они:
```
$out_file='./out.txt'; // в этот лог сохраняется информация об обработанных файлах. можно установить в false и лог писаться не будет.
$src_dir='./out_dir/src'; // исходная директория. это то, куда кидать все скачанное с интернетов.
$dest_dir='./out_dir/dest'; // целевая директория. это то, откуда забирать потом все на SD-карту.
$storagename='_zipstorage_'; // название для директории-хранилища. оно будет прописано в каждый flk-файл, эта директория должна в итоге находиться в корне SD-карты.
$libname='Библиотека'; // название для директории-каталогизатора
$compress_storage=true; // зиповать ли файлы в хранилище. если нет, будут валяться как fb2. не знаю, зачем это может понадобиться. я зипую по-умолчанию.
$control_genres_export=false; // ограничивать ли список жанров по флагам(см. genres.inc)
$no_leased_storage=false; // не использовать выделенное хранилище и файлы-ссылки.
$dbid=0; // переменная для инкремента ID книги, который используется как техническое имя файла в хранилище. ну можно не с нуля начать )))
$GLOBALS['process_config']=array(
'struct_only'=>false, // только для отладки
'unknown_tags_processing'=>XMLP_UT_CUT, // способ обработки неизвестных тегов(невалидных для fb2 например, см. 'tags_hash')
'strip_comments'=>false, // вырезать комментарии
'tags_hash'=>$GLOBALS['XMLP_FB2_elements'], // набор валидных тегов
'tags_processing'=>array( // параметры генерации регулярки для тега
'name_first_alpha'=>false,
'name_len'=>20,
'content_len'=>512,
'pattern_type'=>XMLP_TPS_STRICT,
'include_comments'=>true,
),
);
```
Опишу параметр **$GLOBALS['process\_config']['unknown\_tags\_processing']**. Он рулит парсером, а точнее тем, что парсер будет делать с обнаруженными тегами, которые не являются валидными для формата fb2(FictionBook 2.0):
* XMLP\_UT\_LEAVE — оставить все как было в исходнике.
* XMLP\_UT\_CONVERT — конвертировать в текст, отображаемвый в книге. То есть текст превратится в <tag> текст</tag> и будет в результате в книге отображаться как текст.
* XMLP\_UT\_CUT — будут вырезаны только сами теги. Их внутренний текст останется доступным читателю. $a=$b; превратится в $a=$b;
* XMLP\_UT\_CUT\_FULL — будут вырезаны неизвестные теги вместе с их содержимым. то есть полностью.
* XMLP\_UT\_CUT\_SMART — не реализовано. алиас для XMLP\_UT\_CUT
Очевидно для исправления ошибок наиболее подходят два варианта: XMLP\_UT\_CONVERT и XMLP\_UT\_CUT. Так как в большинстве случаев пользователя не интересуют эти теги вообще, являются мусором, то наиболее правильным на мой взгляд их просто вырезать с помощью опции XMLP\_UT\_CUT.
Сами теги формата FictionBook передаются парсеру в параметре **$GLOBALS['process\_config']['tags\_hash']**. Массив **$GLOBALS['XMLP\_FB2\_elements']** предопределен в начале файла «xmlp.inc».
Параметр **$GLOBALS['process\_config']['tags\_processing']** рулит генерацией регулярки восприятия тегов в тексте. Там лучше лишнего не трогать, по-умолчанию нормально. Можно разве что параметр **'name\_first\_alpha'** установить в **true** — в таком случае движок будет требовать альфа-символ в начале имени тега, и к примеру вот это **<:>** будет восприниматься не как неизвестный тег, а как мусор в тексте, со всеми вытекающими — при опции **XMLP\_UT\_CUT** такие теги не будут вырезаться, а будут превращены в html entities и будут отображаться конечному читателю книги.
Если же здесь же отключить опцию **'include\_comments'**, будет генериться более простая регулярка, в результате производительность скрипта возрастет раза в два как минимум, но при этом в файлах книг комментарии в тегах превратятся в обфусцированную кашу и станут видны конечному читателю книги. Если комментарий попадет в зону текста книги — оно еще ничего, но если в зону заголовка — книжка вероятно вообще не откроется на устройстве, т.к. это будет нарушение XML-структуры документа(произвольный текст между XML-тегами).
Настройка **$no\_leased\_storage**. Если установить в true, отдельное хранилище для книг использоваться не будет. То есть никакого '\_zipstorage\_' и flk-файлов. На место flk-файлов в библиотеке будут ложиться fb2 или zip(в зависимости от параметра **$compress\_storage**). Это будет жрать больше места на SD-карте за счет нескольких копий одной и той же книги(см. описание проблемы выше), но зато позволит владельцам других электрокнижек(не PocketBook), если их книжка поддерживает формат fb2 и навигацию по директориям на флешке, использовать этот же скрипт для автоматической каталогизации своих библиотек.
Еще одна настройка **$control\_genres\_export**. Ее правила находятся в файле «genres.inc».
Там находится массив расшифровок жанров, выглядит он так:
```
''=>array('_Без жанра_','_Без жанра_', true),
'biography'=>array('Биографии','Биография', true),
'biogr_historical'=>array('Биографии исторических личностей','Биография', true),
'biogr_sports'=>array('Биографии спортсменов','Биография', true),
'biogr_arts'=>array('Люди искусства','Биография', true),
'banking'=>array('Банковское дело','Деловая литература', true),
'accounting'=>array('Бухучет, налогообложение, аудит','Деловая литература', true),
'design'=>array('Искусство и Дизайн','Деловая литература', true),
'org_behavior'=>array('Корпоративная культура','Деловая литература', true),
```
Видите, в конце каждого массива есть элемент со значением true? Так вот, при включенной опции **$control\_genres\_export** скрипт будет выливать только те жанры, напротив которых в этом последнем элементе стоит true. Книжки, в которых не прописан ни один жанр, помеченный в «genres.inc» как true, будут игнорироваться, их тела тоже не попадут на карту памяти.
Это очень удобно, если вы понимаете, что размер вашей коллекции больше, чем у вас есть места на SD-карте.
В таком случае вы просто редактируете список жанров, исключая из него ненужные вам. Это позволяет вылить библиотеку на карту частично, только с интересующими вас жанрами. Например вы любите фантастику, а поэзия, любовные романы и деловая литература вас не интересует в принципе.
Так же никто не мешает с помощью этого механизма разбить библиотеку по наборам жанров на несколько разных карт памяти.
В списке жанров есть еще один механизм — переназначение.
Ниже в том же файле(и в том же массиве) вы можете увидеть подобное:
```
'психология'=>array('sci_psychology','r', true),
'science_history_philosophy'=>array('sci_philosophy','r', true),
'языкознание'=>array('sci_linguistic','r', true),
'adv_history_avant'=>array('adv_history','r', true),
'приключения'=>array('adventure','r', true),
'историческая проза'=>array('prose_history','r', true),
```
Видите в предпоследнем значении метатега стоит сиротливая буква 'r'?
Для скрипта это означает, к примеру, что если в книжке обнаружен код жанра 'приключения', он должен смотреть на запись жанра с кодом 'adventure'(в этом же массиве). И книжку в каталогизаторе он отнесет в результате к правильному жанру. Хотя сам fb2-файл править не будет.
#### Не реализовано
Не сделана каталогизация по собственно названиям книжек. Чесно говоря, я не представляю, как это будет выглядеть, и как сделать удобную разбивку директорий для быстрой навигации. По большому счету, если вы кроме названия ничего не знаете, можно по-быстрому хоть с телефона в инете пробить автора, и уже найти книгу на устройстве. Время, затраченное на поиск, против времени, затраченного на последующее чтение, ИМХО, вполне позволяют на этом не заморачиваться.
Не очень нормально сделано отображение прогресса. В исходной директории могут валяться как просто fb2-файлы, так и zip'ы с ними, а так же поддиректории с такими же наборами.
Для zip'файлов прогресс высчитывается наобум, для каждой поддиректории отображается свой прогресс. По хорошему надо бы в начале работы скрипта сканировать все что есть отдельным проходом и потом уже показывать общий прогресс выполнения.
Основательно перелопачен только модуль парсера «xmlp.inc». В остальных исходниках есть некоторый бардак с именами переменных, есть и лишние переменные.
Ну и еще по-мелочи разные некритичные штуки не сделаны.
#### Пример исправления ошибок структуры
До обработки:
```
<:>В следующий раз Якуб пошел на исповедь <одиннадцать лет спустя>, и это> совершенно <другая история.<:>
— Вот те на! — выразил свое изумление Якуб.
Зубами он оторвал уголок конверта и достал плотно сложенную бумагу. Развернул.
```
После(настройка XMLP\_UT\_CONVERT):
```
<:>В следующий раз <tag>Якуб</tag> пошел на исповедь <одиннадцать лет спустя>, и </b>это> совершенно <другая история.<:>
— Вот те на! — выразил свое изумление Якуб.
Зубами он оторвал уголок конверта и достал плотно сложенную бумагу. Развернул.
```
После(настройка XMLP\_UT\_CUT):
```
В следующий раз Якуб пошел на исповедь <одиннадцать лет спустя>, и это> совершенно <другая история.
— Вот те на! — выразил свое изумление Якуб.
Зубами он оторвал уголок конверта и достал плотно сложенную бумагу. Развернул.
```
#### Где взять это добро?
А вот [здесь](http://cs.loving.ru/to_habr/fb2p_release.zip).
Еще на всяк пожарный тем, кто не хочет геморроиться с настройками PHP под Windows, вывалил свой пакет [сюда](http://cs.loving.ru/to_habr/PHP.ZIP). По большому счету, лучше скачайте свежую версию с [php.net](http://www.php.net/), но если в лом, и хочется по-быстрому безболезненно попробовать, и если что, сразу же снести, то разворачиваем данный архив в папку c:\php(в общем-то не важно в какую, желательно, чтобы путь был покороче и без пробелов), и прописываем в системную переменную окружения path эту директорию. Все сразу будет готово к работе.
**P.S.** Да, я знаю, что существуют десктопные программы, позволяющие хранить свою коллекцию. Но…
Во-первых, делалось это все, когда таких программ еще не было.
Во-вторых, они не позволят мне быстро сделать для себя то, что я могу сделать сам(допилить что-то в коде).
В третьих, вряд ли эти программы умеют править критические ошибки в книгах. Я в скрипте умышленно не использовал более быстрый парсинг XML с помощью встроенных в PHP Си-шных библиотек, ибо они падают на ошибках. Можно отключить вылет скрипта при ошибках, но нельзя нормально допарсить файл и автоматически его исправить.
Данный скрипт хоть и написан на «нативном» PHP, тем не менее оптимизирован по скорости обработки.
И много чего еще.
Кстати, никто не мешает же совместить и то и другое. Из десктопной программы отбираем нужные нам книги по условиям(там ведь в GIU гораздо удобнее условия всякие ставить и выливать все по фильтрам), а дальше скармливаем этому скрипту и он формирует каталог на карту памяти.
**UPD**: Обнаружилась засада с новыми Покетбуками и новыми прошивками. Убирают старый функционал книжной полки, и поддержку .flk файлов. Обсуждение проблемы вы можете видеть в комментах в моей переписке с пользователем [Klu4nik](https://geektimes.ru/users/klu4nik/). Функционал с .flk файлами работает на 912-м Покете на заводской прошивке E912.2.1.2 20110727\_154845 из магазина. На более новых прошивках уже не работает.
Звонок в саппорт Покетбуков ничего полезного не дал, одна вода.
После этого с помощью [Klu4nik](https://geektimes.ru/users/klu4nik/) я вышел на официальном форуме на пользователя с ником Antuan, с помощью которого нашел таки решение. Ну как решение, временный костыль по крайней мере у нас есть.
Заключается он в следующем:
Покетбуковская прошивка поддерживает родные и сторонние приложения, вы могли их видеть, зайдя из главного меню в одноименную папку.
Кроме прочего, эти приложения могут быть shell-скриптами, достаточно дать им расширение .app
После тестов оказалось, что можно книжку открыть простой шелл-коммандой вида "/ebrmain/bin/fbreader.app /mnt/ext2/\_zipstorage\_/00000000/00000000/00000001.zip".
Кроме того, если, находясь в папке приложений, на устройстве просто выйти на директорию вверх(директория "..", не выход в главное меню полки), вы будете видеть и память покетбука, и карту памяти, и можете ходить везде и запросто запускать .app файлы. Если войти из главного меню в библиотеку — .app файлы вы видеть не сможете. А через «Приложения» сможете.
Я обновил исходники, теперь там в файле «process.php» появилась еще одна опция настройки **$app\_instead\_of\_flk**. Если ее включить(true), то вместо .flk файлов в каталогизаторе будут ложиться файлы .app вида «Война и мир.app», приблизительно с таким содержанием:
```
#!/bin/sh
/ebrmain/bin/fbreader.app /mnt/ext2/_zipstorage_/00000000/00000000/00000001.zip
```
Работает на ура, книжки открывает. Проверял на своем PocketBook Pro 912, вроде все работает нормально.
Но есть и пара минусов.
При входе через раздел «Приложения» вместо книжной полки работает простенький файловый менеджер. Никаких обложек и красивой книжной полки он не отобразит. Так же нет возможности добавлять в «Избранное».
В общем, перекачайте скрипт по ссылке выше.
Так же посоветовали добавить на сайт [idea.pocketbook-int.com](http://idea.pocketbook-int.com/) запрос на возращение старого функционала.
Там уже есть топик: [idea.pocketbook-int.com/pocketbook-pro/idea/161](http://idea.pocketbook-int.com/pocketbook-pro/idea/161), нужно только голосов набрать побольше, тогда есть шанс, что сделают опцию старой полки в новых прошивках. Но там нужно регистрироваться, чтобы проголосовать за реализацию этой фичи.
**UPD 2**: Решение номер два. Тоже временное(ну кому как).
На текущие прошивки 2.1.2 и 2.1.3 можно установить старую полку от PocketBook 611. Будет интерфейс главного меню, как у старых прошивок. При этом работают файлы-ссылки .flk, «Избранное», мультизадачность, настройки новой прошивки.
Выглядит это на 9.7 дюймах вот так(вертикальная и горизонтальная ориентации):
[](http://cs.loving.ru/to_habr/pb_screens/scr0001.png) [](http://cs.loving.ru/to_habr/pb_screens/scr0003.png) [](http://cs.loving.ru/to_habr/pb_screens/scr0004.png) [](http://cs.loving.ru/to_habr/pb_screens/scr0005.png)
[](http://cs.loving.ru/to_habr/pb_screens/scr0006.png) [](http://cs.loving.ru/to_habr/pb_screens/scr0007.png)
[](http://cs.loving.ru/to_habr/pb_screens/scr0008.png) [](http://cs.loving.ru/to_habr/pb_screens/scr0009.png)
(картинки кликабельны, на скриншоты и превьюхи я добавил только однопиксельную рамку, чтобы видно было края экрана на белом фоне)
Пока замечено только два небольших глючка:
1. главное меню не на полный экран, но работает как надо, не раздражает. Оно и понятно — шаблон менюхи делался под экран 6 дюймов. Остальные экраны нормально масштабируются сами. Так же не на полную ширину экрана рендерится «детальный» вид полки. На скриншотах видно.
2. кнопка «Домой»(возврат в главное меню) не работает. Т.к. переключение в главное меню из контекстного тоже не работает, видимо это связано с мультизадачной средой — не может переключить задачу на то немногозадачное меню, которое мы заменили. Немного раздражает долго выходить в главное меню из дерева каталогов.
Установка проста. Качаем [здесь](http://cs.loving.ru/to_habr/bookshelf_611.zip). Внутри зипа один файл «bookshelf.app». Нужно подключиться USB-шнурком и записать этот файл на внутреннюю память устройства(не на флешку) в директорию "/system/bin/".
Собственно все. После отключения кабеля заработает сразу, хотя лучше на всяк пожарный перегрузиться, чтобы основная полка выгрузилась из памяти.
Снос точно так же прост — цепляем шнурок, удаляем этот файл "/system/bin/bookshelf.app" и все вернется на круги своя.
Проверено на устройстве PocketBook Pro 912. Работает нормально.
**UPD 3**: Появилось дополнительное обсуждение [здесь](http://habrahabr.ru/post/143847/). Велкам с пожеланиями и предложениями.
**UPD 4**[15.05.2012 20:52 MSK]: Исправлена злостная ошибка в «genres.inc», функция genres\_get(), приводившая к жору памяти в цикле. Тупая очепятка была. Во всем виноват копипаст. Исходники обновлены, перекачайте.
**UPD 5**[15.05.2012 22:03 MSK]: Как результат обсуждений по ссылке в UPD3, добавлены и изменены следующие настройки:
```
$dest_mount_point='/mnt/ext2/';
$storagename='.zipstorage';
$path_encoding=PATH_ENC_AUTO;
```
Переменная $path\_encoding отвечает за то, в какой кодировке будут генерироваться пути в каталогизаторе.
Кроме дефолтного автоматического значения могут быть так же принудительные PATH\_ENC\_1251 или PATH\_ENC\_UTF8.
PATH\_ENC\_AUTO определяет по признаку preg\_match('/win/i',PHP\_OS)
Если в константе PHP\_OS содержится «win», то будет PATH\_ENC\_1251, иначе PATH\_ENC\_UTF8.
**UPD 6**[20.05.2012 03:10 MSK]: Переехали на [ГитХаб](http://github.com/dsdcorp/fb2p). | https://habr.com/ru/post/143492/ | null | ru | null |
# Тонкости AngularJS: select внутри шаблона директивы
Эта статья будет описывать решение одной конкретной задачи, а также на примере показывать как работает $transclude.
Задача такая: сделать директиву, обертку для select-а. Предположим, что мы хотим одним тегом добавлять сразу и селект и label к нему (потом можно будет туда добавить ошибки заполнения, но мы для простоты не будем этого делать). В общем то, на первый взгляд выглядит все просто.
Сделаем директиву и назовем ее field. Использовать будем так:
```
```
Мы придумали несколько атрибутов:
* **title** — Название поля
* **type** — Тип поля (у нас будет только select, но вдруг потом...)
* **ng-model** — Переменная, которая хранит выбранное значение
* **options** — Чтобы задать список для селекта мы будем пользоваться синтаксисом англяровского ngOptions
Обратите внимание, что переменные `selectedColor` и `colors` из примера, это переменные scope в котором мы использовали директиву. Мы специально их указали через атрибуты, чтобы директива получила к ним доступ.
Код директивы:
```
angular.module('directives').directive('field', function () {
return {
//директива - это название тега
restrict: 'E',
// то, что мы передали в директиву
scope: {
ngModel: "=",
title: "@",
type: "@",
options: "@"
},
// адрес шаблончика
templateUrl: '/tpl/fields/select.html',
});
```
Код шаблона:
```
{{title}}
```
> Вживую: [codepen.io/Dzorogh/pen/umCKG?editors=101](http://codepen.io/Dzorogh/pen/umCKG?editors=101)
Вроде, все выглядит просто и должно работать. Запускаем, проверяем в отладчике —
```
Цвет
```
Вроде неплохо… только где все options? Почему colors — пуст (точнее, undefined)?
Дело в том, что когда мы указываем в директиве параметр scope, то все тело директивы оборачивается каменной стеной — isolate scope. Это изолированый скоуп не дает тем, кто внутри, видеть внешние scope. Но, соответственно, все те переменные (`ngModel, type, title, options`) что мы указали параметре директивы, будут добавлены в наш изолированый scope и «привязаны» к внешним переменным.
И тут мы можем увидеть проблему — мы не добавили `colors` к тем переменным. И это правильно, директива, разумеется, не должна знать что там за массив мы хотим использовать. Мы уже указали, что используем этот массив, написав его в атрибуте options.
Чтобы получить доступ к массиву, мы должны хотя бы знать название переменной. Поэтому самый лучший вариант — парсить options. Нам тут помогает исходный код angular.js, там есть регулярка для ngOptions.
Но подождите, даже получив название переменной из внешенго scope, как мы сможем ее добавить внутрь?
#### Собственно, самое интересное
Чтобы связывать внешние переменный с внутренними после иницализации директивы нужно использовать такую штуку, как "$transclude". Вызов этой функции дает доступ к внешнему скоупу и можно просто получить любую переменную оттуда и «передать» в скоуп директивы.
Новая директива, с регуляркой и трансклюдом:
```
.directive('field', function() {
// позаимствовано из исходников angularjs
var NG_OPTIONS_REGEXP = /^\s*(.*?)(?:\s+as\s+(.*?))?(?:\s+group\s+by\s+(.*))?\s+for\s+(?:([\$\w][\$\w]*)|(?:\(\s*([\$\w][\$\w]*)\s*,\s*([\$\w][\$\w]*)\s*\)))\s+in\s+(.*?)(?:\s+track\s+by\s+(.*?))?$/;
};
return {
restrict: 'E',
scope: {
ngModel: "=",
type: "@",
title: "@",
options: "@"
},
// "Включаем" возможность использовать трансклюд
transclude: true,
templateUrl: '/fields/select.html',
// $transclude всегда идет 5м параметром.
link: function (scope, element, attrs, controller, $transclude) {
if (scope.type == 'select') {
// Парсинг названия массива значений
var parsedOptions = attrs.options.match(NG_OPTIONS_REGEXP);
// убираем фильтры (они пишутся после | )
var optionsArray = /^(.*) \|/.exec(parsedOptions[7]) || parsedOptions[7];
// optionsArray - название (только название) массива, в котором содержится список значений.
// чтобы получить к нему доступ, нужно взять его из общего Scope
// (того, где появилась директива) и добавить в наш.
$transclude(function (clone, $outerScope) {
scope[optionsArray] = $outerScope[optionsArray];
});
}
}
}
});
```
> Конечный вариант в CodePen: [codepen.io/Dzorogh/pen/gBbyI](http://codepen.io/Dzorogh/pen/gBbyI) | https://habr.com/ru/post/228863/ | null | ru | null |
# Пробуем Gnome 3 на Ubuntu 11.04 Natty Narwhal
Сегодня я установил Ubuntu 11.04 Natty Narwhal Beta 1, дабы поглядеть, что натворили Canonical и нарепортить багов, специфических для моей конфигурации. В результате потратил полдня на попытки хоть как-то разобраться в Unity, но мне не хватило интеллекта: кое-как нашёл системные настройки, хитро спрятанные под иконкой выключения, и так и не нашёл способа примонтировать FTP, что в Gnome делалось элементарно, в два клика. UserInterfaceFreeze давно позади, и надеяться на улучшение в ближайшие полгода не приходится, поэтому знакомство с Unity я отложил на потом, и вернулся в Ubuntu Classic.
Но раз установка тестовая, почему бы не поэкспериментировать, учитывая что буквально на днях состоялся долгожданный релиз Gnome 3?
Все нижеперечисленнве действия проделываются на свой страх и риск, PPA Gnome 3 в данный момент считается нестабильным, как и Beta версия Ubuntu. В моём случае все манипуляциии прошли гладко.
После установки Gnome 3 Ubuntu Unity и Ubuntu Classic могут потерять работоспособность, в моём случае после удаления Gnome 3 работоспособность восстановилась.
#### Установка Gnome 3 на Ubuntu 11.04 Natty Narwhal
Установка проста до безобразия. Открываем терминал, и выполняем следующие команды:
*Добавляем PPA-репозиторий Gnome 3*
```
sudo add-apt-repository ppa:gnome3-team/gnome3
```
*Обновляем список пакетов*
```
sudo apt-get update
```
*Обновляем систему с возможностью доустановки пакетов*
```
sudo apt-get dist-upgrade
```
Перезагружаемся, выбираем сеанс Gnome Shell Session, и вуаля! Gnome shell предельно прост и интуитивен, не вижу смысла объяснять, куда нажимать, и что делать.
#### Удаление Gnome 3 на Ubuntu 11.04 Natty Narwhal
Если Gnome 3 вызвал у вас те же ощущения, что и Unity у меня, избавиться от него не сложнее, чем установить. Для этого запускаем терминал, и последовательно выполняем следующие команды:
*Устанавливаем утилиту для избавления от PPA-репозиториев и их содержимого*
```
sudo apt-get install ppa-purge
```
*Избавляемся от Gnome 3*
```
sudo ppa-purge ppa:gnome3-team/gnome3
```
Перезагружаемся, и возвращаемся в Ubuntu Unity или Ubuntu Classic.
[](http://creativecommons.org/licenses/#licenses)
PS: Скриншот украл с urbanbuntu.ru | https://habr.com/ru/post/117283/ | null | ru | null |
# Как избежать фейлов при разработке продукта: 10 советов от Rookee
Разработка продуктов — процесс трудоемкий. Рынок постоянно нуждается в новых решениях, но на пути создания инноваций любую компанию подстерегают провалы. В данной статье мы собрали воедино свой собственный опыт работы [в высокотехнологичном сервисе](https://www.rookee.ru/?code=referral_habr_10feilov_ssilka_tekst_16_10_18&utm_medium=referral&utm_source=habr&utm_campaign=10feilov&utm_term=ssilka_tekst&utm_content=17_10_18), чтобы попытаться разобраться, какие проблемы могут возникнуть при разработке нового продукта и как их избежать.
``
### 1. Забудьте о процессе, работайте на результат
Нередко компании при разработке продукта все внимание и ресурсы направляют на процесс создания и производства. Даже если каждый этап работ выполнен «строго по технологии», результат может оказаться не таким радужным, как представлялось в начале.
**Пример из практики**
*Три месяца назад в команде [Rookee](https://www.rookee.ru/?code=referral_habr_10feilov_ssilka_tekst_16_10_18&utm_medium=referral&utm_source=habr&utm_campaign=10feilov&utm_term=ssilka_tekst&utm_content=17_10_18) был внедрен сложный процесс системной аналитики. Аналитик должен был запрашивать и собирать маркетинговые исследования, готовить варианты решения, запрашивать финансовые расчеты, проектировать алгоритмы, ставить задачи для UX, определять бизнес-требования, проводить защиту своих решений, отслеживать результат после выкладки, передавать в эксплуатацию и т.д. Нагрузка на одного аналитика могла достигать 15 задач в день. Специалист физически не может пропустить через себя в сутки такое количество разноплановых задач. Неудивительно, что с таким объемом работа аналитика являлась узким горлышком в решении общих задач. Для повышения эффективности многие вещи происходили в обход. В итоге в компании отказались от такого сложного процесса и радикально его упростили, распределив обязанности между разными специалистами. Эффективность повысилась, а процесс аналитики стал происходить быстрее.*
**Как избежать**
Если процесс разработки продукта слишком сложен, а результат не отвечает ожиданиям, необходимо пересмотреть текущие процессы и стать более гибким к изменениям на каждом этапе работ.
### 2. Сохраняйте высокий уровень командной синхронизации
Умение работать в команде — важный навык, которым обладают далеко не все. На практике часто возникают ситуации, когда для реализации одной задачи требуется привлечение сразу нескольких специалистов.
Например, задача о внедрении промокода в систему подразумевает под собой работу и фронтенд-разработчика, и бэкенд. Если эти люди не могут договориться между собой, возможно возникновение самых разных проблем. Например, с точки зрения визуала задача будет сделана, но без алгоритма отработки механики промокода эта задача не даст никакой ценности.
**Пример из практики**
*Когда в нашем сервисе появилось несколько разных продуктов, команды разработки у каждого продукта остались свои. Пользователь один, аккаунт один, а продукты и команды разные. Как-то нам позвонил клиент и сказал, что мы его заспамили. Оказалось, что все команды слали ему письма, когда возникали ситуации, требующие внимания (например, баланс подходил к нулю и работа сервиса могла быть приостановлена). В итоге пользователь получал в неделю порядка 40 писем от сервиса. Был проведен анализ email-рассылок. Некоторые письма объединили. Сейчас в проработке находится email-стратегия, которая окончательно исправит все недостатки.*
**Как избежать**
Чтобы добиться синхронизации по задачам, координируйте действия команды/ команд, работающих над одним продуктом. Например, проводите общее «Демо» проектирования и разработки, уведомляйте о новых фичах другие команды. Заведите в общем доступе документ с историей релизов, которая четко описывает, что, когда и какой командой было сделано, добавив ссылку на задачу в таск-трекере.
### 3. Избегайте доработок продуктов по первому требованию пользователя
У новых продуктов в процессе эксплуатации выявляются проблемы. Не секрет, что некоторые доработки по проектам инициированы пользователями, которые обратились в службу поддержки. Никто не спорит: продукты надо улучшать, но прежде чем бросаться «латать дыры» следует поискать корневую причину проблем.
``
**Как избежать**
Соберите обращения пользователей за достаточный отрезок времени. В зависимости от количества обращений в службу поддержки этот отрезок может составлять как неделю, так и месяц и больше. Проанализируйте вопросы выявите повторяющиеся и решайте те проблемы, на которые пользователи жалуются чаще всего. Если проблема носит блокирующий характер, то есть влияет на корректность работы пользователя в системе, решайте ее незамедлительно.
### 4. Приглашайте разработчиков к обсуждению проекта и проектированию задач
Зачастую, получив бизнес-требования заказчиков, проектировщик приступает к описанию логики работы задач. Если при этом не взять в учет технические особенности системы, может получиться решение, которое выльется в 3 месяца разработки.
**Пример из практики**
*Однажды в [Rookee](https://www.rookee.ru/?code=referral_habr_10feilov_ssilka_tekst_16_10_18&utm_medium=referral&utm_source=habr&utm_campaign=10feilov&utm_term=ssilka_tekst&utm_content=17_10_18) произошла ситуация. Отрисовали интерфейс, в котором был мастер создания проекта в одном из продуктов: на первом шаге пользователь авторизуется в другом сервисе для получения информации из него (в Яндекс.Директе), на втором шаге выбирается список параметров для работы. Параметры получались путем выполнения запроса по токену, указанном на первом шаге.
Интерфейс показали заказчикам, согласовали, отправили разработчикам. Когда разработчики это увидели, они сказали: «Тут придется показывать кино, так как если данных у пользователя много, то ждать он может очень долго. К тому же это интерфейсное решение не user-friendly».
В результате пришлось все переделывать, учитывая обратную связь от программистов.*
**Как избежать**
Приглашайте разработчиков участвовать в обсуждении проектов, составлении требований, вовлекайте их в проектирование. Включив разработчиков в работу на ранних этапах, можно существенно сократить время создания проекта, избежать лишних затрат на переделку и обойтись без лишних седых волос из-за срыва сроков.
### 5. Упрощайте. Гениально, это когда эффективно
Периодически коммерческих специалистов посещают гениальные идеи при создании новых продуктов или доработке старых. К сожалению, не все гениальное востребовано и реализуемо.
**Пример из практики**
*Для увеличения объема продаж нередко используют авторские email-стратегии. Для их реализации существует множество способов: настройка отправки событий, сторонний сервис email-рассылок, который отправляет письма по сигналу вашего сервиса, реализация единой триггерной логики на стороне вашего сервиса и использование стандартного или универсального шаблона для рассылки и др.
Иногда компании решают пойти своим путем и сделать не как все. Сочиняя первое письмо для пользователей в команде думали, что оно будет последним. А потом отправили еще одно последнее письмо. И еще… Когда писем стало много, команда реализовала свой сервис по созданию шаблонов. Он делался 2 месяца и оказался не так хорош, как уже существующие специализированные сервисы. В итоге в компании пришли к оптимальному решению – интегрировали сторонний сервис рассылок.*
**Как избежать**
Если реализация нововведения кажется слишком сложной, откажитесь от нее.
Не тратьте время на создание сервисов, которые будут явно проигрывать уже существующим. Ответьте себе на вопрос, так ли вам нужен инструмент, который сложно поддерживать, но зато свой?
### 6. Избегайте неоднозначного интерпретирования требований
Неоднозначно поставленная задача создает недоразумения, которые могут привести к нежелательным результатам. Например, аналитик может попросить: «Добавьте пять слонов рядом с полем регистрации». Для разных членов команды само собой разумеющимися могут быть разные варианты этого «рядом»: справа, слева, сверху и снизу.
``
**Как избежать**
Если требование не до конца понятно, необходимо задавать уточняющие вопросы. Членам команды следует научиться максимально детализировать каждую задачу, чтобы избежать путаницы и додумывания. Уровень детализации требований обговаривается внутри команды. Также можно разработать шаблон ТЗ, который всех устроит, и в нем максимально подробно прописывать цель задачи, логику и пользовательский интерфейс.
### 7. Помните о целевой аудитории
Как ни странно, находятся люди, которые верят: лучше привлечь как можно больше пользователей, а среди них обязательно окажется и целевая аудитория продукта. Это не так. У вас может быть специфичный продукт, потребители которого — определенный сегмент пользователей.
**Пример из практики**
*Целевая аудитория продукта — домохозяйки, однако проекту хотелось получить много трафика. Потратив значительную сумму на рекламу, компания стала публиковать двусмысленные баннеры на крупных бизнес-порталах в надежде привести платежеспособных клиентов. Трафик сильно увеличился, а продажи — нет. Когда провели опрос, почему пользователи заходят на сайт и ничего не покупают, оказалось, что большинство из них просто не являются ЦА. Предлагаемый продукт их просто не интересовал. В рекламную кампанию были внесены изменения, и проблема через некоторое время разрешилась.*
**Как избежать**
Изначально лучше сосредоточить свои усилия на привлечение целевого трафика и вносить корректировки в рекламные кампании и позиционирование, если посетители сайта — точно не ваши потенциальные клиенты.
### 8. Не допускайте пересечения сплит-тестов при проверке гипотез
Такая проблема может возникнуть при неверном планировании гипотез или низком уровне квалификации аналитиков.
**Пример из практики**
*Компания начала тестировать две версии формы регистрации на лендинге (50% пользователей видят одну версию, 50% — другую). Затем появилась необходимость проверить другую гипотезу на зоне оплаты, и был запущен еще один тест. Это усложнило работу аналитиков, так как пришлось долго делить когорты таким образом, чтобы оценить влияние изменений на конечные действия пользователя. На сбор данных ушло гораздо больше времени, чем потребовалось бы при проведении тестов друг за другом.*
**Как избежать**
При проведении A/B-тестов не допускайте пересечения сплитов. Старайтесь разделять пользователей так, чтобы один человек участвовал только в одном эксперименте. Если вдруг все же было запущено сразу два теста, оценивайте 4 группы:
* первый вариант лендинга + первый вариант на зоне оплаты;
* первый вариант лендинга + второй вариант на зоне оплаты;
* второй вариант лендинга + первый вариант на зоне оплаты;
* второй вариант лендинга + второй вариант на зоне оплаты.
### 9. Не путайте свое мнение с мнением пользователя
Одна из типичных ошибок — это принятие своего мнения за мнение пользователя. Если вам нравится продукт, его дизайн и юзабилити, вы понимаете, как с ним взаимодействовать, не факт, что пользователь разделит ваш восторг.
``
**Как избежать**
При разработке каждой отдельной зоны интерфейса учитывайте визуал всего сервиса в целом. Не думайте за пользователя. Спросите у него (например, с помощью метода фокус-группы), как ему удобнее, привычнее, лучше, чего он ожидает от нового продукта. Яндекс перед запуском продуктов проводит очные тестирования: встречается с пользователями, смотрит на их реакцию, задает неудобные вопросы по своей гипотезе.
Если заранее узнать мнение пользователя о разработке, можно избежать множества проблем в дальнейшем.
### 10. Логируйте события по максимуму
При возникновении спорной ситуации в работе какого-либо системного модуля, быстрее и проще всего обратиться к логам событий. Если, конечно, они есть. Если вы ленились и не логировали события, придется потрудиться, чтобы отыскать первоисточник проблемы при ее возникновении.
**Как избежать**
Логируйте события по максимуму. Это не значит, что надо начать логировать каждую мелкую деталь, вроде пользовательского движения мышкой, но основная информация, происходящая с объектом, должна быть записана.
Заключение
----------
Любая компания может столкнуться с проблемами при разработке новых продуктов. Главное, признать ошибки, сделать выводы и принять меры, чтобы в будущем они не повторялись.
А в вашей практике разработки случались неудачи и как вы с ними боролись? Расскажите о своем опыте в комментариях.
Автор: Екатерина Хиндикайнен, ведущий системный аналитик сервиса [Rookee](https://www.rookee.ru/?code=referral_habr_10feilov_ssilka_tekst_16_10_18&utm_medium=referral&utm_source=habr&utm_campaign=10feilov&utm_term=ssilka_tekst&utm_content=17_10_18) | https://habr.com/ru/post/426721/ | null | ru | null |
# Начинаем использовать Tarantool в Java проекте
В статье ниже я попытаюсь кратко рассказать о том, что такое Tarantool и как начать его использовать в уже существующем проекте если вы программируете на Java. Если же вы программируете на другом языке, то вам могут быть интересны некоторые инструменты доступные в коннекторе, такие как возможность редактирование xlog файлов и создание snap файлов из любых данных. Если вы не знаете, что такое Tarantool, то лучше прочитать [этот пост](http://habrahabr.ru/post/133435/).
[Tarantool](http://tarantool.org) — это ключ-кортеж хранилище данных. Все данные и индексы хранятся в оперативной памяти. Значения составляют кортеж, далее **tuple**, кортежи — пространство, далее **space**, пространства — модель данных. Поддерживаются 3 типа данных: 32 битное без знаковое целоe, 64 битное без знаковое целое и бинарная строка, далее **NUM**, **NUM64** и **STR** соответственно. Для любого пространства должны быть определены тип и структура первичного индекса, например: HASH по полям 1,2 где 1 — NUM, а 2 — NUM64. Вторичные индексы задаются точно так же как и первичные. [DML](http://ru.wikipedia.org/wiki/DML) операции атомарны на уровне кортежа и выполняются только по первичному индексу. Для выполнения нескольких операций атомарно нужно использовать встроенный язык [Lua](http://ru.wikipedia.org/wiki/Lua). Сохранность данных обеспечивается путём сохранения снимка текущего состояния, далее **snapshot**, и бинарного лога, далее **xlog**. Для хранения кортежей используется [slab](http://ru.wikipedia.org/wiki/Slab).
В примерах ниже используется java connector, подробнее о нём можно узнать по адресу [dgreenru.github.com/tarantool-java](http://dgreenru.github.com/tarantool-java/). Последняя стабильная версия на момент написания статьи **0.1.2**. Ниже я рассмотрю пример использования дополнительного функционала позволяющего переносить и синхронизировать данные с любыми другими хранилищами.
#### Пример переноса таблицы MySQL в Tarantool Box:
```
mysql> desc user;
+------------+--------------+------+-----+-------------------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------+--------------+------+-----+-------------------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| username | varchar(255) | NO | UNI | NULL | |
| email | varchar(255) | NO | UNI | NULL | |
| enabled | tinyint(1) | NO | | 1 | |
| registered | timestamp | NO | | CURRENT_TIMESTAMP | |
+------------+--------------+------+-----+-------------------+----------------+
5 rows in set
```
Первичный индекс id и 2 вторичных уникальных индекса username и email. Из непереносимых по умолчанию мест можно выделить *auto\_increment* и *timestamp*. Для первого можно использовать хранимую процедуру **box.auto\_increment**, а для второго можно хранить данные в формате *yyyyMMddhhmmss* или секундах. Если таблица user достаточно небольшая, то можно просто прочитать данные из mysql и вставить в Tarantool Box, на этой задаче я останавливаться не буду, а расскажу, что делать если таблица очень большая, т.е. содержит очень много записей, пусть и каждая из них небольшого размера. Для начала нужно выгрузить данные в удобный для нас формат, желательно не сильно занимая при этом ресурсы сервера.
```
mysql> select * into outfile '/tmp/user' from user;
Query OK, 73890541 rows affected
$ head -1 /tmp/user
1 username email@domain.tld 1 2012-10-14 01:27:05
```
Скопировав файл на нужный сервер или локальный компьютер, можно приступить к его обработке и конвертации в формат Tarantool Box. В примере ниже, для простоты, не рассматриваются эскейп последовательности. Если у вас в таблицах встречаются символы табуляции, переноса строки, возврата каретки, обратный слэш или поля содержат NULL значения, вам нужно добавить их обработку самостоятельно.
```
BufferedReader reader = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream("/tmp/user.gz")), "utf-8"));
SnapshotWriter writer = new SnapshotWriter(new FileOutputStream("/tmp/user.snap").getChannel());
String line = null;
DateFormat indf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
DateFormat outdf = new SimpleDateFormat("yyyyMMddhhmmss");
Pattern pattern = Pattern.compile("\t");
while ((line = reader.readLine()) != null) {
try {
String[] values = pattern.split(line);
if (values.length == 5) {
Integer id = Integer.parseInt(values[0]);
String username = values[1];
String email = values[2];
byte[] enabled = { Byte.valueOf(values[3]) };
Long registered = Long.parseLong(outdf.format(indf.parse(values[4])));
Tuple tuple = new Tuple(5).setInt(0, id).setString(1, username, "UTF-8")
.setString(2, email, "UTF-8").setBytes(3, enabled).setLong(4, registered);
writer.writeRow(0, tuple);
} else {
System.err.println("Line should be splited in 5 parts, but has " + values.length + " for " + line);
}
} catch (Exception e) {
System.err.println("Can't parse line " + line);
e.printStackTrace();
}
}
writer.close();
reader.close();
```
В результате имеем файл
```
$ ls -sh /tmp/user.snap
16.1G /tmp/user.snap
```
теперь необходимо настроить space 0 соответствующим образом.
```
# Этот параметр ограничивает суммарный размер памяти выделенной под slab блоки.
# Индексы и другие накладные расходы хранятся вне slab,
# поэтому суммарная память процесса может быть до 2х больше.
# В нашем случае логично поставить здесь 24 гигабайта.
slab_alloc_arena = 24
# Так же имеет смысл откорректировать количество записей в одном xlog файле.
rows_per_wal = 500000
# И конечно же конфигурация ключей space 0
space[0].enabled = 1
# id. Чтобы использовать box.auto_increment тип дерева должен быть TREE.
space[0].index[0].type = "TREE"
space[0].index[0].unique = 1
space[0].index[0].key_field[0].fieldno = 0
space[0].index[0].key_field[0].type = "NUM"
#username
space[0].index[1].type = "HASH"
space[0].index[1].unique = 1
space[0].index[1].key_field[0].fieldno = 1
space[0].index[1].key_field[0].type = "STR"
#password
space[0].index[2].type = "HASH"
space[0].index[2].unique = 1
space[0].index[2].key_field[0].fieldno = 2
space[0].index[2].key_field[0].type = "STR"
```
Далее нам нужно заменить 00000000000000000001.snap находящегося в папке work\_dir из конфигурационного файла на созданный нами файл.
```
$ mv /tmp/user.snap /var/lib/tarantool/00000000000000000001.snap
```
и попробовать запустить сервер
```
$ tarantool_box --background
$ ps -C tarantool_box -o pid=,cmd=
8853 tarantool_box: primary pri: 33013 sec: 33014 adm: 33015
```
так же посмотрите файл tarantool.log, в случае успешного запуска он будет заканчиваться на строки похожие на приведённые ниже, в случае ошибки, вы сразу увидите причину.
```
1350504007.249 7127 1/sched _ I> Space 0: done
1350504007.249 7127 101/33013/primary _ I> bound to port 33013
1350504007.249 7127 101/33013/primary _ I> I am primary
1350504007.249 7127 102/33014/secondary _ I> bound to port 33014
1350504007.250 7127 103/33015/admin _ I> bound to port 33015
1350504007.251 7127 1/sched _ C> log level 4
1350504007.251 7127 1/sched _ C> entering event loop
```
Далее корректность вставки данных можно проверить простым способом
```
$ tarantool -a 127.0.0.1
127.0.0.1> select * from t0 where k0 = 1
Select OK, 1 rows affected
[1, 'username', 'email@domain.tld', '\x01', '\x21\x8b\xe4\xc9\x4c\x12']
127.0.0.1> select * from t0 where k1 = 'username'
Select OK, 1 rows affected
[1, 'username', 'email@domain.tld', '\x01', '\x21\x8b\xe4\xc9\x4c\x12']
127.0.0.1> select * from t0 where k2 = 'email@domain.tld'
Select OK, 1 rows affected
[1, 'username', 'email@domain.tld', '\x01', '\x21\x8b\xe4\xc9\x4c\x12']
```
т.е. мы проверили нахождение данных по 3-м ключам, указанным нами в конфиге. Далее можно посмотреть количество потребляемой процессом памяти в системе и отчёт команды **show slab** в консоли Tarantool Box.
Tarantool Box запущен, теперь нужно позаботится о резервном копирование данных и поддержке таблицы MySQL в актуальном состояние на случай, если какие-то запросы используют данные из неё в своих целях. Это достаточно просто организовать при помощи класса ReplicationClient. Он позволит иметь почти полную резервную копию xlog без использования полноценного slave сервера и организовать обновление таблицы в MySQL без затрат дополнительных ресурсов и времени. Не забудьте указать **replication\_port** в конфиге, чтобы сделать репликацию возможной. Описанный ниже класс сохраняем все логи полученные от сервера в файлы длинной по 50 тыс. записей. Алгоритм работы достаточно простой:
1. поиск уже существующих логов
2. определение максимального lsn
3. подключение на порт репликации
4. транслируем в файл получаемые данные
Логика обновления MySQL в данном коде отсутствует, но её легко реализовать немного изменив цикл в функции main. Сложным место является расширение класса **ReplicationClient** кодом, который записывает получаемые данные в бинарный лог, расширяя их до формата xlog. На этом месте можно особо не останавливаться, т.к. данный пример скорее заготовка для реального приложения, чем демонстрация использования.
```
public class Backup {
protected DecimalFormat xlogNameFormat = new DecimalFormat("00000000000000000000");
protected String folder;
protected FileChannel xlogChannel;
protected int row;
protected int limit = 50000;
protected long lsn = 0L;
protected ReplicationClient client;
protected XLogWriter writer;
public void setLimit(int limit) {
this.limit = limit;
}
public Backup(String folder, String host, int port) throws IOException {
this.folder = folder;
}
protected void getLatestLSN(String folder) throws IOException, FileNotFoundException {
final File backupFolder = new File(folder);
String[] xlogs = backupFolder.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".xlog");
}
});
boolean hasLogs = xlogs != null && xlogs.length > 0;
if (hasLogs) {
Arrays.sort(xlogs);
XLogReader reader = new XLogReader(new FileInputStream(folder + "/" + xlogs[xlogs.length - 1]).getChannel());
XLogEntry xlogEntry = null;
while ((xlogEntry = reader.nextEntry()) != null) {
lsn = xlogEntry.header.lsn;
}
reader.close();
}
}
public void start() throws IOException {
getLatestLSN(folder);
System.out.println("Planning to start from lsn: " + lsn);
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
@Override
public void run() {
try {
synchronized (this) {
close();
}
} catch (IOException e) {
throw new IllegalStateException("Can't close xlog", e);
}
}
}));
final ByteBuffer rowStartMarker = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(Const.ROW_START_MARKER);
client = new ReplicationClient(SocketChannel.open(new InetSocketAddress("127.0.0.1", 33016)), lsn + 1L) {
@Override
protected ByteBuffer readBody(Header header) throws IOException {
if (Backup.this.xlogChannel == null) {
Backup.this.xlogChannel = nextFile(folder);
}
ByteBuffer body = super.readBody(header);
this.header.flip();
rowStartMarker.flip();
synchronized (Backup.this) {
while (rowStartMarker.hasRemaining())
Backup.this.xlogChannel.write(rowStartMarker);
while (this.header.hasRemaining())
Backup.this.xlogChannel.write(this.header);
while (body.hasRemaining())
Backup.this.xlogChannel.write(body);
Backup.this.xlogChannel.force(false);
body.flip();
}
return body;
}
};
}
public XLogEntry nextEntry() throws IOException {
XLogEntry entry = client.nextEntry();
lsn = entry.header.lsn;
if (++row >= limit) {
close();
xlogChannel = nextFile(folder);
row = 0;
}
return entry;
}
protected FileChannel nextFile(String folder) throws IOException {
String fileName = folder + "/" + xlogNameFormat.format(lsn + 1L) + ".xlog";
new File(fileName).createNewFile();
FileChannel channel = new FileOutputStream(fileName, true).getChannel();
writer = new XLogWriter(channel);
return channel;
}
public void close() throws IOException {
if (writer != null) {
writer.close();
}
}
public static void main(String[] args) throws IOException {
final Backup backup = new Backup("/home/dgreen/backup", "localhost", 33016);
backup.start();
XLogEntry entry = null;
while ((entry = backup.nextEntry()) != null) {
StringBuilder pk = new StringBuilder();
for (int i = 0; i < entry.tuple.size(); i++) {
if (pk.length() > 0) {
pk.append(" - ");
}
switch (entry.tuple.getBytes(i).length) {
case 4:
pk.append(String.valueOf(entry.tuple.getInt(i)));
break;
case 8:
pk.append(String.valueOf(entry.tuple.getLong(i)));
break;
default:
pk.append(entry.tuple.getString(i, "UTF-8"));
}
}
switch (entry.op) {
case Update.OP_CODE:
System.out.println("Got update on #" + pk.toString());
break;
case Insert.OP_CODE:
System.out.println("Got insert " + pk.toString());
break;
case Delete.OP_CODE:
System.out.println("Got delete of #" + pk.toString());
break;
default:
System.out.println("Got unknown op " + entry.op + " " + pk.toString());
break;
}
}
}
}
```
Так же отдельно хотелось бы отметить, что при использовании функционала работы с xlog файлами практически невозможно потерять данные, даже если вы случайно удалили кортеж или очистили целиком space, используя классы **XLogReader** и **XLogWriter** вы сможете легко отредактировать xlog.
На этом в принципе всё, ещё раз напоминаю, что более подробно о коннекторе можно узнать по адресу [dgreenru.github.com/tarantool-java](http://dgreenru.github.com/tarantool-java), исходный код использованных примеров доступен в репозитории на гитхабе. | https://habr.com/ru/post/155575/ | null | ru | null |
# Знакомство с межпроцессным взаимодействием на Linux
Межпроцессное взаимодействие (*Inter-process communication (IPC)*) — это набор методов для обмена данными между потоками процессов. Процессы могут быть запущены как на одном и том же компьютере, так и на разных, соединенных сетью. IPC бывают нескольких типов: «сигнал», «сокет», «семафор», «файл», «сообщение»…
В данной статье я хочу рассмотреть всего 3 типа IPC:1. [именованный канал](#part_namedpipe)
2. [разделенная память](#part_sharedmemory)
3. [семафор](#part_semaphore)
###### Отступление: данная статья является учебной и расчитана на людей, только еще вступающих на путь системного программирования. Ее главный замысел — познакомиться с различными способами взаимодействия между процессами на POSIX-совместимой ОС.
### Именованный канал
Для передачи сообщений можно использовать механизмы сокетов, каналов, D-bus и другие технологии. Про сокеты на каждом углу можно почитать, а про D-bus отдельную статью написать. Поэтому я решил остановиться на малоозвученных технологиях отвечающих стандартам POSIX и привести рабочие примеры.
Рассмотрим передачу сообщений по именованным каналам. Схематично передача выглядит так:
Для создания именованных каналов будем использовать функцию, **mkfifo()**:
```
#include
int mkfifo(const char \*pathname, mode\_t mode);
```
Функция создает специальный FIFO файл с именем **pathname**, а параметр **mode** задает права доступа к файлу.
###### Примечание: **mode** используется в сочетании с текущим значением *umask* следующим образом: *(**mode** & ~umask)*. Результатом этой операции и будет новое значение *umask* для создаваемого нами файла. По этой причине мы используем 0777 (*S\_IRWXO | S\_IRWXG | S\_IRWXU*), чтобы не затирать ни один бит текущей маски.
Как только файл создан, любой процесс может открыть этот файл для чтения или записи также, как открывает обычный файл. Однако, для корректного использования файла, необходимо открыть его одновременно двумя процессами/потоками, одним для получение данных (чтение файла), другим на передачу (запись в файл).
В случае успешного создания FIFO файла, **mkfifo()** возвращает 0 (нуль). В случае каких либо ошибок, функция возвращает -1 и выставляет код ошибки в переменную **errno**.
Типичные ошибки, которые могут возникнуть во время создания канала:* *EACCES* — нет прав на запуск (execute) в одной из директорий в пути **pathname**
* *EEXIST* — файл **pathname** уже существует, даже если файл — символическая ссылка
* *ENOENT* — не существует какой-либо директории, упомянутой в **pathname**, либо является битой ссылкой
* *ENOSPC* — нет места для создания нового файла
* *ENOTDIR* — одна из директорий, упомянутых в **pathname**, на самом деле не является таковой
* *EROFS* — попытка создать FIFO файл на файловой системе «только-на-чтение»
Чтение и запись в созданный файл производится с помощью функций **read()** и **write()**.
#### Пример
###### mkfifo.c
```
#include
#include
#include
#include
#define NAMEDPIPE\_NAME "/tmp/my\_named\_pipe"
#define BUFSIZE 50
int main (int argc, char \*\* argv) {
int fd, len;
char buf[BUFSIZE];
if ( mkfifo(NAMEDPIPE\_NAME, 0777) ) {
perror("mkfifo");
return 1;
}
printf("%s is created\n", NAMEDPIPE\_NAME);
if ( (fd = open(NAMEDPIPE\_NAME, O\_RDONLY)) <= 0 ) {
perror("open");
return 1;
}
printf("%s is opened\n", NAMEDPIPE\_NAME);
do {
memset(buf, '\0', BUFSIZE);
if ( (len = read(fd, buf, BUFSIZE-1)) <= 0 ) {
perror("read");
close(fd);
remove(NAMEDPIPE\_NAME);
return 0;
}
printf("Incomming message (%d): %s\n", len, buf);
} while ( 1 );
}
```
[[скачать](http://codepad.org/OmewsNFb)]
Мы открываем файл только для чтения (*O\_RDONLY*). И могли бы использовать *O\_NONBLOCK* модификатор, предназначенный специально для FIFO файлов, чтобы не ждать когда с другой стороны файл откроют для записи. Но в приведенном коде такой способ неудобен.
Компилируем программу, затем запускаем ее:
```
$ gcc -o mkfifo mkfifo.c
$ ./mkfifo
```
В соседнем терминальном окне выполняем:
```
$ echo 'Hello, my named pipe!' > /tmp/my_named_pipe
```
В результате мы увидим следующий вывод от программы:
```
$ ./mkfifo
/tmp/my_named_pipe is created
/tmp/my_named_pipe is opened
Incomming message (22): Hello, my named pipe!
read: Success
```
### Разделяемая память
Следующий тип межпроцессного взаимодействия — разделяемая память (*shared memory*). Схематично изобразим ее как некую именованную область в памяти, к которой обращаются одновременно два процесса:
Для выделения разделяемой памяти будем использовать POSIX функцию **shm\_open()**:
```
#include
int shm\_open(const char \*name, int oflag, mode\_t mode);
```
Функция возвращает файловый дескриптор, который связан с объектом памяти. Этот дескриптор в дальнейшем можно использовать другими функциями (к примеру, **mmap()** или **mprotect()**).
Целостность объекта памяти сохраняется, включая все данные связанные с ним, до тех пор пока объект не отсоединен/удален (**shm\_unlink()**). Это означает, что любой процесс может получить доступ к нашему объекту памяти (если он знает его имя) до тех пор, пока явно в одном из процессов мы не вызовем **shm\_unlink()**.
Переменная **oflag** является побитовым «ИЛИ» следующих флагов:* *O\_RDONLY* — открыть только с правами на чтение
* *O\_RDWR* — открыть с правами на чтение и запись
* *O\_CREAT* — если объект уже существует, то от флага никакого эффекта. Иначе, объект создается и для него выставляются права доступа в соответствии с mode.
* *O\_EXCL* — установка этого флага в сочетании с O\_CREATE приведет к возврату функцией shm\_open ошибки, если сегмент общей памяти уже существует.
Как задается значение параметра **mode** подробно описано в предыдущем параграфе «передача сообщений».
После создания общего объекта памяти, мы задаем размер разделяемой памяти вызовом **ftruncate()**. На входе у функции файловый дескриптор нашего объекта и необходимый нам размер.
#### Пример
Следующий код демонстрирует создание, изменение и удаление разделяемой памяти. Так же показывается как после создания разделяемой памяти, программа выходит, но при следующем же запуске мы можем получить к ней доступ, пока не выполнен **shm\_unlink()**.
###### shm\_open.c
```
#include
#include
#include
#include
#include
#include
#define SHARED\_MEMORY\_OBJECT\_NAME "my\_shared\_memory"
#define SHARED\_MEMORY\_OBJECT\_SIZE 50
#define SHM\_CREATE 1
#define SHM\_PRINT 3
#define SHM\_CLOSE 4
void usage(const char \* s) {
printf("Usage: %s ['text']\n", s);
}
int main (int argc, char \*\* argv) {
int shm, len, cmd, mode = 0;
char \*addr;
if ( argc < 2 ) {
usage(argv[0]);
return 1;
}
if ( (!strcmp(argv[1], "create") || !strcmp(argv[1], "write")) && (argc == 3) ) {
len = strlen(argv[2]);
len = (len<=SHARED\_MEMORY\_OBJECT\_SIZE)?len:SHARED\_MEMORY\_OBJECT\_SIZE;
mode = O\_CREAT;
cmd = SHM\_CREATE;
} else if ( ! strcmp(argv[1], "print" ) ) {
cmd = SHM\_PRINT;
} else if ( ! strcmp(argv[1], "unlink" ) ) {
cmd = SHM\_CLOSE;
} else {
usage(argv[0]);
return 1;
}
if ( (shm = shm\_open(SHARED\_MEMORY\_OBJECT\_NAME, mode|O\_RDWR, 0777)) == -1 ) {
perror("shm\_open");
return 1;
}
if ( cmd == SHM\_CREATE ) {
if ( ftruncate(shm, SHARED\_MEMORY\_OBJECT\_SIZE+1) == -1 ) {
perror("ftruncate");
return 1;
}
}
addr = mmap(0, SHARED\_MEMORY\_OBJECT\_SIZE+1, PROT\_WRITE|PROT\_READ, MAP\_SHARED, shm, 0);
if ( addr == (char\*)-1 ) {
perror("mmap");
return 1;
}
switch ( cmd ) {
case SHM\_CREATE:
memcpy(addr, argv[2], len);
addr[len] = '\0';
printf("Shared memory filled in. You may run '%s print' to see value.\n", argv[0]);
break;
case SHM\_PRINT:
printf("Got from shared memory: %s\n", addr);
break;
}
munmap(addr, SHARED\_MEMORY\_OBJECT\_SIZE);
close(shm);
if ( cmd == SHM\_CLOSE ) {
shm\_unlink(SHARED\_MEMORY\_OBJECT\_NAME);
}
return 0;
}
```
[[скачать](http://codepad.org/sos8GSpI)]
После создания объекта памяти мы установили нужный нам размер shared memory вызовом **ftruncate()**. Затем мы получили доступ к разделяемой памяти при помощи **mmap()**. *(Вообще говоря, даже с помощью самого вызова **mmap()** можно создать разделяемую память. Но отличие вызова **shm\_open()** в том, что память будет оставаться выделенной до момента удаления или перезагрузки компьютера.)*
Компилировать код на этот раз нужно с опцией *-lrt*:
```
$ gcc -o shm_open -lrt shm_open.c
```
Смотрим что получилось:
```
$ ./shm_open create 'Hello, my shared memory!'
Shared memory filled in. You may run './shm_open print' to see value.
$ ./shm_open print
Got from shared memory: Hello, my shared memory!
$ ./shm_open create 'Hello!'
Shared memory filled in. You may run './shm_open print' to see value.
$ ./shm_open print
Got from shared memory: Hello!
$ ./shm_open close
$ ./shm_open print
shm_open: No such file or directory
```
Аргумент «create» в нашей программе мы используем как для создания разделенной памяти, так и для изменения ее содержимого.
Зная имя объекта памяти, мы можем менять содержимое разделяемой памяти. Но стоит нам вызвать **shm\_unlink()**, как память перестает быть нам доступна и **shm\_open()** без параметра *O\_CREATE* возвращает ошибку «No such file or directory».
### Семафор
Семафор — самый часто употребляемый метод для синхронизации потоков и для контролирования одновременного доступа множеством потоков/процессов к общей памяти (к примеру, глобальной переменной). Взаимодействие между процессами в случае с семафорами заключается в том, что процессы работают с одним и тем же набором данных и корректируют свое поведение в зависимости от этих данных.
Есть два типа семафоров:1. семафор со счетчиком (counting semaphore), определяющий лимит ресурсов для процессов, получающих доступ к ним
2. бинарный семафор (binary semaphore), имеющий два состояния «0» или «1» (чаще: «занят» или «не занят»)
Рассмотрим оба типа семафоров.
#### Семафор со счетчиком
Смысл семафора со счетчиком в том, чтобы дать доступ к какому-то ресурсу только определенному количеству процессов. Остальные будут ждать в очереди, когда ресурс освободится.
Итак, для реализации семафоров будем использовать POSIX функцию **sem\_open()**:
```
#include
sem\_t \*sem\_open(const char \*name, int oflag, mode\_t mode, unsigned int value);
```
В функцию для создания семафора мы передаем имя семафора, построенное по определенным правилам и управляющие флаги. Таким образом у нас получится именованный семафор.
Имя семафора строится следующим образом: в начале идет символ "/" (косая черта), а следом латинские символы. Символ «косая черта» при этом больше не должен применяться. Длина имени семафора может быть вплоть до 251 знака.
Если нам необходимо создать семафор, то передается управляющий флаг *O\_CREATE*. Чтобы начать использовать уже существующий семафор, то **oflag** равняется нулю. Если вместе с флагом *O\_CREATE* передать флаг *O\_EXCL*, то функция **sem\_open()** вернет ошибку, в случае если семафор с указанным именем уже существует.
Параметр **mode** задает права доступа таким же образом, как это объяснено в предыдущих главах. А переменной **value** инициализируется начальное значение семафора. Оба параметра **mode** и **value** игнорируются в случае, когда семафор с указанным именем уже существует, а **sem\_open()** вызван вместе с флагом *O\_CREATE*.
Для быстрого открытия существующего семафора используем конструкцию:
```
#include
sem\_t \*sem\_open(const char \*name, int oflag);
```
, где указываются только имя семафора и управляющий флаг.
#### Пример семафора со счетчиком
Рассмотрим пример использования семафора для синхронизации процессов. В нашем примере один процесс увеличивает значение семафора и ждет, когда второй сбросит его, чтобы продолжить дальнейшее выполнение.
###### sem\_open.c
```
#include
#include
#include
#include
#define SEMAPHORE\_NAME "/my\_named\_semaphore"
int main(int argc, char \*\* argv) {
sem\_t \*sem;
if ( argc == 2 ) {
printf("Dropping semaphore...\n");
if ( (sem = sem\_open(SEMAPHORE\_NAME, 0)) == SEM\_FAILED ) {
perror("sem\_open");
return 1;
}
sem\_post(sem);
perror("sem\_post");
printf("Semaphore dropped.\n");
return 0;
}
if ( (sem = sem\_open(SEMAPHORE\_NAME, O\_CREAT, 0777, 0)) == SEM\_FAILED ) {
perror("sem\_open");
return 1;
}
printf("Semaphore is taken.\nWaiting for it to be dropped.\n");
if (sem\_wait(sem) < 0 )
perror("sem\_wait");
if ( sem\_close(sem) < 0 )
perror("sem\_close");
return 0;
}
```
[[скачать](http://codepad.org/8dzQVZ8n)]
В одной консоли запускаем:
```
$ ./sem_open
Semaphore is taken.
Waiting for it to be dropped. <-- здесь процесс в ожидании другого процесса
sem_wait: Success
sem_close: Success
```
В соседней консоли запускаем:
```
$ ./sem_open 1
Dropping semaphore...
sem_post: Success
Semaphore dropped.
```
#### Бинарный семафор
Вместо бинарного семафора, для которого так же используется функция sem\_open, я рассмотрю гораздо чаще употребляемый семафор, называемый «мьютекс» (mutex).
Мьютекс по существу является тем же самым, чем является бинарный семафор (т.е. семафор с двумя состояниями: «занят» и «не занят»). Но термин «mutex» чаще используется чтобы описать схему, которая предохраняет два процесса от одновременного использования общих данных/переменных. В то время как термин «бинарный семафор» чаще употребляется для описания конструкции, которая ограничивает доступ к одному ресурсу. То есть бинарный семафор используют там, где один процесс «занимает» семафор, а другой его «освобождает». В то время как мьютекс освобождается тем же процессом/потоком, который занял его.
Без мьютекса не обойтись в написании, к примеру базы данных, к которой доступ могут иметь множество клиентов.
Для использования мьютекса необходимо вызвать функцию pthread\_mutex\_init():
```
#include
int pthread\_mutex\_init(pthread\_mutex\_t \*mutex, const pthread\_mutexattr\_t \*mutexattr);
```
Функция инициализирует мьютекс (перемнную **mutex**) аттрибутом **mutexattr**. Если **mutexattr** равен *NULL*, то мьютекс инициализируется значением по умолчанию. В случае успешного выполнения функции (код возрата 0), мьютекс считается инициализированным и «свободным».
Типичные ошибки, которые могут возникнуть:* *EAGAIN* — недостаточно необходимых ресурсов (кроме памяти) для инициализации мьютекса
* *ENOMEM* — недостаточно памяти
* *EPERM* — нет прав для выполнения операции
* *EBUSY* — попытка инициализировать мьютекс, который уже был инициализирован, но не унечтожен
* *EINVAL* — значение **mutexattr** не валидно
Чтобы занять или освободить мьютекс, используем функции:
```
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
```
Функция **pthread\_mutex\_lock()**, если **mutex** еще не занят, то занимает его, становится его обладателем и сразу же выходит. Если мьютекс занят, то блокирует дальнейшее выполнение процесса и ждет освобождения мьютекса.
Функция **pthread\_mutex\_trylock()** идентична по поведению функции **pthread\_mutex\_lock()**, с одним исключением — она не блокирует процесс, если **mutex** занят, а возвращает *EBUSY* код.
Фунция **pthread\_mutex\_unlock()** освобождает занятый мьютекс.
Коды возврата для **pthread\_mutex\_lock()**:* EINVAL — mutex неправильно инициализирован
* EDEADLK — мьютекс уже занят текущим процессом
Коды возврата для **pthread\_mutex\_trylock()**:* EBUSY — мьютекс уже занят
* EINVAL — мьютекс неправильно инициализирован
Коды возврата для **pthread\_mutex\_unlock()**:* EINVAL — мьютекс неправильно инициализирован
* EPERM — вызывающий процесс не является обладателем мьютекса
#### Пример mutex
###### mutex.c
```
#include
#include
#include
#include
static int counter; // shared resource
static pthread\_mutex\_t mutex = PTHREAD\_MUTEX\_INITIALIZER;
void incr\_counter(void \*p) {
do {
usleep(10); // Let's have a time slice between mutex locks
pthread\_mutex\_lock(&mutex);
counter++;
printf("%d\n", counter);
sleep(1);
pthread\_mutex\_unlock(&mutex);
} while ( 1 );
}
void reset\_counter(void \*p) {
char buf[10];
int num = 0;
int rc;
pthread\_mutex\_lock(&mutex); // block mutex just to show message
printf("Enter the number and press 'Enter' to initialize the counter with new value anytime.\n");
sleep(3);
pthread\_mutex\_unlock(&mutex); // unblock blocked mutex so another thread may work
do {
if ( gets(buf) != buf ) return; // NO fool-protection ! Risk of overflow !
num = atoi(buf);
if ( (rc = pthread\_mutex\_trylock(&mutex)) == EBUSY ) {
printf("Mutex is already locked by another process.\nLet's lock mutex using pthread\_mutex\_lock().\n");
pthread\_mutex\_lock(&mutex);
} else if ( rc == 0 ) {
printf("WOW! You are on time! Congratulation!\n");
} else {
printf("Error: %d\n", rc);
return;
}
counter = num;
printf("New value for counter is %d\n", counter);
pthread\_mutex\_unlock(&mutex);
} while ( 1 );
}
int main(int argc, char \*\* argv) {
pthread\_t thread\_1;
pthread\_t thread\_2;
counter = 0;
pthread\_create(&thread\_1, NULL, (void \*)&incr\_counter, NULL);
pthread\_create(&thread\_2, NULL, (void \*)&reset\_counter, NULL);
pthread\_join(thread\_2, NULL);
return 0;
}
```
[[скачать](http://codepad.org/1KdzUvAA)]
Данный пример демонстрирует совместный доступ двух потоков к общей переменной. Один поток (первый поток) в автоматическом режиме постоянно увеличивает переменную **counter** на единицу, при этом занимая эту переменную на целую секунду. Этот первый поток дает второму доступ к переменной **count** только на 10 миллисекунд, затем снова занимает ее на секунду. Во втором потоке предлагается ввести новое значение для переменной с терминала.
Если бы мы не использовали технологию «мьютекс», то какое значение было бы в глобальной переменной, при одновременном доступе двух потоков, нам не известно. Так же во время запуска становится очевидна разница между **pthread\_mutex\_lock()** и **pthread\_mutex\_trylock()**.
Компилировать код нужно с дополнительным параметром **-lpthread**:
```
$ gcc -o mutex -lpthread mutex.c
```
Запускаем и меняем значение переменной просто вводя новое значение в терминальном окне:
```
$ ./mutex
Enter the number and press 'Enter' to initialize the counter with new value anytime.
1
2
3
30 <--- новое значение переменной
Mutex is already locked by another process.
Let's lock mutex using pthread\_mutex\_lock().
New value for counter is 30
31
32
33
1 <--- новое значение переменной
Mutex is already locked by another process.
Let's lock mutex using pthread\_mutex\_lock().
New value for counter is 1
2
3
```
### Вместо заключения
В следующих статьях я хочу рассмотреть технологии d-bus и RPC. Если есть интерес, дайте знать.
Спасибо.
**UPD:** Обновил 3-ю главу про семафоры. Добавил подглаву про мьютекс. | https://habr.com/ru/post/122108/ | null | ru | null |
# Левитрон на Arduino
Добрый вечер! В этой публикации я расскажу о своей маленькой самоделке, задумал которую я достаточно давно.
Некоторое время назад я прочитал статью об интересных устройствах – [левитронах](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%B2%D0%B8%D1%82%D1%80%D0%BE%D0%BD), которые бывают как чисто механическими, так и с электронным управлением.
Естественно, захотел собрать себе такую игрушку, но, поискав в интернете, к своему удивлению обнаружил(по крайней мере на тот момент), что большинство схем были исключительно аналоговыми. Так как в аналоговой технике я понимаю мало, решил «изобрести» левитрон заново. Для экспериментов под рукой оказался Arduino Uno. Заказал в Китае линейный датчик Холла (что такое [эффект Холла](https://ru.wikipedia.org/wiki/%DD%F4%F4%E5%EA%F2_%D5%EE%EB%EB%E0)), а именно UGN3503UA, насобирал некоторое количество старых трансформаторов для намотки пробных катушек и приступил к экспериментам.
Вот что из этого получилось:
Как это работает. В нижней части катушки по центру установлен датчик Холла, измеряющий расстояние до неодимового магнита, который приклеен к «левитирующей» пробке. Датчик имеет три вывода — питание 5В и аналоговый выход, который подключен к АЦП Arduino.
Управляющая соленоидом схема собрана на полевом транзисторе.
Соленоид подключен к выводам J1, контакт 1 разъема J2 к ШИМ Arduino. Подключение датчика Холла к входу АЦП на схеме нет, но сложностей тут никаких быть не должно.
Количество витков катушки сказать не могу, так как в ходе экспериментов изготовил 3 или 4 катушки, мотал по принципу «сколько провода еще осталось на трансформаторе». Остальные параметры: сопротивление катушки около 12Ом, диаметр 30 мм, высота 10 мм, толщина провода 0,3 мм, катушка без сердечника.
Прошивка в первом варианте была крайне проста, при выходе значения из допустимого диапазона, схема или отключается или включается на полную мощность, на видео выше устройство как раз работает по такому алгоритму. В следующей версии прошивки МК пытается плавно регулировать напряжение на соленоиде, в результате чего снизилась склонность к возникновению колебаний в системе.
**Прошивка**
```
#define sensorPin A0
#define pwmPin 6
int sensorValue = 0;
int levitPoint = 370;
int deltaLevit = 5;
int maxL, minL;
byte induction = 128;
void setup()
{
pinMode(pwmPin, OUTPUT);
maxL = levitPoint - deltaLevit;
minL = levitPoint + deltaLevit;
}
int sensorRead(int sensorPin)
{
int s = 0;
for(byte i =0; i < 5; i++) {s += analogRead(sensorPin);}
return s/5;
}
void loop()
{
sensorValue = sensorRead(sensorPin);
if (sensorValue < 490)
{
if (sensorValue < maxL) induction = 0;
if (sensorValue > minL) induction = 250;
if (sensorValue >= maxL and sensorValue <= minL) induction = ((sensorValue - maxL)*25);
} else induction = 0;
analogWrite(pwmPin, induction);
}
```
Питается схема от 12В, датчик запитан от встроенного стабилизатора Arduino. Потребление в максимальном режиме около одного ампера, в режиме висения 0.3-0.4 А.
Устройство заработало, но дольше одной минуты пока работать опасно, транзистор сильно нагревается, греется также и катушка, вплоть до расплавления клея (все собрано на термоклее).
Планирую в дальнейшем переделать соленоид и перевести схему на питание от 5 вольт, поставить более мощный транзистор, с радиатором. Ну и заменить Arduino на ATiny. Не помешает также поставить на входные цепи конденсатор большой емкости, или даже батарею конденсаторов для защиты блока питания (первый блок питания на 1,5А, сгорел через 10 секунд работы от скачков нагрузки).
На этом, пожалуй, закончу, спасибо за внимание. | https://habr.com/ru/post/255647/ | null | ru | null |
# .NET nanoFramework — платформа для разработки приложений на C# для микроконтроллеров
[](https://habrastorage.org/webt/pv/9y/ln/pv9yln6jimphiuxpkn0c3ez2_98.png)
[.NET nanoFramework](https://nanoframework.net/) — это бесплатная платформа с открытым исходным кодом, основанная на .NET и предназначена для малых встраиваемых устройств, микроконтроллеров. С ее помощью можно разрабатывать различные устройства для Интернета вещей, носимые устройства, научные приборы, робототехнические устройства, можно создавать прототипы и даже использовать на промышленном оборудование.
.NET nanoFramework является малой версией «большого» .NET Framework предназначенного для настольных систем. Разработка приложений ведется на языке C# в среде разработки Visual Studio. Сама платформа является исполнительной средой .NET кода, это позволяет абстрагироваться от аппаратного обеспечения и дает возможность переносить программный код с одного микроконтроллера на другой, который тоже поддерживает .NET nanoFramework. Программный код на C# для настольных систем, без изменений или с небольшой адаптацией (необходимо помнить про малый объем оперативной памяти) исполнится на микроконтроллере. Благодаря этому, разработчики на .NET с минимальными знаниями в области микроэлектроники смогут разрабатывать различные устройства на .NET nanoFramework.
В свое время подход создание программ для микроконтроллеров в стиле Arduino совершил революцию и существенно снизил порог вхождения в область разработки устройств, дав возможность многим гикам по всему миру разрабатывать свои устройства от погодных станций до систем управления умным домом и т.д.
.NET nanoFramework, следующий шаг в этом направлении, потому что в себе сочетает гибкость, высокую функциональность, и высокую производительностью, стирая грань между разработчиком настольных систем и разработчиком для встраиваемых систем.
Подход использования языков программирования высокого уровня с сочетанием высокой абстракцией аппаратного обеспечения существенно расширяет круг потенциальных разработчиков и сильно снижает стоимость разработки устройства с точки зрения затрат человеко-часов и отсутствия необходимости долгого процесса обучения разработчика.
**Особенности .NET nanoFramework:**
* Может работать на 32- и 64-разрядных микроконтроллерах ARM, с наличием всего 256 КБ флэш-памяти и 64 КБ ОЗУ.
* Работает нативно на чипе, в настоящее время поддерживаются устройства ARM Cortex-M и ESP32.
* Поддерживает самые распространенные интерфейсы такие как :GPIO, UART, SPI, I2C, USB, networking.
* Обеспечивает встроенную поддержку многопоточности.
* Включает функции управления электропитанием для обеспечения энергоэффективности, например, устройств работающих от аккумуляторных батарей.
* Поддерживает совмещение управляемого кода на C# и неуправляемого кода на C/C++ в одном проекте.
* Автоматическая сборка мусора благодаря сборщику мусора.
**В сравнение с другими платформами:**
* Доступен интерактивный отладчик при запуске кода на самом устройстве с точками останова.
* Есть развитая и бесплатная среда программирования с Microsoft Visual Studio.
* Поддержка большого количества недорогих плат от различных производителей, включая: платы Discovery и Nucleo от ST Microelectronics, Quail от Mikrobus, Netduino от Wilderness Labs, ESP32 DevKit C, Texas Instruments CC3220 Launchpad, CC1352 Launchpad и NXP MIMXRT1060-EVK.
* Легко переносится на другие аппаратные платформы и устройства на ОС RTOS . В настоящее время совместимость обеспечивается в соответствие с CMSIS и ESP32 FreeRTOS.
* Полностью бесплатное решение с открытым исходным кодом, никаких скрытых лицензионных отчислений. От основных компонентов до утилит, используемых для создания, развертывания, отладки и компонентов IDE.
Предыстория
===========
Вначале было Слово и было это Слово [**.NET Micro Framework**](http://netmf.github.io/) от компании Micrsoft. До появления .NET nanoFramework, в Microsoft любительский проект перерос в серьезную платформу .NET Micro Framework, которая быстро завоевала популярность на американском рынке. Такая компания [GHI Electronics](https://www.ghielectronics.com) с 2008 года, построила весь свой бизнес на разработке микроконтроллеров и решений на базе .NET Micro Framework. В портфолио GHI Electronics были небольшие микроконтроллеры в стиле Arduino — FEZ Domino и весьма производительные с несколькими мегабайтами ОЗУ (для микроконтроллеров это весьма круто).
**Микроконтроллеры компании GHI Electronics**
[](https://habrastorage.org/webt/yf/xf/dc/yfxfdctl9ga3lq7ozggmzsinqtu.png)
Устройства могли работать практически с любой периферией, была поддержка стека TCP/IP, WiFI, обновления по воздуху. Была даже ограниченная реализация СУБД SQLite, поддержка USB Host и USB Client. Не трудно понять что компания быстро смогла себе сделать имя, стать основным разработчикам решений на .NET Micro Framework, продукцию которой постановляют во все страны мира.
В 2014 г. в проекте [Школьный звонок на .NET Micro Framework с удаленным управлением](https://habr.com/ru/post/246853/) мною использовалась плата FEZ Domino от GHI Electronics. Так же было и множество других проектов таких как [Netduino](https://ru.wikipedia.org/wiki/Netduino).
**FEZ Domino**
[](https://habrastorage.org/webt/i3/aw/tz/i3awtzotx1cz0ozs7m0kfdsgvxs.jpeg)
В октябре 2015 года на GitHub был опубликован [релиз .NET Micro Framework v4.4](https://github.com/NETMF/netmf-interpreter/releases/tag/v4.4-RTW-20-Oct-2015), этот релиз оказался последним. Компании Micrsoft отказалась дальше развивать платформу, с этого момента начинает свою историю проект nanoFramework (с 2017 года), в основе которого кодовая база .NET Micro Framework. Многие основные библиотеки были полностью переписаны, некоторые перенесены как есть, было проведено множество чисток и улучшений кода. Энтузиасты встраиваемых систем, гики увлеченные программированием, возродили платформу!
Работа над платформой ведется в основном в свободное время. Некоторые из основных участников работают в компаниях, которые активно спонсируют .NET nanoFramework и предлагают свои рабочие часы для продвижения проекта. Если вы используете .NET nanoFramework как часть своего продукта или просто хотите его поддержать, можете сделать пожертвование. Это позволяет оплачивать затраты на инфраструктуру и уделять больше времени на реализацию проекта.
Архитектура платформы
=====================
Платформа включает в себя уменьшенную версию .NET Common Language Runtime (CLR) и подмножество библиотек базовых классов .NET вместе с наиболее распространенными API-интерфейсами, включенными в универсальную платформу Windows (UWP). В текущей реализации, .NET nanoFramework работает поверх [ChibiOS](http://www.chibios.org/dokuwiki/doku.php) которая поддерживается, некоторыми платами ST Microelectronics, Espressif ESP32, Texas Instruments CC3220 Launchpad, CC1352 Launchpad и NXP MIMXRT1060-EVK. Разработка ведется в Microsoft Visual Studio или Visual Studio Code, отладка производится непосредственно на устройстве в интерактивном режиме.
#### Общая архитектура
Для того чтобы эффективно писать код на C # на микроконтроллере, необходимо понимать (на высоком уровне), как это работает. Весь код в микроконтроллере делится на 4 логических компонента, как показано ниже:
[](https://habrastorage.org/webt/pf/9m/i7/pf9mi7c3ox79is3hbxl0fn0ex78.png)
На самом высоком уровне находится ваше приложение на C #, которое необходимо запускать на MCU. Ниже располагается уровень CLR, исполнительная среда для нашей программы. Загрузчик — базовый компонент любого микроконтроллера, запускает среду CLR при включении MCU. Наконец, на самом низком уровне у нас есть MCU.
Для использования .NET nanoFramework необходимо загрузить среду nanoCLR на микроконтроллер. После этого приложение на C#, скомпилированное в виде бинарного файла, можно загружать на микроконтроллер.
#### Схема архитектуры .NET nanoFramework
[](https://habrastorage.org/webt/kd/ct/tc/kdcttcaknv33skxa74tn2gv7uwu.png)
nanoCLR базируется на слое аппаратной абстракции (HAL). HAL предоставляет абстракцию устройств и стандартизует методы и функции работы с устройствами. Это позволяет использовать наборы функций которые одинаковы доступны на уровне абстракции платформы (PAL) и конкретных драйверов. Среда nanoCLR построена на PAL и содержит некоторые ключевые библиотеки, такие как **mscorlib** (System и несколько других пространств имен), которые всегда используются. Модульность .NET nanoFramework позволяет добавлять пространства имен (namespaces) и классы, связанные с nanoCLR.
ChibiOS
=======
[ChibiOS/RT](https://www.chibios.org/dokuwiki/doku.php) — компактная многозадачная операционная система реального времени (ОСРВ). Предназначена для встраиваемых приложений, работающих в реальном времени. Эта ОСРВ отличается высокой мобильностью, компактными размерами и, главным образом имеет свою собственную уникальную архитектуру, которая как никак подходит для быстрого и эффективного переключения контекста.
Основные характеристики:
* Эффективное и портативное ядро.
* Лучшая в своем классе реализация переключения контекста.
* Множество поддерживаемых платформ.
* Статичная архитектура — все статически выделяется во время компиляции.
* Динамические расширения — динамические объекты поддерживаются как дополнительный слой надстройки статичного ядра.
* Богатый набор примитивов для ОСРВ: потоки (threads), виртуальные таймера (virtual timers), семафоры (semaphores), мьютексы (mutexes), переменные условия/синхронизации (condition variables), сообщения (messages), очереди (queues), флаги событий (event flags) и почтовый ящик (mailboxes).
* Поддержка алгоритма наследования для мьютексов.
* HAL-компонент поддержки различных абстрактных драйверов устройств: порт, последовательный порт, ADC, CAN, I2C, MAC, MMC, PWM, SPI, UART, USB, USB-CDC.
* Поддержка внешних компонентов uIP, lwIP, FatFs.
* Инструментарий для отладки ОСРВ
Поддерживаемые платформы:
* ARM7, ARM9
* Cortex-M0, -M0+, -M3, -M4, -M7
* PPC e200zX
* STM8
* MSP430
* AVR
* x86
* PIC32
Области применения ChibiOs/RT:
* Автомобильная электроника.
* Робототехника и промышленная автоматика.
* Бытовая электроника.
* Системы управления электроэнергией.
* DIY.
ChibiOS/RT также был портирована на Raspberry Pi, и были реализованы следующие драйверы устройств: порт (GPIO), Seral, GPT (универсальный таймер), I2C, SPI и PWM.
Поддерживаемые устройства
=========================
Поддерживаемые устройства делятся на две категории: основные платы и поддерживаемые сообществом.
Основные платы:
* ESP32 WROOM-32, ESP32 WROOM-32D, ESP32 WROOM-32U, ESP32 SOLO-1
* ESP-WROVER-KIT, ESP32 WROVER-B, ESP32 WROVER-IB
* STM32NUCLEO-F091RC
* STM32F429IDISCOVERY
* STM32F769IDISCOVERY
* OrgPal PalThree
* CC1352R1\_LAUNCHXL
* CC3220SF\_LAUNCHXL
* MIMXRT1060 Evalboard
* Netduino N3 WiFi
Платы поддерживаемые сообществом:
* ESP32 ULX3S
* STM32NUCLEO144-F746ZG
* STM32F4DISCOVERY
* TI CC1352P1 LAUNCHXL
* GHI FEZ cerb40 nf
* I2M Electron nf
* I2M Oxygen
* ST Nucleo 144 f439zi
* ST Nucleo 64 f401re/f411re nf
* STM NUCLEO144 F439ZI board
* QUAIL
Пример программы
================
Примеры кода представлены в разделе nanoframework/Samples. Рассмотрим базовый пример, [Blinky](https://github.com/nanoframework/Samples/tree/master/samples/Blinky) — пример программы позволяющей мигать встроенным светодиодом на плате **ESP32-WROOM**:
```
using System.Device.Gpio;
using System;
using System.Threading;
namespace Blinky
{
public class Program
{
private static GpioController s_GpioController;
public static void Main()
{
s_GpioController = new GpioController();
// ESP32 DevKit: 4 is a valid GPIO pin in, some boards like Xiuxin ESP32 may require GPIO Pin 2 instead.
GpioPin led = s_GpioController.OpenPin(4,PinMode.Output);
led.Write(PinValue.Low);
while (true)
{
led.Toggle();
Thread.Sleep(125);
led.Toggle();
Thread.Sleep(125);
led.Toggle();
Thread.Sleep(125);
led.Toggle();
Thread.Sleep(525);
}
}
}
}
```
Программный код простой и понятный. Не требуется никаких детальных знаний аппаратной платформы, все что нужно знать, это распиновку платы. Вначале кода объявляется глобальный объект **GpioController**, затем устанавливается контакт с номером 4 на вывод, после этого в коде идет простое инверсное переключение состояния. Это все что требуется знать.
Что сейчас доступно из коробки?
===============================
Аппаратные интерфейсы:
* Windows.Devices.WiFi — работа с Wi-Fi сетью.
* nanoFramework.Devices.Can — работа с CAN шиной. CAN (Controller Area Network) — стандарт промышленной сети, ориентированный, прежде всего, на объединение в единую сеть различных исполнительных устройств и датчиков. Используется прежде всего в автомобилях.
* 1-Wire — 1-Wire интерфейс, используется для подключения одного/нескольких температурных датчиков DS18B20.
* Windows.Devices.I2c, System.Device.I2c — I2C шина для подключения нескольких устройств.
* Windows.Devices.Spi — SPI шина.
* Windows.Devices.Adc — аналого-цифровой преобразователь (АЦП).
* Windows.Devices.Pwm — широтно-импульсная модуляция (ШИМ).
* System.Devices.Dac - цифро-аналоговый преобразователь (ЦАП).
Классы:
* Windows.Devices.SerialCommunication — работа с последовательным интерфейсом.
* MQTT — MQTT клиент, порт популярной библиотеки M2Mqtt. Библиотека предназначена для отправки коротких сообщений, используется для Интернета вещей и M2M взаимодействия.
* System.Net.Http.Server и System.Net.Http.Client — готовые классы Web-сервера и Web-клиента с поддержкой TLS/SSL.
* Json — работа с данными в формате Json.
* nanoFramework.Graphics — библиотека работы с отображения графических примитивов на LCD-TFT дисплеях.
* System.Collections — коллекции объектов.
* Discord bot — реализация Discord бота.
* Json Serializer and Deserializer — Json сериализацияя/десериализация.
Сетевые протоколы:
* AMQP.Net Lite — Облегченная версия открытого протокола AMQP 1.0 для передачи сообщений между компонентами системы. Основная идея заключается в том, что отдельные подсистемы (или независимые приложения) могут обмениваться произвольным образом сообщениями через AMQP-брокера, который осуществляет маршрутизацию, гарантирует доставку, распределяет потоки данных, предоставляет подписку на нужные типы сообщений. Используется в инфраструктуре Azure, поддерживает шифрование TLS.
* SNTP — протокол синхронизации времени по компьютерной сети.
Библиотеки классов
==================
В таблице представлена общая организация библиотек классов .NET nanoFramework. Приведенные ниже примеры относятся к ChibiOS (которая в настоящее время является эталонной реализацией .NET nanoFramework):
| | |
| --- | --- |
| **Библиотека класса** | **Название Nuget пакета** |
| Base Class Library (also know as mscorlib) | nanoFramework.CoreLibrary |
| nanoFramework.Hardware.Esp32 | nanoFramework.Hardware.Esp32 |
| nanoFramework.Runtime.Events | nanoFramework.Runtime.Events |
| nanoFramework.Runtime.Native | nanoFramework.Runtime.Native |
| nanoFramework.Runtime.Sntp | nanoFramework.Runtime.Sntp |
| Windows.Devices.Adc | nanoFramework.Windows.Devices.Adc |
| Windows.Devices.I2c | nanoFramework.Windows.Devices.I2c |
| Windows.Device.Gpio | nanoFramework.Windows.Devices.Gpio |
| Windows.Devices.Pwm | nanoFramework.Windows.Devices.Pwm |
| Windows.Devices.SerialCommunication | nanoFramework.Windows.Devices.SerialCommunication |
| Windows.Devices.Spi | nanoFramework.Windows.Devices.Spi |
| Windows.Devices.WiFi | nanoFramework.Windows.Devices.WiFi |
| Windows.Networking.Sockets | nanoFramework.Windows.Networking.Sockets |
| Windows.Storage | nanoFramework.Windows.Storage |
| Windows.Storage.Streams | nanoFramework.Windows.Storage.Streams |
| System.Net | nanoFramework.Windows.System.Net |
Все дополнительные пакеты добавляются с помощью системы Nuget, как это принято в .NET Core.
Unit-тестирование
=================
[](https://habrastorage.org/webt/ow/z-/aq/owz-aqpwgscybsi2qnoeyxkablm.png)
Тестирование настольного приложения на рабочей станции не вызывает никаких проблем, но все обстоит иначе, если необходимо тестировать приложение для микроконтроллера. Исполнительная среда должна быть эквивалентна по характеристикам микроконтроллеру. В Unit тестирование кода на C#, используется концепция **Адаптера (Adapter)**. Для тестовой платформы Visual Studio (vstest) был разработан специальный компонент **nanoFramework.TestAdapter**. В нем реализовано, два интерфейса для детального описания конфигурации и третий для описания специфических параметров, таких как time out, в зависимости от целевой среды исполнения, на реальном оборудование или в Win32 nanoCLR. Механизм проведения тестов на Win32 nanoCLR и реальном оборудовании, одинаков. Единственное отличие — это консоль вывода, которая в случае реального оборудования отправляет данные в порт отладки.
Один из интерфейсов называется **ITestDiscoverer**, который используется Visual Studio для сбора возможных тестов. vstest вызовет адаптер для любой запущенной сборки и передаст бинарный файл dll или exe, соответствующую определенному условию сборки (пока у нас нет TFM, и мы используем небольшой хак и основной .NET Framework 4.0 ). Затем nanoFramework **TestAdapter** анализирует каталоги, чтобы найти nfproj, анализируя файлы cs, глядя на определенные атрибуты **Test**, определенные для nanoFramework. На основе этого составляется список, который передается обратно.
Этот хак выполняется с помощью файла с расширением **.runsettings** с необходимым минимумов элементов ( для запуска приложения в Win32 nanoCLR, параметр **IsRealHardware** необходимо выставить в false, в случае реального устройства — true):
[](https://habrastorage.org/webt/2b/yr/ol/2byrolfr3c6x54l7ke63qisnfrk.png)
Когда выполняется сборка проекта отрабатывает триггер интерфейс **ITestExecutor**. В случае, если вы работаете в контексте Visual Studio, передается список тестов (индивидуальный или полный список), и именно здесь запускается **nanoFramework.nanoCLR.Win32.exe** как процесс, передающий nanoFramework.UnitTestLauncher.pe, mscorlib.pe, nanoFramework.TestFramework.pe и, конечно же, тестовую библиотеку для исполняемого файла.
nanoFramework Unit Test загрузит тестовую сборку и выполнит тесты с начиная с первого — Setup, затем TestMethod и, наконец, тесты Cleanup.
Выходные данные этого процесса перенаправляются в **TestAdapter**, которые затем разбираются. Важное примечание: UnitTestLauncher необходимо собрать и развернуть при отладке! В противном случае он никогда не сможет ничего вывести в консоль. Чтобы запустить тест на реальном оборудование, нужно просто добавить строку ввода в файл runsettings, как указано выше.
По окончании выполнения тестов, возвращается статусы. Простой строковый вывод со статусом теста, имени метода и времени его выполнения и/или исключение. Тест пройден: MethodName, 1234 или Test failed: MethodName, подробное исключение. Это передается обратно в vstest, а затем отображается в Visual Studio.
Для Unit-тестирования необходимо в проект добавить NuGet пакет nanoFramework.TestFramework. Или использовать готовый проект для Unit-тестирования в Visual Studio, это самый простой способ! Он автоматически добавит в проект NuGet и .runsettings.
Лицензирование
==============
Весь исходный код .NET nanoFramework распространяется по лицензией MIT, включая nf-interpreter, классы библиотек, расширение Visual Studio и все сопутствующие утилиты.
Немного сложнее обстоит с лицензированием ChibiOS. Для персональных проектов ChibiOS бесплатна, при этом свой код не обязательно открыто публиковать, это может быть закрытый проект.
Для коммерческого использования ChibiOS, необходимо приобретать лицензию. Так же можно лицензировать отдельные компоненты.
Но если количество выпущенных коммерческих устройств с ChibiOS не превышает 500 ядер, то оплачивать лицензию не требуется. Свыше этого объема приобретаются пакеты лицензий на 500, 1000, 5000 ядер или неограниченно. При бесплатном коммерческом использование некоторые функции недоступны и в своем продукте необходимо «реализовать» рекламу ChibiOS.
Управляемые приложения managed apps (C#) запущенные на .NET nanoFramework не компилируются и не собираются ChibiOS, а интерпретируются «на лету». Поэтому рассматриваются как отдельный компонент от встроенного ПО. Таким образом, схема лицензирования ChibiOS не распространяется на приложения C#, и не зависит от условий лицензирования ChibiOS.
Использование в промышленном сфере
==================================
Американская компания [OrgPal.Iot](https://www.orgpal.com/) специализируется на аппаратных и программных решениях для Интернета вещей (IOT), которые осуществляют сбор данных телеметрии для отдаленнейшего анализа, управление инфраструктурой через частное облако. Компания предоставляет конечные устройства и шлюзы для передачи данных на рабочие станции, сервера и мобильные устройства. Решения совместимы с Azure IoT.
Основные направление компании это мониторинг инфраструктуры:
* Промышленного производства
* Нефтяных месторождений
* Панелей солнечных электростанций
* Систем управления электропитанием
Одно из разработанных устройств компании это PalThree. [PalThree](https://www.orgpal.com/palthree-iot-azure) — сертифицированное устройство Azure IoT Ready Gateway & Edge Point для сбора данных и телеметрии с последующей передачей в облако Azure IoT. На борту большой набор входных интерфейсов для получения данных о технологических процессах. Устройство основано на STM32 ARM 4 и ARM 7, поставляется в двух вариантах с микроконтроллерами STM32F469x и STM32F769x, с 1 МБ SDRAM на плате, флэш-памятью SPI и QSPI. Программное обеспечение основано на .NET nanoFramework, с ChibiOS для STM32.
**Как это работает**
[](https://habrastorage.org/webt/gh/2i/7r/gh2i7rhokusok3eujfbvygxejme.png)
Устройство [PalThree](https://www.orgpal.com/palthree-iot-azure) — используется для частого и точного мониторинга нефтегазовых месторождений. Выбор был обусловлен необходимостью использования простого решения с возможностью интеграции с сотнями датчиков. Многие компании использую различные дорогостоящие решения, это приводит к большой стоимости обслуживания и увеличивает время перестройки инфраструктуры. .NET nanoFramework — для данных задач подходит как никак лучше из-за высокой скорости разработки решений и легкости интеграций различных интерфейсов.
**Цистерны для хранения нефтегазовых продуктов**
[](https://habrastorage.org/webt/-e/ji/p2/-ejip2bhbtbyhu0swfy3depnyoy.jpeg)
**Шкаф с PalThree**
[](https://habrastorage.org/webt/to/_1/4t/to_14t0h9kfoipkb4clikb-ue7m.jpeg)
Web-сервер с поддержкой: REST api, многопоточности, параметров в URL запросе, статических файлов.
=================================================================================================
Специально для .NET nanoFramework, Laurent Ellerbach разработал библиотеку nanoFramework.WebServer, которая по своей сути является «упрощенной версией» ASP.NET.
Возможности Web-сервера:
* Обработка многопоточных запросов
* Хранение статических файлов на любом носителе
* Обработка параметров в URL запросе
* Возможность одновременной работы нескольких веб-серверов
* Поддержка команд GET/PUT и любых другие
* Поддержка любого типа заголовка http-запроса
* Поддерживает контент в POST запросе
* Доступно использование контроллеров и маршрутизации
* Хелперы для возврата кода ошибок, для REST API
* Поддержка HTTPS
* Декодирование/кодирование URL
Ограничение: не поддерживает компрессию ZIP в запросе и ответе.
Для использования Web-сервера необходимо просто указать порт и добавить обработчик запросов:
```
using (WebServer server = new WebServer(80, HttpProtocol.Http)
{
// Add a handler for commands that are received by the server.
server.CommandReceived += ServerCommandReceived;
// Start the server.
server.Start();
Thread.Sleep(Timeout.Infinite);
}
```
Так же, можно передать контроллер, например **ControllerTest**, и будет использоваться декоратор для маршрутизации и методов:
```
using (WebServer server = new WebServer(80, HttpProtocol.Http, new Type[] { typeof(ControllerPerson), typeof(ControllerTest) }))
{
// Start the server.
server.Start();
Thread.Sleep(Timeout.Infinite);
}
```
В следующем примере, определяется маршрут «test» и т.д., в котором определяется метод GET, и «test/any»:
```
public class ControllerTest
{
[Route("test"), Route("Test2"), Route("tEst42"), Route("TEST")]
[CaseSensitive]
[Method("GET")]
public void RoutePostTest(WebServerEventArgs e)
{
string route = $"The route asked is {e.Context.Request.RawUrl.TrimStart('/').Split('/')[0]}";
e.Context.Response.ContentType = "text/plain";
WebServer.OutPutStream(e.Context.Response, route);
}
[Route("test/any")]
public void RouteAnyTest(WebServerEventArgs e)
{
WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.OK);
}
}
```
Функция **RoutePostTest** будет вызываться каждый раз, когда вызываемый URL-адрес будет test, Test2, tEst42 или TEST, URL-адрес может быть с параметрами и методом GET. **RouteAnyTest** вызывается всякий раз, когда URL-адрес является test/any, независимо от метода. По умолчанию маршруты не чувствительны к регистру, и атрибут должен быть в нижнем регистре.
Если вы хотите использовать маршруты с учетом регистра, как в предыдущем примере, используйте атрибут CaseSensitive. Как и в предыдущем примере, вы должны написать маршрут так, как вы хотите, чтобы на него ответили.
Cooming Soon
============
В продолжение к публикации, будет практическая работа с загрузкой CLR на ESP32 и Nucleo, с написанием первой программы на C#.
Страница проекта [.NET nanoFramework](https://nanoframework.net/) | https://habr.com/ru/post/549012/ | null | ru | null |
# Swift 5.0. Что нового?
Swift 5 — долгожданный релиз, включающий в себя несколько десятков улучшений и исправлений. Но самой главной целью релиза Swift 5.0 было достижение ABI стабильности. В этой статье вы узнаете, что такое ABI и что стабильный ABI даст iOS/macOS разработчикам. А также проведём разбор нескольких новых фич Swift 5.
ABI Stability
=============
ABI — бинарный интерфейс приложения. ABI можно рассматривать как набор правил, позволяющих компоновщику объединять откомпилированные модули компонента.
Соответственно, в ABI описано следующее.
1. То, как происходит вызов кода из разных модулей, в том числе системных.
2. Формат передачи аргументов и получение возвращаемого значения из функций.
3. Алгоритмы лэйаута данных в оперативной памяти.
4. Управление памятью, ARC.
5. Система типов, дженерики.
Swift 5 вместе со стабильным ABI предоставляет бинарную совместимость для приложений. Бинарная совместимость для iOS/macOS приложений означает, что скомпилированные приложения будут в рантайме совместимы с системными библиотеками, скомпилированными более ранними или более поздними версиями языка. Например, приложение, скомпилированное с Swift 5.0, будет совместимо с стандартными библиотеками, скомпилированными с Swift 5.1 или Swift 6.0.
Начиная с iOS 12.2 и macOS 10.14.4, операционные системы Apple будут содержать все необходимое для запуска свифтовых приложений. Это означает, что приложения, написанные на Swift 5 и более поздних версиях, не будут содержать рантайм и стандартную библиотеку языка. Поэтому приложения, написанные на Swift 5, станут весить примерно на 3-10 мегабайт меньше.
Важно отметить, что помимо ABI stability, есть еще Module stability. Если ABI stability позволяет совмещать разные версии свифта в рантайме, то Module stability отвечает за то, как компилируются бинарные фреймворки, написанные на разных версиях языка. Module stability появится в Swift 5.1. И тогда разработчики смогут распространять свои фреймворки не только с открытым исходным кодом, но и в скомпилированном виде.
**Плюсы ABI стабильности.**
1. Приложения станут весить меньше.
2. Ускорение запуска и производительности приложений.
3. В теории, Apple может писать новые фреймворки полностью на Swift.
**Минусы ABI стабильности.**
Разработчикам придётся учитывать отсутствие в более старых версиях стандартной библиотеки какого-либо нового функционала. Например, если в iOS 13 будет встроен Swift 5.1 с какими-нибудь новыми классами/функциями в стандартной библиотеке, то при поддержке в приложении iOS 12.2 разработчики не смогут их использовать. (Нужно будет вставлять проверки #available(...) так же, как мы это делаем сейчас для Foundation, UIKit и других платформенных библиотек).
Тип Result в стандартной библиотеке
===================================
В стандартной библиотеке появился удобный способ передачи и обработки ошибок в асинхронном API. Также этот тип можно использовать в случае, если по каким-либо причинам нам не подходит стандартная обработка ошибок через try/catch.
Тип Result реализован через enum с двумя кейсами: success и failure:
```
public enum Result where Failure: Error {
case success(Success)
case failure(Failure)
...
}
```
На самом деле такой подход не нов для Swift-разработчиков. Ещё со времен первой версии Swift многие разработчики использовали похожий подход. Но теперь, когда в стандартной библиотеке появился свой Result, это упростит взаимодействие с кодом из внешних библиотек.
Пример использования в сервисе загрузок статей:
```
struct Article {
let title: String
}
class ArticleService {
func fetchArticle(id: Int64, completion: @escaping (Result) -> Void) {
// асинхронная загрузка статьи
// ...
completion(.success(Article(title: "Swift 5.0. Что нового?")))
}
}
```
А вот пример обработки полученного результата. Так как Result — это всего лишь enum, то мы можем обработать все его состояния с помощью switch:
```
articleService.fetchArticle(id: 42) { result in
switch result {
case .success(let article):
print("Success: \(article)")
case .failure(let error):
print("Failure: \(error)")
}
}
```
Raw strings
===========
В Swift 5 добавили так называемые raw strings, в которых кавычки и бэкслеш интерпретируются именно как символы, и для их использования в литерале не нужно использовать символ экранирования. Чтобы написать литерал такой строки, необходимо к двойным кавычкам по краям добавить символ #.
Пример использования кавычек:
```
// swift 4.2
print("Чтобы вывести строку в \"кавычках\" необходимо добавлять бэкслеш.")
print("Чтобы добавить переход на следующую строку, нужно использовать символы \\n")
// swift 5
print(#"В "сырой" строке не нужны бэкслеши перед кавычками"#)
print(#"Чтобы добавить переход на следующую строку, нужно использовать символы \n"#)
```
Эта фича особенно полезна при написании регулярных выражений:
```
// swift 4.2
let regex = "^\\(*\\d{3}\\)*( |-)*\\d{3}( |-)*\\d{4}$"
// swift 5
let regex = #"^\(*\d{3}\)*( |-)*\d{3}( |-)*\d{4}$"#
```
Для интерполяции строк после бэкслеша надо добавлять символ #:
```
// swift 4.2
let string = "Строка с интерполяцией \(variable)"
// swift 5
let string = #"Строка с интерполяцией \#(variable)"#
```
Более подробно можете прочитать [в этом предложении](https://github.com/apple/swift-evolution/blob/master/proposals/0200-raw-string-escaping.md).
Обновленная интерполяция строк
==============================
С помощью интерполяции строк мы можем добавить в строковый литерал значение какой-либо переменной или результат выражения. Начиная с 5-ой версии языка, появилась возможность расширять то, как наши выражения добавляются в конечную строку.
В общем случае достаточно написать расширение к структуре DefaultStringInterpolation и добавить метод с названием appendInterpolation. Например, если мы хотим добавить в строку цену в отформатированном виде:
```
extension DefaultStringInterpolation {
mutating func appendInterpolation(price: Decimal) {
let formatter = NumberFormatter()
formatter.numberStyle = .currency
if let string = formatter.string(from: price as NSDecimalNumber) {
appendLiteral(string)
} else {
appendLiteral(price.description)
}
}
}
print("Price of item: \(price: 9.99)")
// Price of item: $9.99
```
Важно отметить то, что, по сути, конструкция (price: 9.99) в строке с помощью компилятора преобразовалась в вызов метода appendInterpolation(price: Decimal).
Также в методах appendInterpolation мы можем добавить неограниченное число аргументов, как именованных, так и не именованных, с дефолтными значениями или без них.
Более подробно можно прочитать [в этом предложении](https://github.com/apple/swift-evolution/blob/master/proposals/0228-fix-expressiblebystringinterpolation.md).
Проверка кратности чисел
========================
К числовым типам в стандартной библиотеке добавлен метод проверки кратности isMultiple(of:). Да, мы всё ещё можем использовать оператор взятия остатка от деления %. Но, кажется, isMultiple(of:) выглядит более наглядно.
```
let interger = 42
if interger.isMultiple(of: 3) {
print("Кратно трем")
} else {
print("Не кратно трем")
}
```
Метод compactMapValues в Dictionary
===================================
Метод compactMapValues позволяет преобразовать значения словаря, а также отфильтровать их, если само преобразование возвратило nil.
Например, маппинг строковых ключей в тип URL:
```
let dict = [
"site": "https://www.site.ru/path/to/web/site/page",
"other site": "invalid url"
]
let mappedDict: [String: URL] = dict.compactMapValues { URL(string: $0) }
print(mappedDict)
// ["site": https://www.site.ru/path/to/web/site/page]
```
Вторая пара «ключ/значение» была удалена после маппинга, так как строка не является валидным URL’ом.
Изменение поведения try?
========================
В Swift 4.2 с помощью конструкции try? можно с лёгкостью получить опциональный тип с несколькими уровнями вложенности. В большинстве случаев это не то, чего ожидает разработчик. По этой причине в Swift 5 try? получил поведение, схожее c optional chaining. То есть при комбинации try? с optional chaining или optional casting результатом выражения будет опционал с одним уровнем вложенности.
Пример использования try? вместе с as?:
```
// Swift 4.2
let jsonDict = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
// Тип jsonDict - [String: Any]??
// Swift 5
let jsonDict = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
// Тип jsonDict - [String: Any]?
```
Пример использования try? вместе с методом опционального объекта:
```
// Swift 4.2
let article = try? storage?.getArticle()
// Тип article - Article??
// Распаковка
if let first = article, let second = first {
first // тип Article?
second // тип Article
}
// Или так
if case let value?? = article {
value // тип Article
}
// Swift 5
let article = try? storage?.getArticle()
// Тип article - Article?
// Распаковка
if let value = article {
value // тип Article
}
```
Более подробно можно прочитать [в этом предложении](https://github.com/apple/swift-evolution/blob/master/proposals/0230-flatten-optional-try.md).
Атрибут @dynamicCallable
========================
Новый атрибут @dynamicCallable позволяет пометить тип как «вызываемый». Это означает, что мы сможем вызвать тип как обычный метод.
Если мы помечаем тип как @dynamicCallable, то должны реализовать один (или оба) из методов:
```
func dynamicallyCall(withArguments: <#Arguments#>) -> <#R1#>
func dynamicallyCall(withKeywordArguments: <#KeywordArguments#>) -> <#R2#>
```
Тип Arguments должен поддерживать протокол ExpressibleByArrayLiteral, тип KeywordArguments должен поддерживать протокол ExpressibleByDictionaryLiteral, а R1 и R2 могут быть любыми типами.
Например, структура Sum. При её вызове можно передать любое количество чисел и получить их сумму:
```
@dynamicCallable
struct Sum {
func dynamicallyCall(withArguments args: [Int]) -> Int {
return args.reduce(0, +)
}
}
let sum = Sum()
let result = sum(1, 2, 3, 4)
print(result) // 10
```
По сути, компилятор преобразует sum(1, 2, 3, 4) в вызов sum.dynamicallyCall(withArguments: [1, 2, 3, 4]). Аналогично для метода dynamicallyCall(withKeywordArguments:).
Эта фича позволит добавить взаимодействие Swift кода с различными динамическим языками программирования, например, Python или JavaScript.
Более подробно можно прочитать [в этом предложении](https://github.com/apple/swift-evolution/blob/master/proposals/0216-dynamic-callable.md).
Поддержка оператора «меньше» в директивах проверки версии компилятора и языка
=============================================================================
Начиная с 5-ой версии Свифта можно использовать оператор «меньше» при проверках версии компилятора в коде:
```
// Swift 4.2
#if !swift(>=5)
// Этот код будет скомпилирован только для свифт 4.2 и меньше
#endif
// Swift 5
#if swift(<5)
// Этот код будет скомпилирован только для свифт 4.2 и меньше
#endif
```
Заключение
==========
Это не все возможности и улучшения появившиеся в Swift 5. Всего было принято 28 предложений от комьюнити, также включающие в себя повышение производительности строк, улучшения Swift Package Manager и стандартной библиотеки. Полный список изменений и улучшений можно посмотреть [в release notes](https://developer.apple.com/documentation/xcode_release_notes/xcode_10_2_release_notes/swift_5_release_notes_for_xcode_10_2). | https://habr.com/ru/post/444862/ | null | ru | null |
# Группировка вебсокет соединений для асинхронного фреймворка Starlette
Cегодня мы с вами напишем решение для фреймворка Starlette, которое позволит группировать открытые вебсокет соединения.
### Вступление
[Starlette](https://www.starlette.io/) довольно молодой фреймворк, и какие-то «плюшки» для него приходится писать самостоятельно. [В предыдущей статье](https://habr.com/ru/post/502814/) я показал как можно реализовать JWT сессии и «Djangoподобную» структуру, сегодня мы рассмотрим как группировать вебсокет соединения.
### Для чего нужна группировка вебсокет cоединений?
Допустим я и мой друг (назовем его UnnamedUser) решили пообщаться в чате.
Когда я захожу в комнату с ID=1, **мой браузер** устанавливает первое вебсокет соединение с сервером (для упрощения назовем его «канал 1»\*).
Когда UnnamedUser заходит в комнату с ID=1, **его браузер** устанавливает второе вебсокет соединение с сервером (для упрощения назовем его «канал 2»\*).
*\* далее по тексту вебсокет соединение будет называться каналом*
> Технически «канал 1» и «канал 2» это два разных объекта класса [WebSocketEndpoint](https://github.com/encode/starlette/blob/master/starlette/endpoints.py), поэтому в чате мы видим только свои сообщения, а не сообщения других участников (как ожидалось).
Чтобы решить эту проблему нам необходимо объединить наши каналы в группу (к примеру **room\_1**) и делать массовые рассылки при наступлении какого либо события (к примеру кто-то написал в чат).
### Где хранить группы?
Для хранения групп создадим класс **ChannelGroups** и объявим глобально его экземпляр:
```
import time
import uuid
from simple_print.functions import sprint_f
from starlette.endpoints import WebSocketEndpoint
class ChannelGroups:
def __init__(self):
self.created = time.time()
_CHANNEL_GROUPS = {}
created = None
async def group_send(self, group, payload):
self.clean_expired()
for channel in self._CHANNEL_GROUPS.get(group, {}):
await channel.send(payload)
def groups_show(self):
if self._CHANNEL_GROUPS:
for group in self._CHANNEL_GROUPS:
sprint_f(f"\n{group}", "green")
for channel in self._CHANNEL_GROUPS.get(group, {}):
sprint_f(channel, "cyan")
if channel.is_expired():
sprint_f("expired", "red")
else:
sprint_f("Channel groups is empty", "yellow")
def groups_flush(self):
self._CHANNEL_GROUPS = {}
def group_add(self, group, channel):
self._CHANNEL_GROUPS.setdefault(group, {})
self._CHANNEL_GROUPS[group][channel] = ""
def remove_channel(self, channel):
for group in self._CHANNEL_GROUPS:
if channel in self._CHANNEL_GROUPS[group]:
del self._CHANNEL_GROUPS[group][channel]
if not any(self._CHANNEL_GROUPS[group]):
del self._CHANNEL_GROUPS[group]
def clean_expired(self):
for group in self._CHANNEL_GROUPS:
for channel in self._CHANNEL_GROUPS.get(group, {}):
if channel.is_expired():
del self._CHANNEL_GROUPS[group][channel]
if not any(self._CHANNEL_GROUPS[group]):
del self._CHANNEL_GROUPS[group]
channel_groups = ChannelGroups()
```
### Унаследуемся от WebSocketEndpoint
Чтобы добавить для открытых соединений связь с **channel\_groups** нам необходимо унаследоваться от базового класса [WebSocketEndpoint](https://github.com/encode/starlette/blob/master/starlette/endpoints.py).
Начнем с создания вспомогательного класса **Channel**:
```
class Channel:
def __init__(self, websocket, expires, encoding):
self.channel_uuid = str(uuid.uuid1())
self.websocket = websocket
self.expires = expires
self.encoding = encoding
self.created = time.time()
async def send(self, payload):
websocket = self.websocket
if self.encoding == "json":
try:
await websocket.send_json(payload)
except RuntimeError:
pass
elif self.encoding == "text":
try:
await websocket.send_text(payload)
except RuntimeError:
pass
elif self.encoding == "bytes":
try:
await websocket.send_bytes(payload)
except RuntimeError:
pass
else:
try:
await websocket.send(payload)
except RuntimeError:
pass
self.created = time.time()
def is_expired(self):
return self.expires + int(self.created) < time.time()
def __repr__(self):
return f"{self.channel_uuid}"
```
В качестве uuid (уникального идентификатора) канала мы будем использовать встроенный в Python механизм идентификации [UUID objects](https://docs.python.org/3/library/uuid.html).
Создадим основной класс **ChannelEndpoint** от которого мы будем наследоваться в наших endpoints:
```
class ChannelEndpoint(WebSocketEndpoint):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.expires = 60 * 60 * 24
self.encoding = "json"
self.channel_groups = channel_groups
async def on_connect(self, websocket, **kwargs):
await super().on_connect(websocket, **kwargs)
self.channel = Channel(websocket=websocket, expires=self.expires, encoding=self.encoding)
async def on_disconnect(self, websocket, close_code):
await super().on_disconnect(websocket, close_code)
self.channel_groups.remove_channel(self.channel)
async def group_send(self, payload):
await self.channel_groups.group_send(self.group, payload)
def get_or_create(self, group):
assert self._validate_name(group), "Invalid group name"
self.channel_groups.group_add(group, self.channel)
self.group = group
def _validate_name(self, name):
if name.isidentifier():
return True
raise TypeError("Group names must be valid python identifier only alphanumerics and underscores are accepted")
```
При инициализации мы переопределяем базовый метод WebSocketEndpoint *on\_connect*, добавляя к нему объект **Channel**.
В endpoints унаследованных от **ChannelEndpoint** появляются новые публичные методы:
* **get\_or\_create(self, group)** — для получения или создания группы
* **group\_send(self, payload)** — для отправки сообщений в каналы, которые входят в данную группу.
### Пример интеграции
```
routes = [
Route("/chat/", endpoint=ChatView)
Route("/chat/ws", endpoint=ChatChannel)
]
html = """
ws
ChannelEndpoint
===============
group\_id:
username:
message:
Send
var ws = new WebSocket("ws://localhost/chat/chat/ws");
ws.onmessage = function(event) {
console.log('Message received %s', event.data)
var messages = document.getElementById('messages');
var message = document.createElement('li');
var data = JSON.parse(event.data);
message.innerHTML = `<strong>${data.username} :</strong> ${data.message}`;
messages.appendChild(message);
};
function sendMessage(event) {
var username = document.getElementById("username");
var group\_id = document.getElementById("groupId");
var input = document.getElementById("messageText");
var data = {
"group\_id": group\_id.value,
"username": username.value,
"message": input.value,
};
console.log('Message send %s', data)
ws.send(JSON.stringify(data));
event.preventDefault();
}
"""
class ChatView(HTTPEndpoint):
async def get(self, request):
return HTMLResponse(html)
class ChatChannel(ChannelEndpoint): # наследуемся от ChannelEndpoint
async def on_receive(self, websocket, data):
group_id = data["group_id"]
message = data["message"]
username = data["username"]
if message.strip():
await self.get_or_create(group_id) # получаем группу (и все ее каналы) из словаря CHANNEL_GROUPS
payload = {
"username": username,
"message": message,
}
await self.group_send(payload) # отправляем сообщение всем участникам группы
```
### Методы ChannelGroups
В процессе эксплуатации нам понадобится отправка сообщения в группы из любого места кода, «мониторинг» групп, а также «очистка».
Отправка сообщения в группу из любого места кода:
```
from channel_box import channel_groups
await channel_groups.group_send('my_chat_1', {"username": "New User", "message": "Hello world"})
```
«Мониторинг» групп:
```
from channel_box import channel_groups
channel_groups.groups_show()
```
Очистка:
```
from channel_box import channel_groups
channel_groups.groups_flush()
```
### Установка
Менеджер пакетов pip:
```
pip install channel-box
```
[Исходный код решения](https://github.com/Sobolev5/channel-box)
\*\*UPD 2022:\*\*
channel-box дорос до версии 0.4 и теперь дружит с последними версиями Starlette.
Чат на channel-box здесь:
[channel-box.andrey-sobolev.ru](https://channel-box.andrey-sobolev.ru/) | https://habr.com/ru/post/506056/ | null | ru | null |
# 5 вещей, о которых должен знать любой разработчик Apache Kafka
Apache Kafka — это платформа потоковой обработки событий, которую используют 30% компаний из Fortune 500. У Kafka много функций, благодаря которым платформа задает стандарт обработки событий, и здесь мы поговорим о пяти самых важных аспектах, которые должны быть известны любому, кто работает с Kafka.
Некоторые аспекты связаны с производительностью, другие — с архитектурой. Надеюсь, к концу этого поста вы лучше поймете, как работает Kafka, и освоите пару новых трюков.
### 1. Гарантии надежности и доставки сообщений
`KafkaProducer` обеспечивает надежность данных с помощью параметра конфигурации `acks`. Параметр `acks` указывает, сколько подтверждений должен получить продюсер, чтобы запись считалась доставленной брокеру. Варианты значений:
`none` — продюсер считает записи успешно доставленными после их отправки на брокер. Никакого подтверждения он не ждет.
`one`— продюсер ждет от брокера лидера подтверждение того, что он занес запись в лог.
`all`— продюсер ждет подтверждения от брокера лидера и реплик.
У разных приложений разные требования, и здесь нужно найти компромисс: или это будет высокая пропускная способность, но с риском потери данных, или гарантия надежности в ущерб пропускной способности.
Давайте подробнее рассмотрим сценарий `acks=all`. Если у записи для параметра `acks` установлено all в кластере с тремя брокерами Kafka, в идеальной ситуации Kafka содержит три реплики данных — по одной на лидере и двух фолловерах. Когда у логов в каждой из трех реплик одинаковое смещение записи, они считаются *синхронизированными*. Другими словами, *синхронизированные реплики* содержат одинаковый контент для данной партиции топика. Это видно на схеме:
*В идеале лидер отправляет подтверждение продюсеру, когда сам получит
подтверждение от обоих фолловеров.*
Но у `acks=all` есть некоторые нюансы. Он не указывает, *сколько* реплик должно быть синхронизировано. Брокер лидер всегда *синхронизирован* сам с собой. В некоторых ситуациях два остальных брокера могут отставать из-за разрыва сети, нагрузки на запись и т. д. В итоге, когда продюсер успешно отправляет данные, нужное число подтверждений может поступить только от одного брокера! Если два фолловера *не синхронизированы*, продюсер все равно получает нужное число подтверждений, но только от лидера.
Например:
*Если фолловеры почему-то не могут получить данные от лидера, запрос
продюсера все равно выполняется успешно, ведь все «синхронизированные»
реплики подтвердили запись.*
Указывая `acks=all`, мы делаем ставку на надежность. Если реплики отстают, возможно, следует вызвать исключение для новых записей, пока реплики не догонят.
Если синхронизированная реплика всего одна, формально правила соблюдены, но наше намерение при этом не реализовано. При использовании параметра `acks=all` нам нужна гарантия. Успешной должна считаться отправка с большинством доступных синхронизированных брокеров.
Соответствующая конфигурация есть: `min.insync.replicas`. Конфигурация `min.insync.replicas`задает число реплик, которые должны быть синхронизированы, чтобы можно было продолжить запись. Конфигурация `min.insync.replicas` задается на уровне брокера или топика, а не для продюсера. Дефолтное значение для `min.insync.replicas` — 1. Чтобы избежать сценария, описанного выше, в кластере с тремя брокерами лучше указать 2.
Вот как это будет выглядеть на нашем примере:
*Недостаточно реплик! Если мы настроили min.insync.replicas=2 и не получили подтверждение от нужного числа реплик, запрос не выполняется.*
Если число синхронизированных реплик меньше настроенного, лидер не пытается добавить запись в свой лог. Он выдает исключение `NotEnoughReplicasException` или `NotEnoughReplicasAfterAppendException`, и продюсер снова пытается записать данные. Если реплики не синхронизированы с лидером, можно повторить попытку, что продюсер и будет делать, пока не истечет настроенный [таймаут на доставку](https://kafka.apache.org/documentation/#delivery.timeout.ms).
Если правильно настроить `min.insync.replicas` и acks для продюсера, мы повысим надежность данных.
Перейдем к следующему пункту списка — улучшения в клиентах Kafka. За последний год в API продюсера и консюмера Kafka появились фичи, о которых всем надо знать.
### 2. Новый sticky partitioner в API продюсера
Kafka использует партиции, чтобы повысить пропускную способность и распределить нагрузку по всем брокерам в кластере. Записи в Kafka хранятся в виде пары ключ-значение, где ключ может быть null. Продюсеры Kafka отправляют записи не сразу. Сначала они группируют их в батчи для конкретных партиций. Пакеты позволяют эффективнее использовать сетевые ресурсы. Partitioner выбирает партицию для записей тремя способами.
Партиция может быть явно указана в объекте ProducerRecord через перегруженный конструктор ProducerRecord. В этом случае продюсер всегда использует эту партицию.
Если партиция не указана, а у ProducerRecord есть ключ, продюсер делит хэш ключа на количество партиций. Получившееся число и будет партицией, которую использует продюсер.
Если в ProducerRecord нет ключа и партиций, раньше в Kafka использовалось распределение по кругу (round-robin). Первую запись в пакете продюсер назначал партиции 0, вторую — партиции 1 и так далее, пока партиции не кончатся. Затем продюсер снова начинал с партиции 0 и повторял этот процесс для оставшихся записей.
Примерно так:
*Батчи распределяются по партициям. При старом добром подходе round robin продюсер идет по партициям по возрастанию до максимального номера в топике, а потом опять начинает с нуля.*
Такой метод хорошо подходит для равномерного распределения записей по партициям. Но есть недостаток: в итоге мы отправляем много не до конца заполненных пакетов. Эффективнее будет отправлять меньше пакетов, но с большим числом записей. Чем меньше пакетов, тем короче очередь запросов и меньше нагрузка на брокеры.
Давайте рассмотрим упрощенный пример. Возьмем топик с тремя партициями. Для простоты предположим, что приложение создало девять записей без ключа, и все они поступают одновременно:
*Порядок назначения партиций: после партиции 2 продюсер переходит к партиции 0.
Одновременно создается девять записей.
Продюсер распределяет записи по партициям методом round robin. В итоге на брокер отправляется три батча.*
Итак, мы получили три пакета по три записи в каждом. Но будет лучше отправить один пакет с девятью записями — чем меньше пакетов, тем меньше трафика и нагрузки на брокеры.
В Apache Kafka 2.4.0 представлен [sticky partitioner](https://www.confluent.io/blog/apache-kafka-2-4-latest-version-updates#kip-480), с которым это стало возможным. Sticky partitioner не использует round robin а просто наполняет пакет для одной партиции, отправляет пакет, берет другую партицию и собирает пакет для нее. Давайте рассмотрим тот же пример, что и выше, но со sticky partitioner:
*Если мы используем sticky partitioner, первый батч отправляется в партицию 0. Второй — в партицию 1. Третий — в партицию 2, а потом опять с нуля.*
Если мы наполняем пакет только для одной партиции, мы сокращаем число запросов, а значит и нагрузку на очередь запросов и задержку во всей системе. При этом распределение записей остается равномерным, поскольку partitioner отправляет полные пакеты в партиции по очереди. Этот подход тоже можно назвать круговым, только распределение идет не запросами, а целыми пакетами.
Узнайте больше в статье [о том, какие улучшения в Apache Kafka внес sticky partitioner](https://www.confluent.io/blog/apache-kafka-producer-improvements-sticky-partitioner/), и в документации [KIP-480](https://cwiki.apache.org/confluence/display/KAFKA/KIP-480:+Sticky+Partitioner).
Перейдем к изменениям для консюмера.
### 3. Кооперативная ребалансировка групп консюмеров без stop-the-world
Kafka — это распределенная система, которая должна не только быть готовой к сбоям, но и успешно справляться с ними. Отличный пример того, как Kafka решает вопрос ожидаемого сбоя, — протокол группы консюмеров, который управляет несколькими инстансами консюмера для одного логического приложения. Если один инстанс консюмера останавливается, намеренно или случайно, Kafka выполняет *ребалансировку*, перекидывая работу на другой инстанс.
В Kafka 2.4 представлен новый протокол ребалансировки — кооперативная. Прежде чем поговорить о нем, давайте вспомним основные принципы групп консюмеров.
Предположим, у нас есть распределенное приложение с несколькими консюмерами, подписанными на один топик. Консюмеры с одинаковым group.id образуют группу консюмеров. Каждый консюмер в группе принимает сообщения от одной или нескольких партиций в топике. Партиции назначаются лидером группы консюмеров.
Вот как это работает:
Как видите, в оптимальных условиях каждый из трех консюмеров обрабатывает записи от своих двух партиций. Что будет, если в приложении возникнет ошибка или связь с сетью прервется? Обработка партиций в этом топике будет прекращена, пока вы не восстановите приложение? К счастью, *нет* — благодаря протоколу ребалансировки.
Вот еще одна иллюстрация протокола группы консюмеров в действии:
Как видите, консюмер 2 по какой-то причине молчит или превысил лимит ожидания. Координатор группы удаляет его из группы и запускает ребалансировку. Этот механизм пытается равномерно распределить (сбалансировать) рабочую нагрузку по доступным членам группы консюмеров. В этом случае, поскольку консюмер 2 выбыл, ребалансировка назначает принадлежавшие ему партиции другим активным членам группы. Как видите, если один консюмер в группе потерян, обработка его партиций в топике не прекращается.
Но у дефолтного механизма ребалансировки есть недостаток. Каждый консюмер лишается назначенных партиций и ничего не обрабатывает, пока их не назначат обратно, поэтому иногда такую ребалансировку называют stop-the-world. Более того, в зависимости от используемого инстанса `ConsumerPartitionAssignor`, консюмеры просто переназначаются тем же партициям, с которыми работали до этого, поэтому пауза не имеет никакого смысла.
Такая реализация протокола ребалансировки называется `eager rebalancing`. Ее цель — гарантировать, что консюмеры в одной группе не будут назначены одинаковым партициям. Если одна партиция будет принадлежать двум консюмерам из одной группы, это приведет к непредсказуемому поведению.
Этого нельзя допустить. Но оказывается, есть более эффективный подход, который обеспечивает безопасность без пауз — [пошаговая кооперативная ребалансировка (incremental cooperative rebalancing)](https://www.confluent.io/blog/incremental-cooperative-rebalancing-in-kafka/). Впервые представленный в Kafka Connect в [Apache Kafka 2.3](https://www.confluent.io/blog/whats-new-in-apache-kafka-2-3#kip-415), этот подход теперь реализован и для протокола группы консюмеров. При таком подходе консюмеры не отказываются от партиций автоматически в начале ребалансировки. Вместо этого все члены кодируют свои назначения и отправляют эту информацию лидеру группы. Лидер группы решает, какие партиции должны сменить назначения, вместо того чтобы переназначать все с нуля.
Запускается вторая ребалансировка, которая затрагивает только те партиции, которым нужно изменить назначение, например, партиции без назначения или новые партиции. Если ничего не меняется, обработка не останавливается.
Если останавливать не все, а только нужные партиции, ребалансировка выходит менее затратной и отнимает меньше времени. Даже долгая ребалансировка воспринимается не так болезненно, потому что обработка продолжается. Это изменение стало возможным благодаря использованию `CooperativeStickyAssignor`. Пусть `CooperativeStickyAssignor` и выполняет вторую ребалансировку, зато позволяет быстрее вернуться к нормальной работе.
Чтобы использовать новый протокол ребалансировки, настройте для `partition.assignment.strategy` новый `CooperativeStickyAssignor`. Это изменение происходит на стороне клиента. Чтобы воспользоваться новым протоколом ребалансировки, достаточно обновить версию клиента. Если вы используете Kafka Streams, вам повезло еще больше. В Kafka Streams кооперативный протокол включен по умолчанию, так что вам ничего не придется делать.
### 4. Инструменты командной строки
Установка Apache Kafka включает несколько инструментов в каталоге `bin`. Давайте рассмотрим четыре самых полезных из них. Это `console-consumer`, `console-producer`, `dump-log` и `delete-records`.
**Kafka console producer**
С console-producer можно создавать записи в топике прямо из командной строки. Это очень удобный способ быстро протестировать новые приложения-консюмеры, пока в топики еще не передаются данные. Запускаем console-producer:
```
kafka-console-producer --topic \
--broker-list
```
После выполнения команды открывается пустая строка. Вводим любые символы и нажимаем Enter, чтобы создать сообщение.
При этом мы отправляем только значения, без ключей. К счастью, есть способ отправить и ключи — нужно просто добавить в команду флаги:
```
kafka-console-producer --topic \
--broker-list \
--property parse.key=true \
--property key.separator=":"
```
Свойство `key.separator` можно выбрать произвольно. Подойдет любой символ. Теперь можно отправлять полноценные пары ключ-значение прямо из командной строки. Если вы используете [Confluent Schema Registry](https://docs.confluent.io/current/schema-registry/index.html), вам доступны [CLI продюсеры](https://docs.confluent.io/current/schema-registry/serdes-develop/index.html#command-line-utilities-and-json-encoding-of-messages) для отправки записей в схемы Avro, Protobuf и JSON.
Теперь зайдем с другой стороны: консюмеры сообщений в командной строке.
**Kafka console consumer**
С console-consumer можно читать записи в топике прямо из командной строки. Возможность быстро запускать консюмер очень поможет при прототипировании и отладке. Допустим, мы создаем новый микросервис. Чтобы быстро проверить, что продюсер отправляет сообщения, выполняем команду:
```
kafka-console-consumer --topic \
--bootstrap-server
```
Сразу отображаются записи (если продюсер отправляет данные в топик). Если нужно просмотреть все записи в топике с самого начала, добавляем в команду флаг `--from-beginning`.
```
kafka-console-consumer --topic \
--bootstrap-server \
--from-beginning
```
Если вы используете [Schema Registry](https://docs.confluent.io/current/schema-registry/index.html), вам доступны [CLI консюмеры](https://docs.confluent.io/current/schema-registry/serdes-develop/index.html#command-line-utilities-and-json-encoding-of-messages) для схем Avro, Protobuf и JSON. Консюмеры в командной строке для Schema Registry работают с записями в формате Avro, Protobuf и JSON, а обычные консюмеры работают с записями примитивных типов Java: String, Long, Double, Integer и т. д. По умолчанию обычный консюмер ожидает ключи и значения типа String.
Если они принадлежат другому типу, предоставим десериализаторы с помощью флагов `--key-deserializer` и `--value-deserializer` с полным именем (FQN) класса соответствующих десериализаторов.
Наверное, вы заметили, что по умолчанию консольный консюмер выводит только значения сообщений. Если мы хотим посмотреть ключи, добавляем флаги:
```
kafka-console-consumer --topic \
--bootstrap-server \
--property print.key=true
--property key.separator=":"
```
Как и для продюсера, значение разделителя ключей выбирается произвольно.
**Dump log**
Иногда при работе с Kafka хочется вручную проверить логи топика — из любопытства или для отладки какой-то проблемы. В этом нам поможет команда `kafka-dump-log`. Допустим, мы хотим посмотреть лог примера топика с говорящим именем `example`:
```
kafka-dump-log \
--print-data-log \
--files ./var/lib/kafka/data/example-0/00000000000000000000.log
```
* Флаг `--print-data-log` велит вывести данные в лог.
* Флаг `--files` является обязательным. Это может быть список файлов, разделенный запятыми.
Чтобы увидеть полный список опций и их описания, выполним команду `kafka-dump-log` с флагом `--help`.
Лог выглядит примерно так:
```
Dumping ./var/lib/kafka/data/example-0/00000000000000000000.log
Starting offset: 0
baseOffset: 0 lastOffset: 0 count: 1 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 0 CreateTime: 1599775774460 size: 81 magic: 2 compresscodec: NONE crc: 3162584294 isvalid: true
| offset: 0 CreateTime: 1599775774460 keysize: 3 valuesize: 10 sequence: -1 headerKeys: [] key: 887 payload: -2.1510235
baseOffset: 1 lastOffset: 9 count: 9 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 81 CreateTime: 1599775774468 size: 252 magic: 2 compresscodec: NONE crc: 2796351311 isvalid: true
| offset: 1 CreateTime: 1599775774463 keysize: 1 valuesize: 9 sequence: -1 headerKeys: [] key: 5 payload: 33.440664
| offset: 2 CreateTime: 1599775774463 keysize: 8 valuesize: 9 sequence: -1 headerKeys: [] key: 60024247 payload: 9.1408728
| offset: 3 CreateTime: 1599775774463 keysize: 1 valuesize: 9 sequence: -1 headerKeys: [] key: 1 payload: 45.348946
| offset: 4 CreateTime: 1599775774464 keysize: 6 valuesize: 10 sequence: -1 headerKeys: [] key: 241795 payload: -63.786373
| offset: 5 CreateTime: 1599775774465 keysize: 8 valuesize: 9 sequence: -1 headerKeys: [] key: 53596698 payload: 69.431393
| offset: 6 CreateTime: 1599775774465 keysize: 8 valuesize: 9 sequence: -1 headerKeys: [] key: 33219463 payload: 88.307875
| offset: 7 CreateTime: 1599775774466 keysize: 1 valuesize: 9 sequence: -1 headerKeys: [] key: 0 payload: 39.940350
| offset: 8 CreateTime: 1599775774467 keysize: 5 valuesize: 9 sequence: -1 headerKeys: [] key: 78496 payload: 74.180098
| offset: 9 CreateTime: 1599775774468 keysize: 8 valuesize: 9 sequence: -1 headerKeys: [] key: 89866187 payload: 79.459314
```
Команда `dump-log` дает много полезной информации, например `key`, `payload`, смещение и метка времени для каждой записи. Это данные для демо-топика, где всего 10 сообщений. Для реального топика данных будет гораздо больше. В этом примере ключи и значения топика — это строки. Чтобы использовать dump-log с ключами и значениями других типов, используем флаги `--key-decoder-class` и `--value-decoder-class`.
**Delete records**
Kafka хранит записи для топиков на диске и сохраняет их даже после прочтения консюмерами. Записи не хранятся в одном большом файле. Они разделены на сегменты по партициям, причем порядок смещений будет непрерывным в сегментах одной партиции. Поскольку серверы не резиновые, Kafka позволяет контролировать время хранения и объем данных:
* Параметр `log.retention.hours` задает время хранения данных. По умолчанию это 168 часов (одна неделя).
* Параметр `log.retention.bytes` задает размер сегментов, которые можно удалять.
*Однако* дефолтное значение `log.retention.bytes` составляет -1, то есть размер сегмента не ограничен. Если мы не настроим размер сегмента и период хранения, место на диске скоро закончится. Мы *не хотим* удалять файлы вручную. Нам нужен контролируемый рабочий способ удалять записи из топика, чтобы освободить место. К счастью, в Kafka для этого есть специальный инструмент.
У `kafka-delete-records` два обязательных параметра:
* `--bootstrap-server` — брокеры для начальной загрузки;
* `--offset-json-file` — файл JSON с параметрами удаления.
Пример файла JSON:
```
{
"partitions": [
{"topic": "example", "partition": 0, "offset": -1}
],
"version":1
}
```
Как видите, у JSON простой формат. Это массив объектов JSON. У каждого объекта JSON три свойства:
* **topic** — топик, из которого удаляем данные;
* **partition** — партиция, из которой удаляем данные;
* **offset** — смещение, с которого начинаем удалять данные, двигаясь от большего к меньшему.
В этом примере возьмем топик из раздела про dump-log, чтобы получить простейший файл JSON. Если партиций или топиков больше, файл конфигурации JSON будет больше.
Как выбрать `offset` в файле JSON? У нас в примере всего 10 записей, так что начальное смещение рассчитать легко. На практике это будет не так очевидно. Помните, что смещение не эквивалентно номеру сообщения, так что мы не может просто удалить все, начиная с сообщения 42. Если указано `-1`, используется смещение `high watermark`, то есть мы удаляем все данные из топика. `high watermark` — это максимальное доступное смещение для чтения (смещение последнего успешно реплицированного сообщения плюс один).
Чтобы выполнить эту команду, вводим в командной строке:
```
kafka-delete-records --bootstrap-server \
--offset-json-file offsets.json
```
После выполнения команды в консоли отображается примерно следующее:
```
Executing records delete operation
Records delete operation completed:
partition: example-0 low_watermark: 10
```
Результаты команды показывают, что Kafka удалила все записи из партиции топика `example-0`. Значение `low_watermark`, равное 10, указывает *минимальное* смещение, доступное консюмерам. Раз в `example topic` всего 10 записей, смещения имеют номера от 0 до 9, то есть консюмеры больше не смогут читать эти записи. Больше о реализации удаления: [KIP-107](https://cwiki.apache.org/confluence/display/KAFKA/KIP-107%3A+Add+deleteRecordsBefore%28%29+API+in+AdminClient) и [KIP-204](https://cwiki.apache.org/confluence/display/KAFKA/KIP-204+%3A+Adding+records+deletion+operation+to+the+new+Admin+Client+API).
### 5. Заголовки записей
В Apache Kafka 0.11 представлены [заголовки записей](https://cwiki.apache.org/confluence/display/KAFKA/KIP-82+-+Add+Record+Headers). Заголовки записей позволяют добавлять метаданные о записи Kafka, но при этом не указывать дополнительную информацию в парах ключ-значение самой записи. Допустим, мы хотим добавить в сообщение идентификатор системы, из которой поступили данные. Это может понадобиться для отслеживания происхождения, аудита или упрощения маршрутизации данных.
Почему бы не указать эту информацию в ключе, чтобы потом просто извлечь нужную часть и отправить данные куда надо? Добавление искусственных данных в ключ может привести к двум проблемам.
1. Во-первых, если вы используете compacted топик, при добавлении данных в ключ запись будет выглядеть уникальной, хотя это не так. В итоге compaction будет работать не так, как хотелось бы.
2. Во-вторых, представьте, что будет, если идентификатор системы будет доминировать в отправленной записи. Это может привести к серьезному перекосу ключей. В зависимости от способа чтения данных из партиций, неравномерное распределение ключей может увеличить задержку при обработке.
В таких ситуациях на выручку придут заголовки. [Исходный KIP](https://cwiki.apache.org/confluence/display/KAFKA/KIP-82+-+Add+Record+Headers), где были предложены заголовки, предусматривал дополнительные варианты использования:
* Автоматизация маршрутизации сообщений между кластерами на основе заголовков.
* Корпоративные инструменты APM (например, Appdynamics или Dynatrace) должны использовать идентификаторы транзакций, чтобы мониторить весь поток транзакций.
* Вместе с сообщением записываются метаданные для аудита, например идентификатор клиента, который создал запись.
* Содержание сообщения должно быть защищено сквозным шифрованием и надежно подписано, но компонентам экосистемы требуется доступ к метаданным для выполнения задач.
Итак, мы определились с назначением заголовков, а теперь посмотрим, как добавлять заголовки в записи Kafka.
**Добавление заголовков в записи Kafka**
Код Java для добавления заголовков в `ProducerRecord`:
```
ProducerRecord producerRecord = new ProducerRecord<>("bizops", "value");
producerRecord.headers().add("client-id", "2334".getBytes(StandardCharsets.UTF\_8));
producerRecord.headers().add("data-file", "incoming-data.txt".getBytes(StandardCharsets.UTF\_8));
// Details left out for clarity
producer.send(producerRecord);
```
* Создаем инстанс класса `ProducerRecord`.
* Вызываем метод `ProducerRecord.headers()` и добавляем ключ и значение для заголовка.
* Добавляем еще заголовок.
На что нужно обратить внимание? Интерфейс [header](https://kafka.apache.org/26/javadoc/org/apache/kafka/common/header/Header.html) ожидает ключ `String` и значение в виде байтового массива. Для одного ключа можно добавить сколько угодно заголовков. Дублирующиеся ключи *не* перезаписывают предыдущие данные с тем же ключом.
Существуют перегруженные конструкторы `ProducerRecord`, которые принимают `Iterable`. Можно создать собственный конкретный класс, который реализует интерфейс `Header` и передает коллекцию, реализующую интерфейс `Iterable`. Но на практике будет достаточно простого метода, который мы показали здесь.
Добавлять заголовки мы теперь умеем, давайте узнаем, как получить к ним доступ со стороны консюмера.
**Извлечение заголовков**
Получаем доступ к заголовкам при чтении записей:
```
//Details left out for clarity
ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));
for (ConsumerRecord consumerRecord : consumerRecords) {
for (Header header : consumerRecord.headers()) {
System.out.println("header key " + header.key() + "header value " + new String(header.value()));
}
}
```
* Проходим по `ConsumerRecords`.
* Для каждой `ConsumerRecord` проходим по заголовкам.
* Обрабатываем заголовки.
Из кода видно, что для обработки заголовков мы используем метод `ConsumerRecord.headers()`, который их возвращает. В примере выше мы выводим заголовки на консоль в целях демонстрации. Получив доступ к заголовкам, мы обрабатываем их в зависимости от потребностей. Для чтения заголовков из командной строки [KIP-431](https://cwiki.apache.org/confluence/display/KAFKA/KIP-431:+Support+of+printing+additional+ConsumerRecord+fields+in+DefaultMessageFormatter) добавляет поддержку вывода заголовков из ConsoleConsumer. Эта фича будет доступна в релизе Apache Kafka 2.7.0.
Еще можно просмотреть заголовки из командной строки с помощью [kafkacat](https://github.com/edenhill/kafkacat). Пример команды:
```
kafkacat -b kafka-broker:9092 -t my_topic_name -C \
-f '\nKey (%K bytes): %k
Value (%S bytes): %s
Timestamp: %T
Partition: %p
Offset: %o
Headers: %h\n'
```
#### Другие материалы по Apache Kafka в нашем блоге:
[Apache Kafka в вопросах и ответах](https://habr.com/ru/company/southbridge/blog/536164/)
[Почему Kafka такая быстрая](https://habr.com/ru/company/southbridge/blog/530498/)
[Используете Kafka с микросервисами? Скорее всего, вы неправильно обрабатываете повторные передачи](https://habr.com/ru/company/southbridge/blog/531838/)
[Практический взгляд на хранение в Kafka](https://habr.com/ru/company/southbridge/blog/535374/)
[Как Apache Kafka поддерживает 200К партиций в кластере?](https://habr.com/ru/company/southbridge/blog/544958/) | https://habr.com/ru/post/547264/ | null | ru | null |
# Управление устройствами интернета вещей через Kubernetes
Kubernetes последовательно захватывает все новые ниши для декларативного описания ожидаемого состояния и теперь ресурсами Kubernetes можно управлять облачными провайдерами (например, через [Crossplane](https://habr.com/ru/company/otus/blog/676082/)), создавать и масштабировать функции ([KNative](https://habr.com/ru/company/otus/blog/682466/)) и многим другим. И кажется интересной идея конфигурирования через Kubernetes физических устройств, имеющих механизм удаленного управления и отправки информации о текущем состоянии. В CNCF был зарегистрирован проект (сейчас находится в sandbox) [Akri](https://github.com/project-akri/akri), который предлагает модель унифицированного управления устройствами умного дома и в этой статье мы рассмотрим основные аспекты конфигурирования Akri на примере udev и OPC UA.
Akri определяет два типа ресурсов: описание устройства и описание экземпляра Akri для управления устройством. Для обнаружения устройств Akri поддерживает протоколы [udev](https://www.freedesktop.org/software/systemd/man/udev.html) (универсальный механизм обнаружения для Linux), [ONVIF](https://www.onvif.org/) (для обнаружения IP-камер), [OPC UA](https://opcfoundation.org/about/opc-technologies/opc-ua/) (промышленный стандарт для взаимодействия с датчиками и управляющими устройствами), в работе поддержка Bluetooth, [LoRaWAN](https://lora-alliance.org/about-lorawan/), [CoAP](https://r-iot.org/2018/05/14/coap-%D0%B4%D0%BB%D1%8F-%D1%82%D0%B5%D1%85-%D1%83-%D0%BA%D0%BE%D0%B3%D0%BE-%D0%BC%D0%B0%D0%BB%D0%BE-%D1%80%D0%B5%D1%81%D1%83%D1%80%D1%81%D0%BE%D0%B2/) и других, при этом можно создать собственное расширение для обнаружения устройств по специальному протоколу, который описан в [документации](https://docs.akri.sh/development/handler-development) на основе [шаблона](https://github.com/project-akri/akri-discovery-handler-template) на Rust. Мы будем использовать `udev` и будем обнаруживать существующую веб-камеру на компьютере, но разумеется здесь можно было бы использовать любую другую конфигурацию (например, управлять GPU или другими устройства, в том числе подключенными через USB).
Для установки будем использовать Helm, это поможет сразу настроить необходимую конфигурацию обнаружения. Для получения информации о состоянии pod будет использоваться crictl, которая доступна по умолчанию в Kubernetes 1.24+. Важно при установке указать расположение socket-файла для cri в переменной `agent.host.containerRuntimeSocket` (например, при установке с Containerd расположение будет `/run/containerd/contained.sock`, для Docker + Mirantis cri-dockerd: `/run/cri-dockerd.sock`)
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
helm install akri akri-helm-charts/akri \
--set agent.host.containerRuntimeSocket=/run/cri-dockerd.sock \
--set udev.discovery.enabled=true \
--set udev.configuration.enabled=true \
--set udev.configuration.name=akri-udev-video \
--set udev.configuration.discoveryDetails.udevRules[0]='KERNEL=="video[0-9]*"' \
--set udev.configuration.brokerPod.image.repository="ghcr.io/project-akri/akri/udev-video-broker"
```
При установке мы указываем способ обнаружения устройств, дополнительные настройки для поиска устройств (здесь мы ищем все доступные видеоустройства в /dev). Также можно разрешить все доступные способы обнаружения через переменную `agent.full=true`. Для мониторинга в Prometheus можно разрешить экспорт метрик через `prometheus.enabled=true`, среди которых будет кроме обычных замеров rust-приложений значения количества обнаруженных устройств (`akri_instance_count`), запущенных брокеров (`akri_broker_pod_count`), а также метрики от брокеров (например, `akri_frame_count` от брокера `udev-video`).
При использовании сетевых методов обнаружения можно указывать список ip или MAC-адресов для отбора устройств и анонсированные возможности (например, scopes в ONVIF). Более подробно примеры конфигурации можно посмотреть в [документации](https://github.com/project-akri/akri-docs/blob/main/docs/discovery-handlers/onvif.md). Конфигурация discovery создает ресурс с типом `Configuration` (`apiVersion: akri.sh/v0`) со следующей спецификацией:
```
spec:
brokerProperties: {}
brokerSpec:
brokerPodSpec:
containers:
- image: ghcr.io/project-akri/akri/udev-video-broker:latest
name: akri-udev-video-broker
securityContext:
privileged: true
capacity: 1
configurationServiceSpec:
ports:
- name: grpc
port: 80
protocol: TCP
targetPort: 8083
type: ClusterIP
discoveryHandler:
discoveryDetails: |
udevRules:
- KERNEL=="video[0-9]*"
name: udev
instanceServiceSpec:
ports:
- name: grpc
port: 80
protocol: TCP
targetPort: 8083
type: ClusterIP
```
В спецификации указывается образ контейнера для брокера, который будет использоваться для взаимодействия с устройствами, и настройки discovery, которые применяются в discovery-daemonset для обнаружения новых устройств. Кроме пода обнаружения на узлы устанавливается агент, который реализует протокол [Device Plugins](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins/) для уведомления о доступных устройствах, устанавливается через DaemonSet на все узлы кластера. Для обнаруженных устройств создается экземпляр ресурса `Instance` (`apiVersion: akri.sh/v0`), который содержит информацию о доступе к устройству для брокера (brokerProperties). Также в brokerProperties может содержаться информация о настройках устройствах (например, частота кадров для камеры). Агент отслеживает изменения в списке устройств и соответственно создает, изменяет или удаляет ресурсы Instance.
```
apiVersion: akri.sh/v0
kind: Instance
metadata:
name: akri-udev-video-db97e3
namespace: default
spec:
brokerProperties:
UDEV_DEVNODE: /dev/video0
configurationName: akri-udev-video
deviceUsage:
akri-udev-video-db97e3-0: mynotebook
nodes:
- mynotebook
shared: false
```
Брокер может изменять состояние устройства при изменениях в brokerProperties, а также предоставлять методы для получения информации от устройства через REST, gRPC или другие протоколы. Для udev-video-broker можно использовать клиент, который отображает полученные кадры в веб-интерфейсе:
```
kubectl apply -f https://raw.githubusercontent.com/project-akri/akri/main/deployment/samples/akri-video-streaming-app.yaml
PORT=`kubectl get service/akri-video-streaming-app --output=jsonpath='{.spec.ports[?(@.name=="http")].nodePort}'`
open http://localhost:$PORT
```
Исходные тексты приложения можно посмотреть [здесь](https://github.com/project-akri/akri/tree/main/samples/apps/video-streaming-app). Приложение запрашивает кадры с опубликованного grpc-сервиса (связан с соответствующим Instance и может быть найден по имени Instance и суффиксу -svc, grpc опубликован на порт 80), описание протокола выглядит следующим образом:
```
syntax = "proto3";
option csharp_namespace = "Camera";
package camera;
service Camera {
rpc GetFrame (NotifyRequest) returns (NotifyResponse);
}
message NotifyRequest {
}
message NotifyResponse {
bytes frame = 1;
string camera = 2;
}
```
Рассмотрим теперь более сложный пример с использованием OPC UA. Для симуляции устройства будем использовать <https://github.com/flopach/opc-ua-sensor-simulator>. Установим симулятор и попробуем подключиться к нему через свободный клиент:
```
git clone https://github.com/flopach/opc-ua-sensor-simulator
apt install libxslt-dev libxml2-dev libffi-dev
cd opc-ua-sensor-simulator
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt install python3.8 python3.8-distutils
sudo rm /usr/bin/python
sudo ln -s /usr/bin/python3.8 /usr/bin/python
pip3 install -r requirements.txt
unzip sensor.csv.zip
sed -i 's/127.0.0.1/0.0.0.0/ig' opc-ua-server.py
python opc-ua-server.py
```
Установим свободный клиент:
```
snap install --edge opcua-client
```
Для получения информации о доступных устройствах и замеров датчиков подключимся к localhost:4840 и получим возможность просмотра списка зарегистрированных поставщиков данных и значения температуры и давления.
Теперь настроим подключение Akri к серверу. Для этого создадим конфигурацию обнаружения:
```
apiVersion: akri.sh/v0
kind: Configuration
metadata:
name: akri-opcua
namespace: default
spec:
brokerProperties: {}
brokerSpec:
brokerPodSpec:
containers:
- image: nginx:latest
name: akri-opcua-broker
capacity: 1
configurationServiceSpec:
ports:
- name: grpc
port: 80
protocol: TCP
targetPort: 8083
type: ClusterIP
discoveryHandler:
discoveryDetails: "opcuaDiscoveryMethod: \n standard:\n discoveryUrls:\n -
opc.tcp://IP:4840/opcua/\napplicationNames:\n action: Exclude\n
\ items: []\n"
name: opcua
instanceServiceSpec:
ports:
- name: grpc
port: 80
protocol: TCP
targetPort: 80
type: ClusterIP
```
Вместо IP здесь необходимо подставить соответствующий внешний адрес узла. Для каждого обнаруженного устройства будет создан брокер (в нашем случае сервер nginx). Для разработки собственного брокера (например, получения температуры с датчиков) можно использовать свободные реализации gRPC и OPC UA (например, topic и opcua в crates для Rust, grpc и asyncua в python). Во второй части статьи мы рассмотрим пример обработки данных с датчика температуры через протокол спецификации OPC UA и их извлечения в веб-интерфейсе с построением графика истории изменения температуры (также будем использовать возможности обнаружения Akri), а также поговорим о возможностях интеграции системы обнаружения со свободными системами умного дома Majordomo и Home Assistant.
В преддверии запуска курса ["Инфраструктурная платформа на основе Kubernetes"](https://otus.pw/9wSo/) приглашаю всех на бесплатный демоурок, в рамках которого мои коллеги расскажут как шаблонизировать манифесты Kubernetes разными способами и не только.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/9wSo/) | https://habr.com/ru/post/686332/ | null | ru | null |
# Маршрутизация IPv6 через WireGuard с поддержкой SLAAC
Вдохновившись аргументами из статьи «[IPv6 — прекрасный мир, стоящий скорого перехода на него](https://habr.com/ru/post/490378/)», мне стало катастрофически не хватать IPv6. Конечная цель: обеспечить каждое из своих устройств уникальным публичным псевдостатическим IPv6.
Для дома решение довольно простое: при наличии статического IPv4, можно получить подсеть IPv6 от [туннельного брокера](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%B1%D1%80%D0%BE%D0%BA%D0%B5%D1%80%D0%BE%D0%B2_IPv6) и на этом вопрос можно считать закрытым.
А вот с мобильными устройствами так не получится: услуга статического IPv4 тут скорее редкость; да и при наличии бесплатного WiFi я выберу подключение к нему, а не к мобильной сети.
Остаётся единственный вариант — использовать VPN. Существующие на GitHub решения типа “[wireguard-install](https://github.com/angristan/wireguard-install)” или “[openvpn-install](https://github.com/angristan/openvpn-install)” имеют фатальный недостаток: они отдают клиенту единственный IPv6/128 адрес, а чтобы у клиентов появилась возможность автоконфигурации, нужна целая /64 подсеть.
Предлагается решение на основе WireGuard.
---
Вам понадобятся
---------------
1. Особый виртуальный сервер. Для реализации задуманного, нужно купить VDS, которому хостер согласится отдать хотя бы /60 подсеть. Как оказалось, найти такое — достаточно [сложная задача](https://searchengines.guru/ru/forum/1046267): в худшем случае, хостеры почему-то продают IPv6 поштучно; в лучшем — только /64 подсети. В результате долгих поисков и благоприятного стечения обстоятельств, был найдена компания [Melbicom](https://melbicom.ru/?from=37123), которая способна выделить /56 подсеть на VDS.
2. Linux + wireguard + udppd + nftables. На моём сервере установлен ArchLinux, но описанное решение может быть воспроизведено и на других дистрибутивах.
Условные обозначения
--------------------
`ens3` – имя сетевого интерфейса.
Далее в тексте используются следующие «IP» адреса:
* `2a06:X:X:a::2/128` и `213.x.x.2/24` – IPv6 и IPv4 адреса VDS. Назначаются хостером автоматически и бесплатно к каждому приобретаемому VDS.
* `2a06:X:X:100::/56` – Маршрутизируемая до VDS подсеть /56 IPv6. Заказывается отдельно.
* `2a06:X:X:111::/64` – подсеть для клиента (мобильного устройства), которая выделяется из заказанной выше /56 подсети.
* `2a06:X:X:111:a:b:c:d/64` – пример IPv6 клиента (мобильного устройства), где `a:b:c:d` (interface id) выбирается клиентом самостоятельно.
Где заглавная буква `X` означают одну группу шестнадцатеричных цифр IPv6 адреса, а строчная `x` - одну группу десятичных цифр IPv4 адреса.
Тестирование наличия выделенной /56 подсети
-------------------------------------------
Изначально, на сервере, сеть не должна быть настроена, но должна маршрутизироваться до него. Содержимое /etc/systemd/network/ens3.network выглядит примерно так:
```
[Match]
Name = ens3
[Network]
Address = 213.x.x.2/24
Gateway = 213.x.x.1
Address = 2a06:X:X:a::2/128
Gateway = 2a06:X:X:a::1
```
Для проверки, выполним команду: `tcpdump ip6 -nq -i ens3`
Далее, пингуем любой IPv6 из выделенной подсети, например `2a06:X:X:111:a:b:c:d`. Если всё хорошо, то в дампе появятся строки типа:
`19:14:39.689842 IP6 fe80::XX > ff02::XX ICMP6, neighbor solicitation, who has 2a06:X:X:111:a:b:c:d, length 32`
Установка ndppd
---------------
Ndppd — это демон, задача которого слушать интерфейс: ожидать «neighbor solicitation» и отвечать «router advertisement» Таким образом, вышестоящий роутер узнает, куда адресовать трафик выделенной подсети. Далее этот трафик через wireguard будет передан клиенту.
К сожалению, в ArchLinux ndppd пока доступен только из AUR. Если в вашем дистрибутиве он доступен из репозиториев, переходите к следующем разделу.
Для начала ставим все необходимые компоненты:
`pacman -Suy git base-devel`
Далее создаём пользователя, под которым будем все это собирать:
`useradd -m router`
Переходим в пользователя:
`su router`
`cd /home/router`
Теперь из-под пользователя выполняем команды:
`git clone https://aur.archlinux.org/ndppd.git`
`cd ndppd`
`makepkg`
Возвращаемся в root:
`exit`
Переходим в каталог ndppd:
`cd /home/router/ndppd`
Находим в каталоге ndppd-\*.zst файл и устанавливаем его:
`pacman -U ndppd-0.2.5-1-x86_64.pkg.tar.zst`
Настройка ndppd
---------------
Создаём файл /etc/ndppd.conf с содержимым:
```
proxy ens3 {
rule 2a06:X:X:100::/56 {
static
}
}
```
Где:
* `ens3` – имя интерфейса
* `static` - опция, которая сообщает ndppd, что он должен немедленно отвечать на Neighbor Solicitation, без дополнительных проверок.
Подробное описание параметров изложено в [документации](http://manpages.ubuntu.com/manpages/bionic/man5/ndppd.conf.5.html).
Далее активируем сервис:
`systemctl enable ndppd`
и запускам:
`systemctl start ndppd`
Установка системных переменных
------------------------------
Чтобы заработала пересылка IPv6 пакетов между интерфейсами, необходимо в каталоге /etc/sysctl.d/ создать файл wireguard.conf с содержимым:
```
net.ipv4.ip_forward=1
net.ipv6.conf.all.forwarding=1
```
Первая строка включает пересылку IPv4, вторая — IPv6. Подробное описание каждого из параметров можно узнать из [документации](https://www.kernel.org/doc/Documentation/networking/ip-sysctl.txt).
Применяем настройки:
`sysctl --system`
Настройка WireGuard на сервере
------------------------------
Создаём публичный и приватный ключи сервера:
`wg genkey | tee server-private.key | wg pubkey > server-public.key`
Создаём публичный и приватный ключи клиента:
`wg genkey | tee client1-private.key | wg pubkey > client1-public.key`
Создаём pre-shared key:
`wg genpsk > pre-shared.key`
Создаём файл /etc/wireguard/wg0.conf:
```
[Interface]
SaveConfig = false
ListenPort = 52525 #Может быть любым
PrivateKey = #содержимое server-private.key#
Address = 10.20.30.1/24, 2a06:X:X:100::/56
[Peer]
PublicKey = #содержимое client1-public.key#
PresharedKey = #содержимое pre-shared.key#
AllowedIPs = 10.20.30.17/32, 2a06:X:X:111::/64
```
Активируем и запускаем демона wireguard:
`systemctl enable wg-quick@wg0 && systemctl start wg-quick@wg0`
В случае изменения конфигурации, перезапуск удобно выполнять командой:
`wg-quick down wg0 && wg-quick up wg0`
Настройка nftables
------------------
Поскольку iptables постепенно выходит из употребления, я предпочитаю nftables.
Установка командой:
`pacman -S nftables`
Для конфигурации нужно создать или отредактировать файл /etc/nftables.conf :
```
#!/usr/sbin/nft -f
# Start by flushing all the rules.
flush ruleset
# Документация https://man.archlinux.org/man/nft.8
# Определение переменных: интерфейсы и виртуальная локальная IPv4 подсеть
define wan = ens3
define vpn = wg0
define vpn_net4 = 10.20.30.0/24
# Общие настройки для IPv6 и IPv4
table inet wg-common {
# Все пересылаемые пакеты по умолчанию дропаем, за исключением тех, которые идут между vpn и wan
chain forward {
type filter hook forward priority 0; policy drop;
iifname $wan oifname $vpn accept;
oifname $wan iifname $vpn accept;
}
chain input {
type filter hook input priority 0;
# allow established/related connections
ct state {established, related} accept
# early drop of invalid connections
ct state invalid drop
# allow from loopback
iifname lo accept
# allow icmp
ip protocol icmp accept
meta l4proto ipv6-icmp accept
# allow ssh
tcp dport ssh accept
# Разрешаем вкходящие соединения с WireGuard
udp dport 52525 accept;
# everything else
reject with icmpx type port-unreachable
}
}
# Настройка NAT для IPv4
table ip wg-nat {
# Все исходяющие пакеты IPv4 c подсети vpn на интерфейс wan подвергаются маскараду
chain pre {
type nat hook postrouting priority 0;
oifname $wan ip saddr $vpn_net4 masquerade persistent;
}
}
```
Настройка WireGuard на клиенте
------------------------------
Конфигурация клиента выглядит так:
```
[Interface]
PrivateKey = #содержимое client1-private.key#
Address = 10.20.30.17/32, 2a06:X:X:111:a:b:c:d/64
DNS = 9.9.9.9, 149.112.112.112, 2620:fe::fe, 2620:fe::9
[Peer]
PublicKey = #содержимое server-public.key#
PresharedKey = #содержимое pre-shared.key#
AllowedIPs = 2000::/3
Endpoint = #Публичный IP сервера, или домен#:52525
PersistentKeepalive = 25
```
На этом конфигурация завершена. Всё, что осталось это установить на телефон WireGuard, импортировать полученный конфиг, включить и пользоваться IPv6. Важной особенностью тут является то, что в IPv6 адресе клиента вместо `a:b:c:d` можно указать абсолютно любой interface id. Такой себе ручной SLAAC. А если хочется пустить через wireguard ещё и весь IPv4 трафик, в поле `AllowedIPs` добавьте подсеть `0.0.0.0/0` .
Бонус: обход блокировок
-----------------------
Если из-за политики государства, часть Интернета заблокирована, при помощи клиента WireGuard на роутере с OpenWRT можно обойти блокировку.
Для этого переносим конфиг клиента на роутер с OpenWRT, указав в параметре `AllowedIPs` заблокированные подсети. Например, чтобы разблокировать Яндекс из Украины, нужно указать:
```
AllowedIPs=5.45.192.0/18,5.45.196.0/24,5.45.202.0/24,5.45.205.0/24,5.45.213.0/24,5.45.229.0/24,5.45.240.0/24,5.255.192.0/18,5.255.195.0/24,5.255.196.0/24,5.255.197.0/24,5.255.255.0/24,37.9.64.0/18,37.9.64.0/24,37.9.73.0/24,37.9.112.0/24,37.140.128.0/18,77.88.0.0/18,77.88.8.0/24,77.88.35.0/24,77.88.44.0/24,77.88.54.0/24,77.88.55.0/24,87.250.224.0/19,87.250.247.0/24,93.158.128.0/18,95.108.128.0/17,100.43.64.0/19,141.8.128.0/18,141.8.174.0/24,178.154.128.0/19,178.154.131.0/24,178.154.160.0/19,185.32.187.0/24,199.21.96.0/22,199.36.240.0/22,213.180.192.0/19,213.180.199.0/24,2a02:6b8::/29,2620:10f:d000::/44
```
Список подсетей Яндекса взят отсюда <https://ipinfo.io/AS13238>
IPv4 заработает сразу. А чтобы заработал IPv6, нужно при помощи nat6 подменить префикс клиента. В разделе Firewall :: Custom Rules допишем следующие пользовательские правила:
```
ip6tables -t nat -A POSTROUTING -d 2a02:6b8::/29 -j NETMAP --to 2a06:X:X:111::/64
ip6tables -t nat -A POSTROUTING -d 2620:10f:d000::/44 -j NETMAP --to 2a06:X:X:111::/64
```
После этого можно перейти на <https://yandex.ru/internet/> и убедиться, что всё работает. | https://habr.com/ru/post/565692/ | null | ru | null |
# Hibernate — о чем молчат туториалы
Эта статья не будет затрагивать основы hibernate (как определить entity или написать criteria query). Тут я постараюсь рассказать о более интересных моментах, действительно полезных в работе. Информацию о которых я не встречал в одной месте.
Сразу оговорюсь. Все ниже изложенное справедливо для Hibernate 5.2. Также возможны ошибки в силу того, что я что-то неправильно понял. Если обнаружите — пишите.
Проблемы отображения объектной модели в реляционную
---------------------------------------------------
Но начнем все же с основ ORM. ORM — объектно-реляционное отображение — соответственно у нас есть реляционная и объектная модели. И при отображении одной в другую существуют проблемы, которые нам нужно решить самостоятельно. Давайте их разберем.
Для иллюстрации возьмем следующий пример: у нас есть сущность “Пользователь”, который может быть либо джедаем либо штурмовиком. У джедая обязательно должна быть сила, а у штурмовика специализация. Ниже приведена диаграмма классов.
### Проблема 1. Наследование и полиморфные запросы.
В объектной модели есть наследование, а в реляционной нет. Соответственно это и первая проблема — как правильно отобразить наследование в реляционную модель.
Hibernate предлагает 3 варианта ее отображения такой объектной модели:
1. Все наследники лежат в одной таблице:
**@Inheritance(strategy = InheritanceType.SINGLE\_TABLE)**
В этом случае, общие поля и поля наследников лежат в одной таблице. Используя такую стратегию мы избегаем join-ов при выборе сущностей. Из минусов стоит отметить, что во-первых, мы не можем в реляционной модели задать “NOT NULL” ограничение для колонки “force” и во-вторых, мы теряем третью нормальную форму. (появляется транзитивная зависимость неключевых атрибутов: force и disc).
Кстати, в том числе и по этой причине есть 2 способа указать not null ограничение у поля — [NotNull](https://habr.com/users/notnull/) отвечает за валидацию; @Column(nullable = true) — отвечает за not null ограничение в базе данных.
На мой взгляд это лучший вариант отображения объектной модели в реляционную.
2. Специфичные для сущности поля лежат в отдельной таблице.
**@Inheritance(strategy = InheritanceType.JOINED)**
В этом случае общие поля хранятся в общей таблице, а специфичные для дочерних сущностей — в отдельных. Используя эту стратегию у нас появляется JOIN при выборе сущности, но теперь мы сохраняем третью нормальную форму, а также можем указать NOT NULL ограничение в базе данных.
3. Для каждой сущности есть своя таблица
**@InheritanceType.TABLE\_PER\_CLASS**
В этом случае у нас нет общей таблицы. Используя эту стратегию, при полиморфных запросах мы используется UNION. У нас появляеются проблемы с генераторами первичных ключей и другими ограничениями целостности. Данный тип отображения наследования строго не рекомендуется использовать.
На всякий случай упомяну про аннотацию — @MappedSuperclass. Она используется когда вы хотите “спрятать” общие поля для нескольких сущностей объектной модели. При этом сам аннотированный класс не рассматривается как отдельная сущность.
### Проблема 2. Отношение композиции в ООП
Возвращаясь к нашему примеру заметим, что в объектной модели мы вынесли профиль пользователя в отдельную сущность — Profile. Но в реляционной модели мы не стали выделять под нее отдельную таблицу.
Отношение OneToOne чаще является плохой практикой, т.к. в селекте у нас появляется неоправданный JOIN (даже указав fetchType=LAZY в большинстве случаев у нас JOIN останется — эту проблему обсудим позже).
Для отображения композиции в общую таблицу существуют аннотации @Embedable и @Embeded. Первая ставится над полем, а вторая над классом. Они взаимозаменяемые.
Entity Manager
--------------
Каждый экземпляр EntityManager-а (EM) определяет сеанс взаимодействия с базой данных. В рамках экземпляра EM-а, существует кэш первого уровня. Тут я выделю следующие значимые моменты:
1. **Захват соединения с БД**
Это просто интересный момент. Hibernate захватывает Connection не во время получения EM-а, а во время первого обращения к БД или открытия транзакции(хотя и эту проблему [можно решить](https://vladmihalcea.com/why-you-should-always-use-hibernate-connection-provider_disables_autocommit-for-resource-local-jpa-transactions/)). Это сделано с целью сократить время занятого коннекшена. Во время получения EM-a проверяется наличие JTA транзакции.
2. **У persisted сущности всегда есть id**
3. **Сущности описывающие одну строчку в БД эквивалентны по ссылке**
Как было сказано выше, у EM-а существует кэш первого уровня, объекты в нем сравниваются по ссылке. Соответственно возникает вопрос — какие поля использовать для переопределения equals и hashcode? Рассмотрим следующие варианты:
* Использовать все поля. Плохая идея, т.к. equals может затронуть LAZY поля. Кстати, это справедливо и для метода toString.
* Использовать только id. Нормальная идея, но тоже есть нюансы. Так как чаще всего для новых сущностей id проставляет генератор в момент persist-а. Возможна следующая ситуация:
```
Entity foo = new Entity(); // создаем сущность (id = null)
set.put(foo); // добавляем в hashset
em.persist(foo); // persist сущности (id = some value)
set.contains(foo) == false // т.к. hashCode вернул другое значение
```
* Использовать бизнес ключ (грубо говоря — поля, которые уникальные и NOT NULL). Но и этот вариант бывает не всегда удобен.
Кстати, раз уж заговорили о NOT NULL и UNIQUE, то иногда удобно сделать публичный конструктор с NOT NULL аргументами, а конструктор без аргументов protected.
* Вообще не переопределять equals и hashcode.
4. **Как работает flush**
Flush — выполняет накопившиеся insert-ы, update-ы и delete-ы в БД. По-умолчанию flush выполняется в случаях:
* Перед выполнением query (за исключением em.get) — это нужно чтобы соблюсти принцип ACID. Например: мы поменяли дату рождения у штурмовика, а потом захотели получить количество совершеннолетних штурмовиков.
Если мы говорим о CriteriaQuery или JPQL, то flush выполнится в случае если запрос затрагивает таблицу, чьи сущности есть в кэше первого уровня.
* При коммите транзакции;
* Иногда при persist-е новой сущности — в случае когда мы можем получить ее id только через insert.
А теперь небольшой тест. Сколько операций UPDATE выполнится в этом случае?
```
val spaceCraft = em.find(SpaceCraft.class, 1L);
spaceCraft.setCoords(...);
spaceCraft.setCompanion( findNearestSpaceCraft(spacecraft) );
```
Под операцией flush скрывается интересная фича hibernate — он пытается снизить время блокировки строк в БД.
Также отмечу, что есть разные стратегии операции flush. Например можно запретить “сливать” изменения в БД — он называется MANUAL (он также отключает механизм dirty checking).
5. **Dirty Checking**
Dirty Checking — это механизм, выполняемый во время операции flush. Его цель найти сущности, которые изменились и обновить их. Чтобы реализовать такой механизм, hibernate должен хранить оригинальную копию объекта (то с чем будет сравниваться актуальный объект). Если быть точнее, то hibernate хранит копию полей объекта, а не сам объект.
Тут стоит отметить, что если граф сущностей большой, то операция dirty checking-а может стоить дорого. Не стоит забывать о том, что hibernate хранит 2 копии сущностей (грубо говоря).
С целью “удешевить” этот процесс пользуйтесь следующими фичами:
* em.detach / em.clear — открепляют сущности от EntityManager-а
* FlushMode=MANUAL- полезен в операциях чтения
* [Immutable](https://habr.com/users/immutable/) — также позволяет избежать операций dirty checking
6. **Транзакции**
Как известно hibernate позволяет обновлять сущности только внутри транзакции. Больше свободы предлагают операции чтения — их мы можем выполнять не открывая явно транзакцию. Но в этом как раз и вопрос, стоит ли для операций чтения открывать транзакцию явно?
Приведу несколько фактов:
* Любой statement выполняется в БД внутри транзакции. Если даже мы ее явно не открыли. (auto-commit mode).
* Как правило мы не ограничиваемся одним запросом к БД. Например: для получения первых 10 записей вы вероятно захотите вернуть количество записей всего. А это уже почти всегда 2 запроса.
* Если мы говорим про spring data, то методы репозитория транзакционны [по-умолчанию](https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#transactions), при этом методы чтения — read-only.
* Спринговая аннотация @Transactional(readOnly=true) также влияет на FlushMode, точнее Spring переводит его в статус MANUAL, тем самым хибернейт не будет выполнять dirty-checking.
* Синтетические тесты с одним-двумя запросами к БД покажут, что auto-commit работает быстрее. Но в боевом режиме это может быть не так. ([отличная статья на эту тему](https://vladmihalcea.com/why-you-should-always-use-hibernate-connection-provider_disables_autocommit-for-resource-local-jpa-transactions/), + смотрите комментарии)
Если в двух словах: хорошей практикой является любое общение с БД выполнять в транзакции.
Генераторы
----------
Генераторы нужны для описания, каким способом первичные ключи наших сущностей будут получать значения. Давайте быстро пробежимся по вариантам:
* **GenerationType.AUTO** — выбор генератора осуществляется на основе диалекта. Не самый лучший вариант, так как тут как раз действует правило “явное лучше неявного”.
* **GenerationType.IDENTITY** — самый простой способ конфигурирования генератора. Он опирается на auto-increment колонку в таблице. Следовательно, чтобы получить id при persist-е нам нужно сделать insert. Именно поэтому он исключает возможность отложенного persist-а и следовательно batching-а.
* **GenerationType.SEQUENCE** — наиболее удобный случай, когда id мы получаем из sequence.
* **GenerationType.TABLE** — в этом случае hibernate эмулирует sequence через дополнительную таблицу. Не самый лучший вариант, т.к. в таком решении hibernate приходится юзать отдельную транзакцию и lock на строчку.
Поговорим немного подробнее про sequence. С целью повысить скорость работы hibernate использует разные алгоритмы-оптимизаторы. Все они нацелены на уменьшение количества общений с БД (количество round-trip-ов). Давайте посмотрим на них чуть подробнее:
* **none** — без оптимизаций. за каждым id дергаем sequence.
* **pooled и pooled-lo** — в этом случае наш сиквенс должен увеличиваться на некий интервал — N в БД(SequenceGenerator.allocationSize). А в приложении у нас появляется некий pool, значения из которого который мы можем присваивать новым сущностям не обращаясь к БД..
* **hilo** — для генерации ID алгоритм hilo использует 2 числа: hi (хранится в БД — значение, полученное от вызова sequence) и lo(хранится только в приложении — SequenceGenerator.allocationSize). На основе этих чисел интервал для генерации id рассчитывается так: [(hi — 1) \* lo + 1, hi \* lo + 1). По понятным причинам этот алгоритм считается устарелым и использовать его не рекомендуется.
Теперь давайте разберемся, как выбирается оптимизатор. У hibernate есть несколько генераторов sequence. Нам будет интересно 2 из них:
* **SequenceHiLoGenerator** — старый генератор, который использует hilo оптимизатор. Выбирается по-умолчанию, если у нас свойство hibernate.id.new\_generator\_mappings == false.
* **SequenceStyleGenerator** — используется по-умолчанию (если свойство hibernate.id.new\_generator\_mappings == true). Этот генератор поддерживает несколько оптимизаторов, но по-умолчанию используется pooled.
Так же настроить генератор можно аннотацией @GenericGenerator.
Deadlock
--------
Давайте разберем на примере псевдокода ситуацию, которая может привести к deadlock-у:
```
Thread #1:
update entity(id = 3)
update entity(id = 2)
update entity(id = 1)
Thread #2:
update entity(id = 1)
update entity(id = 2)
update entity(id = 3)
```
Для предотвращения таких проблем у hibernate есть механизм, который позволяет избежать deadlock-ов такого типа — параметр hibernate.order\_updates. В этом случае все update-ы будут упорядочены по id и выполнены. Также еще раз упомяну, что hibernate старается “отсрочить” захват коннекшена и выполнение insert-ов и update-ов.
Set, Bag, List
--------------
В hibernate есть 3 основных способа представить коллекцию связи OneToMany.
* Set — неупорядоченное множество сущностей без повторений;
* Bag — неупорядоченное множество сущностей;
* List — упорядоченное множество сущностей.
Для Bag в java core нет класса, который бы описывал такую структуру. Поэтому все List и Collection — являются bag-ом если не указана колонка, по которой наша коллекция будет сортироваться(аннотация OrderColumn. Не путать с SortBy). Использовать аннотацию OrderColumn крайне не рекомендую в силу плохой (на мой взгляд) реализации фичи — не оптимальные sql запросы, возможное наличие NULL-ов в листе.
Возникает вопрос, а что все-таки лучше использовать bag или set? Начнем с того, что при использовании bag-а возможны следующие проблемы:
* Если ваша версия hibernate ниже 5.0.8, то существует довольно серьезный баг — [HHH-5855](https://hibernate.atlassian.net/browse/HHH-5855) — при инсерте дочерней сущности возможно ее дублирование (в случае cascadType=MERGE and PERSIST);
* Если вы используете bag для отношения ManyToMany, то hibernate генерирует крайне не оптимальные запросы при удалении сущности из коллекции — он сначала удаляет все строки из связывающей таблицы, а потом выполняет insert;
* Hibernate не может выполнить одновременный fetch нескольких bag-ов для одной сущности.
В случае, когда вы хотите добавить к связи @OneToMany еще одну сущность, выгоднее использовать Bag, т.к. он для этой операции не требует загрузки всех связанных сущностей. Давайте посмотрим пример:
```
// используем bag
spaceCraft.getCrew().add( luke ); // весь экипаж не загружается из бд
// используем set
spaceCraft.getCrew().put( luke ); // весь экипаж загружается из бд
// хотя вышеописанный вариант связывания мне не очень нравится. На мой взгляд связь ManyToOne удобнее указывать так:
luke.setCurrentSpaceCraft( spaceCraft );
```
Сила References
---------------
Reference — это ссылка на объект, загрузку которого мы решили отложить. В случае отношения ManyToOne с fetchType=LAZY, мы получаем такой reference. Инициализация объекта происходит в момент обращения к полям сущности, за исключением id (т.к. значение этого поля нам известно).
Стоит отметить, что в случае Lazy Loading-а reference всегда ссылается на существующую строку в БД. Именно по этой причине большинство случаев Lazy Loading-а в отношениях OneToOne не работает — hibernate необходимо сделать JOIN для проверки существования связи и JOIN уже был, то hibernate загружает его в объектную модель. Если же мы укажем в OneToOne связи nullable=true, то LazyLoad должен заработать.
Мы можем и самостоятельно создать reference, используя метод em.getReference. Правда в таком случае нет гарантии, что reference ссылается на существующую строку в БД.
Давайте приведем пример использования такой ссылки:
```
// используем bag
spaceCraft.getCrew().add( em.getReference( User.class, 1L ) ); // весь экипаж не загружается из бд, пользователь тоже не будет загружен
```
На всякий случай напомню, что мы получим LazyInitializationException в случае закрытого EM-а или отсоединенной(detached) ссылки.
Дата и время
------------
Не смотря на то что в java 8 появилось прекрасное API для работы с датой и временем, JDBC API по прежнему позволяет работать только со старым API дат. Поэтому разберем некоторые интересные моменты.
Во-первых, нужно четко понимать отличия LocalDateTime от Instant и от ZonedDateTime. (Не буду растягивать, а приведу отличные статьи на эту тему: [первая](https://habr.com/post/274811/) и [вторая](https://habr.com/post/274905/))
**Если вкратце**LocalDateTime и LocalDate представляют обычный кортеж чисел. Они не привязаны к конкретному времени. Т.е. время посадки самолета хранить в LocalDateTime нельзя. А дату рождения через LocalDate вполне нормально. Instant же представляет точку во времени, относительно которой мы можем получить локальное время в любой точке на планете.
Более интересный и важный момент — как даты сохраняется в базу данных. Если у нас проставлен тип TIMESTAMP WITH TIMEZONE то проблем быть не должно, если же стоит TIMESTAMP (WITHOUT TIMEZONE) то есть вероятность, что дата запишется/прочитается неверная. (за исключением LocalDate и LocalDateTime)
Давайте разберемся почему:
Когда мы сохраняем дату, используется метод со следующей сигнатурой:
```
setTimestamp(int i, Timestamp t, java.util.Calendar cal)
```
Как видим тут используется старое API. Дополнительный аргумент Calendar нужен для того, чтобы преобразовать timestamp в строковое представление. т.е он хранит в себе timezone-у. Если Calendar не передается, то используется Calendar по-умолчанию с таймзоной JVM.
Решить эту проблему можно 3 способами:
* Устанавливать нужную timezone JVM
* Использовать параметр hibernate — hibernate.jdbc.time\_zone (добавлена в 5.2) — починит только ZonedDateTime и OffsetDateTime
* Использовать тип TIMESTAMP WITH TIMEZONE
Интересный вопрос, почему LocalDate и LocalDateTime не подпадают под такую проблему?
**Ответ**Для ответа на этот вопрос нужно понимать структуру класса java.util.Date (java.sql.Date и java.sql.Timestamp его наследники и их отличия в данном случае нас не волнуют). Date хранит дату в миллисекундах c 1970 года грубо говоря в UTC, но метод toString преобразует дату согласно системной timeZone.
Соответственно, когда мы получаем из базы данных дату без таймзоны, она отображатеся в объект Timestamp, так чтобы метод toString отобразил ее желаемое значение. При этом количество миллисекунд с 1970-го года может отличаться (в зависимости от временной зоны). Именно поэтому только локальное время отображается всегда корректно.
Также привожу в пример код, ответственный за преобразование Timesamp в LocalDateTime и Instant:
```
// LocalDateTime
LocalDateTime.ofInstant( ts.toInstant(), ZoneId.systemDefault() );
// Instant
ts.toInstant();
```
Batching
--------
По-умолчанию запросы отправляются в БД по одному. При включении batching-а hibernate сможет в одном запросе к БД отправлять несколько statement-ов. (т.е. batching сокращает количество round-trip-ов к БД)
Для этого необходимо:
* Включить batching и задать максимальное количество statement-ов:
hibernate.jdbc.batch\_size (Рекомендуется от 5 до 30)
* Включить сортировку insert-ов и update-ов:
hibernate.order\_inserts
hibernate.order\_updates
* Если мы используем версионирование, то нам также нужно включить
hibernate.jdbc.batch\_versioned\_data — тут будьте аккуратны, нужно чтобы jdbc driver умел отдавать количество строк, затронутых при update-е.
Так же напомню, про эффективность операции em.clear() — она отвязывает сущности от em-а, тем самым вы освобождаете память и сокращаете время на операцию dirty checking.
Если мы используем postgres, то можно так же сказать hibernate использовать [multi-raw insert](https://vladmihalcea.com/postgresql-multi-row-insert-rewritebatchedinserts-property/).
N+1 проблема
------------
Это достаточно изъезженная тема, поэтому пробежимся по ней быстро.
N+1 проблема — это ситуация, когда вместо одного запроса на выбор N книг происходит по меньшей мере N+1 запрос.
Самый простой способ решения N+1 проблемы это сделать fetch связанных таблиц. В этом случае у нас может возникнуть несколько других проблем:
* **Пагинация.** в случае отношений OneToMany hibernate не сможет указать offset и limit. Поэтому пагинация будет происходить in-memory.
* **Проблема декартова произведения** — это ситуация, когда на выбор N книг с M главами и K авторами база данных возвращает N\*M\*K строк.
Есть и другие способы решения N+1 проблемы.
* **FetchMode** — позволяет изменить алгоритм загрузки дочерних сущностей. В нашем случае нас интересуют следующие:
+ **FetchType.SUBSELECT** — загружает дочерние записи отдельным запросом. Минус в том, что вся сложность основного запроса повторяется в subselect-е.
+ **BATCH (FetchType.SELECT + аннотация BatchSize)** — так же загружает записи отдельным запросом, но вместе subquery делает условие типа WHERE parent\_id IN (?, ?, ?, …, N)Стоит отметить, что при использовании fetch в Criteria API, FetchType игнорируется — всегда используется JOIN
* **JPA EntityGraph и Hibernate FetchProfile** — позволяют вынести правила загрузки сущностей в отдельную абстракцию — на мой взгляд обе реализации неудобны.
Тестирование
------------
В идеале development окружение должно предоставлять как можно больше полезной информации о работе hibernate и о взаимодействии с БД. А именно:
* Логирование
+ org.hibernate.SQL: debug
+ org.hibernate.type.descriptor.sql: trace
* Статистика
+ hibernate.generate\_statistics
Из полезных утилит можно выделить следующее:
* **DBUnit** — позволяет описывать состояние БД в XML формате. Иногда бывает удобно. Но лучше еще раз подумайте надо ли оно вам.
* DataSource-proxy
+ **p6spy** — одно из самых старых решений. предлагает расширенное логирование запросов, время выполнения, итд
+ **com.vladmihalcea:db-util:0.0.1** — удобная утилита для поиска N+1 проблем. Также она позволяет логировать запросы. В состав входит интересная аннотация [Retry](https://habr.com/users/retry/), которая повторяет попытку выполнить транзакцию в случае OptimisticLockException.
+ **Sniffy** — позволяет сделать assert на количество запросов через аннотацию. В некотором плане изящнее, чем решение от Влада.
Но еще раз повторюсь, что это только для development, на production это включать не стоит.
Литература
----------
* [Доклад Николая Алименков — Сделаем Hibernate снова быстрым](https://youtu.be/b52Qz6qlic0) — именно этот доклад меня вдохновил изучить hibernate глубже. Ниже представлены ресурсы, которые я использовал.
* [Книга “Java Persistence API и Hibernate”](https://www.ozon.ru/context/detail/id/141415731/)
* [Официальная документация](http://docs.jboss.org/hibernate/orm/5.3/userguide/html_single/Hibernate_User_Guide.html)
* [Блог Влада М.](https://vladmihalcea.com)
* [Java Weakly Digest](http://www.baeldung.com/java-web-weekly) — ежедневный дайджест (косвенно относится к теме) | https://habr.com/ru/post/416851/ | null | ru | null |
# Устанавливаем FAR в Ubuntu, используя Wine
***Любителям «священных войн» вход строго воспрещен!***
Для многих людей FAR оставался и остается одной из самых любимых программ. Достоинств у нее много, недостатков тоже. Но этот топик не про это. Многие хотят продолжать использовать FAR и дальше, но уже под Linux'ом.
**Что нам нужно?**
* [Ubuntu Lucid Lynx 10.04](http://www.ubuntu.com/)
* [FAR manager 2.0](http://farmanager.com/download.php?l=ru) (я обычно качаю 7zip архив, и далее речь пойдет именно про него)
* Wine 1.2
Поехали? (Осторожно, много картинок)
#### Установка программы
Для начала нам нужно распаковать архив с программой. Для этого заходим в центр приложений (Applications > Ubuntu Software Center), в окне поиска набираем 7zip, и устанавливаем нужный нам пакет.
Потом устанавливаем wine. В центре приложений в окне поиска набираем wine. Устанавливать нужно **Wine Microsoft Compatibility Layer (Beta release)**. Это более свежая версия этой программы.
В домашней директории я сделал папку *wine*, куда потом распаковал файлы FAR'a
Нажимаем правой кнопкой мыши на exe-файле FAR'а, и проверяем его свойства, установлен ли чекбокс «Allow executing file as program» (Разрешить запуск файла на исполнение) в правах доступа.
Если все нормально, то закрываем окно свойств, и запускаем наш любимый FAR.
Теперь берем напильник, и будем из комбайна делать танк. Для начала нужно восстановить привычные действия по правой кнопке мыши.
Нажимаем правую кнопку и устанавливаем галочку возле пункта **Shift**
Нажимаем кнопку **Ok** и говорим, что хотим сохранить параметры для всех сессий.
Повторно вызвать эту панель настроек можно будет при помощи правой кнопки мыши и Shift'а.
Настройку шрифтов пока не трогаем.
#### Проблема Alt+F1 и Alt+F2
Далее нас ждет следующая проблема. При нажатии **Alt+F1** и **Alt+F2** будут вызываться системные функции, а не привычные всем диалоговые окна. Эту проблему решаем путем переназначения этих кнопок в системе. Заходим в System > Preferences > Keyboard Shortcuts
Находим упоминание про **Alt+F1** и **Alt+F2**, и переопределяем на другое сочетание клавиш. Убрать назначение клавиш можно при помощи **backspace**. Пункту **«Show the panel's main menu»** лучше установить какое-то конкретное сочетание клавиш, иначе система будет использовать **Alt+F1**
Возвращаемся в наш FAR и пробуем смену дисков. Работает прекрасно.
#### Шрифты и их сглаживание
Займемся второй проблемой — шрифтами. Для начала открываем консоль (Applications > Accessories > Terminal или Ctrl+Alt+T).
Как я уже говорил, я создал папку *wine* в домашней директории.
Набираем в консоли
`cd wine`
потом
`wget www.kegel.com/wine/winetricks`
и потом
`sh winetricks fontsmooth-rgb allfonts`
Перезапускаем FAR, и заходим в свойства программы, нажав Shift + правая кнопка мыши. Меняем шрифт на более подходящий, например на Andale Mono или Liberation Mono. Сохраняем настройки как и указано выше.
Вот что у меня получилось
Красота, да не очень. Цвет диалоговых окон немного темнее, чем под Windows, и это, если сильно напрягает, можно исправить в настройках цветового оформления FAR'а.
#### Ассоциация файлов с родными приложениями Linux'а
В домашней директории создаем файлик с названием **winenative**
Его содержимое должно быть такое
`#!/bin/sh
$1 "`wine winepath -u "$2"`"`
Сохраняем его, потом делаем следующее
`sudo chown root:root winanative
sudo chmod a+x winenative
sudo mv winenative /usr/bin/`
Изменили владельца, поставили права на исполнение и перенесли в папку */usr/bin/*
Далее, запускаем FAR и набираем в консоли **regedit**
В **HKEY\_CLASSES\_ROOT** ищем ключ **pngfile**, в нем будет **shell** > **open**
В **open** может быть **ddeexec**, который я удалял. Нам необходимо создать или изменить ключ **command**
Значением ключа вставляем `start /Unix /usr/bin/winenative eog "%1"`
Должно получиться вот так:
Аналогично повторяем для других типов, заменяя «Eye of Gnome» (eog) на другие приложения.
#### Ложка дегтя
* Плагин WinSCP не работает, но он и не нужен. Можно спокойно примонтировать удаленную файловую систему через *fuse* и работать дальше.
* Я так и не смог найти способ, как в консоли FAR'а выполнять команды linux консоли. Windows ищет команду в неком списке доступных команд, и по определенному пути. Как заставить это все транслировать в тот же bash, я не нашел.
* Иногда FAR крошится на редактировании файлов.
**UPD:** Указал в требованиях к установке wine | https://habr.com/ru/post/102362/ | null | ru | null |
# Как я избавлялся от Google на Android
Недавно на работе получил задачу от руководителя: сделай так чтобы телефон android не сливал данные гуглу. Можете представить мой восторг (и предвкушение) ибо спустя 2 недели тестов я вполне уже чувствовал себя человеком который прошивает телефоны на радиорынке (ничего личного, просто не мой профиль). Прочел отличную [статью](https://habr.com/en/company/ruvds/blog/519668/) и понабравшись опыта решил немного дополнить. Статья кстати отличная, рекомендую к прочтению.
Давайте рассмотрим несколько альтернативных операционных систем якобы без сервисов гугла, и выясним действительно ли они не общаются с гуглом. Подготовился я к слову основательно, для тестов даже приобрел девайс "pixel 3", так как GrapheneOS работает только с устройствами от google.
* [GrapheneOS](https://grapheneos.org/)
* [LineageOS](https://lineageos.org/)
Хотел протестировать еще:
* [/e/](https://community.e.foundation/) Но к сожалению моего девайса не было в списке
* [PostmarketOS](https://postmarketos.org/) Та же проблема
* [PinePhone](https://www.pine64.org/pinephone/) Было желание приобрести тестовый девайс. Но после обзора на youtube, желание пропало, так как он очень тормозит, и сложно его представить в роли смартфона для повседневного пользования.
GrapheneOS
----------
На первый взгляд система позиционирует себя как максимально безопасная и анонимная. Есть пару нюансов которые мне не понравились:
1. Нет доступа к root
2. Отстукивание на серверы Google:
* HTTPS: <https://www.google.com/generate_204>
* HTTP: <http://connectivitycheck.gstatic.com/generate_204>
* HTTP fallback: <http://www.google.com/gen_204>
* HTTP other fallback: <http://play.googleapis.com/generate_204>
Ничего необычного, этот сервис называется [Captive portal](https://ru.wikipedia.org/wiki/Captive_portal) используется для андроид с 4 версии. При наличии root можно выбрать другие независимые сервера или на крайняк поднять свой. Но такой возможности нет и приходится довольствоваться услугами google. Также разработчик утверждает что использование других серверов в качестве альтернативы нежелательно, по причине того что телефон будет более узнаваем в толпе, но говорит, что такая функция находится в [разработке](https://github.com/GrapheneOS/os_issue_tracker/issues/198) (правда имеет маленький приоритет)
LineageOS
---------
LineageOS является более популярной операционной системой. Но к ней тоже очень много вопросов. Абсолютно чистая система умудряется стучать гуглу в особо крупных количествах. Вот данные которые я снял со своего маршрутизатора, и сделал небольшую табличку. Маршрутизатор снифил трафик с телефона 3 дня, повторюсь, что телефон я откатил до заводских настоек и ничего не устанавливал и никуда не логинился.
Существует несколько способов ограничить доступ телефона к google:
* Использование firewall. В моем случае я использовал afwall+, его можно скачать в магазине [f-droid](https://www.f-droid.org/) или же в aurora store, который можно скачать [там же](https://www.f-droid.org/)
* Второй способ, менее радикальный и более трудоемкий. Он заключается в подмене сервисов. Настройка на службах альтернатив google.
Каждый способ требует root права. Описывать как их получить не буду, так как есть огромное количество статей на эту тему, и в зависимости от модели телефона инструкция может меняться. Я использовал [magisk](https://magiskmanager.com/)
Использование firewall
----------------------
Ну с этим, думаю, понятно. Блокируем все, и разблокируем по мере необходимости (для AFwall+ понадобятся root права). В android 10 добавили модуль [Network Stack Permission Config module](https://source.android.com/devices/architecture/modular-system/networking). Если заблочить данный модуль то система будет говорить что у данной сети нет доступа к интернету.  
Тем не менее интернет будет работать в обычном режиме. Так как у меня гугловый девайс Pixel 3, то были подозрения что устройство общается с google на hardware уровне. Но они развеялись после того как заблокировал все и снял дамп с роутера. Результаты показали что за двое суток устройство дальше внутренней сети не ушло.
Подмена сервисов
----------------
Необходимо настроить следующие сервисы:
* DNS
* Captive Portals
* WebView
* Hostfile
DNS
---
По дефолту LineageOS использует гугловые dns 8.8.8.8, было бы не плохо заменить их на cloudflare 1.1.1.1. Идеальным решением будет использовать vpn и завернуть туда весь трафик, в противном случае для каждой wifi сети надо будет вбивать руками кастомные dns. Альтернативой является установка приблуды через magisk "CloudflareDNS4Magisk", или какой-либо другой с магазина, но там на свой страх и риск. Как по мне лучше с гугловыми dns, чем непонятным магазинным софтом.
Captive Portals
---------------
Captive portal — сетевой сервис, требующий от подключившегося к сети пользователя выполнить некоторые действия для получения доступа в Интернет. Обычно используется для взимания платы, аутентификации абонента либо показа рекламы. Настроим его что-бы он стучался не на google.
Дальнейшая инструкция подразумевает то, что вы уже получили root через [magisk](https://magiskmanager.com/)
---
Присоединяем телефон по USB, запускаем терминал (linux;macos) и заходим в shell, `./adb shell`, и переходим в режим админа `su`. Может отбить: permission denied, в этом случае заходим в magisk и даем shell рута.
Далее вводим следующие команды. Я выбрал заменить google на магазин f-droid
```
settings put global captive_portal_mode 0
settings put global captive_portal_detection_enabled 0
settings put global wifi_watchdog_on 0
settings put global wifi_watchdog_background_check_enabled 0
settings put global captive_portal_server f-droid.org
settings put global captive_portal_https_server "https://f-droid.org"
settings put global captive_portal_http_server "http://f-droid.org"
settings put global captive_portal_fallback_url "http://f-droid.org"
settings put global captive_portal_other_fallback_urls "http://f-droid.org"
```
Вы также можете выбрать другой сервер. Ниже будет предоставлено несколько альтернатив, либо же вы можете поднять свой собственный
```
http://captiveportal.kuketz.de
http://elementary.io/generate_204
http://httpstat.us/204
```
WebView
-------
Советую заменить браузер на "duck go browser" который можно найти на aurora store
Hosts
-----
Желательно заблокировать следующие сайты в файле hosts. Так как мы блокируем google нужно выбрать другой поисковик, предлагаю [этот](https://duckduckgo.com/).
```
google.com/gen_204
accounts.google.com:443
connectivitycheck.gstatic.com/generate_204
google.com:443
s3.amazonaws.com:433
collector-hpn.ghostery.net:443
cmp-cdn.ghostery.com:443
api.ghostery.net:443
cdn.ghostery.net:433
updates.signal.org:433
googleads.g.doubleclick.net:433
fonts.googleapis.com:433
api.cleanapk.org:433
clientservices.googleapis.com:443
ssl.google-analytics.com:443
bahn.de:443
deutschebahn.sc.omtrdc.net:443
assets.adobedtm.com:443
cdn.optimizely.com:443
settings.crashlytics:443
firebaseremoteconfig.googleapis.com:433
graph.facebook.com:433
http://xtrapath1.izatcloud.net/xtra3grcej.bin
http://xtrapath2.izatcloud.net/xtra3grcej.bin
http://xtrapath3.izatcloud.net/xtra3grcej.bin
```
Выводы:
-------
Огромное количество информации сливается даже при кастомных прошивках которые, позиционируют себя как свободные от google. А по факту когда снимаешь дамп трафика то мягко говоря удивляешься.
P.S.
----
Если вы выберете второй способ, то все-равно не пренебрегайте использованием firewall, я неделю проверял данные с роутера, пробовал разные варианты (что будет если заблокировать эту службу, а что если эту). Оказалось что это самый надежный способ. Как и любая настройка firewall, блокируем все, разблокируем по надобности.
P.P.S.
------
Изучал вопрос приватности и решил поделится с Хабром, так как Хабр часто делится со мной. Может кому-то это будет полезно. Спасибо если дочитали до конца. | https://habr.com/ru/post/520642/ | null | ru | null |
# Туториал по JUnit 5 - Аннотация @RepeatedTest
> Это продолжение туториала по JUnit 5. Введение опубликовано [здесь](https://habr.com/ru/post/590607/).
>
>
Аннотация `@RepeatedTest` используется для написания повторяющихся тестовых шаблонов, которые могут выполняться несколько раз в JUnit. Частоту повторения можно настроить как параметр аннотации `@RepeatedTest`.
**Оглавление**
1. Аннотация @RepeatedTest
* Синтаксис
* Методы жизненного цикла
2. Пользовательские отображаемые имена
3. Интерфейс RepetitionInfo
### 1. Аннотация @RepeatedTest
Аннотация *@RepeatedTest* используется для обозначения метода тестирования, который должен повторяться указанное количество раз с настраиваемым отображаемым именем.
Чтобы повторить тест с различными аргументами, рассмотрите возможность использования аннотации *@ParameterizedTest*.
#### 1.1. Синтаксис
Чтобы создать повторяемый тест, аннотируйте метод теста с помощью @RepeatedTest.
В данном примере тестовый метод использует *аннотацию @RepeatedTest (5)*. Это означает, что тест будет выполнен пять раз.
```
@DisplayName("Add operation test")
@RepeatedTest(5)
void addNumber(TestInfo testInfo) {
Calculator calculator = new Calculator();
Assertions.assertEquals(2, calculator.add(1, 1), "1 + 1 should equal 2");
}
```
#### 1.2. Методы жизненного цикла
Обратите внимание, что каждый вызов повторного теста ведет себя как выполнение обычного теста с полной поддержкой тех же обратных вызовов и расширений жизненного цикла.
Это означает, что аннотированные методы жизненного цикла *@BeforeEach*и *@AfterEach*будут вызываться при каждом вызове теста.
```
package com.howtodoinjava.junit5.examples;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.RepetitionInfo;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
@RunWith(JUnitPlatform.class)
public class RepeatedTestExample {
@BeforeAll
public static void init(){
System.out.println("Before All init() method called");
}
@BeforeEach
public void initEach(){
System.out.println("Before Each initEach() method called");
}
@DisplayName("Add operation test")
@RepeatedTest(5)
void addNumber(TestInfo testInfo, RepetitionInfo repetitionInfo)
{
System.out.println("Running addNumber test -> " + repetitionInfo.getCurrentRepetition());
Assertions.assertEquals(2, Calculator.add(1, 1), "1 + 1 should equal 2");
}
@AfterEach
public void cleanUpEach(){
System.out.println("After Each cleanUpEach() method called");
}
@AfterAll
public static void cleanUp(){
System.out.println("After All cleanUp() method called");
}
}
```
Результат вышеуказанного теста:
```
Before All init() method called
Before Each initEach() method called
After Each cleanUpEach() method called
Before Each initEach() method called
Running addNumber test -> 1
After Each cleanUpEach() method called
Before Each initEach() method called
Running addNumber test -> 2
After Each cleanUpEach() method called
Before Each initEach() method called
Running addNumber test -> 3
After Each cleanUpEach() method called
Before Each initEach() method called
Running addNumber test -> 4
After Each cleanUpEach() method called
Before Each initEach() method called
Running addNumber test -> 5
After Each cleanUpEach() method called
After All cleanUp() method called
```
### 2. Пользовательские отображаемые имена
Помимо указания количества повторений, мы можем дать каждому повторению собственное отображаемое имя. Это настраиваемое отображаемое имя может быть комбинацией {*статический текст + динамические заполнители*}.
В настоящее время поддерживаются три заполнителя (placeholder):
* `{displayName}`: отображаемое имя метода `@RepeatedTest`.
* `{currentRepetition}`: текущее количество повторений.
* `{totalRepetitions}`: общее количество повторов.
```
public class JUnit5AnnotationsExample
{
@DisplayName("Add operation test")
@RepeatedTest(value = 5, name = "{displayName} - repetition {currentRepetition} of {totalRepetitions}")
void addNumber(TestInfo testInfo) {
Assertions.assertEquals(2, Calculator.add(1, 1), "1 + 1 should equal 2");
}
}
```
Выполнение вышеуказанного теста дает вывод ниже:
Отображаемые имена повторных тестов JUnit 5Мы можем использовать один из двух предопределенных форматов, то есть `LONG_DISPLAY_NAME` и `SHORT_DISPLAY_NAME`. Последний формат используется по умолчанию, если он не указан.
* `RepeatedTest.LONG_DISPLAY_NAME` – {displayName} :: повторение {currentRepetition} из {totalRepetitions}
* `RepeatedTest.SHORT_DISPLAY_NAME` – повторение {currentRepetition} из {totalRepetitions}
```
@DisplayName("Add operation test")
@RepeatedTest(value = 5, name = RepeatedTest.LONG_DISPLAY_NAME)
void addNumber(TestInfo testInfo) {
Assertions.assertEquals(2, Calculator .add(1, 1), "1 + 1 should equal 2");
}
```
### 3. Интерфейс RepetitionInfo
Интерфейс [RepetitionInfo](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/RepetitionInfo.html) используется для получения информации о текущем повторении повторяющегося теста внутри `@RepeatedTest` методов, или методов жизненного цикла, таких как `@BeforeEach`, и `@AfterEach`.
```
public class JUnit5AnnotationsExample {
@BeforeEach
public void initEach(RepetitionInfo info){
int currentRepetition = info.getCurrentRepetition();
int totalRepetitions = info.getTotalRepetitions();
//Use information as needed
}
@DisplayName("Add operation test")
@RepeatedTest(value = 5, name="{displayName} :: repetition {currentRepetition} of {totalRepetitions}")
void addNumber(TestInfo testInfo) {
Calculator calculator = new Calculator();
Assertions.assertEquals(2, calculator.add(1, 1), "1 + 1 should equal 2");
}
@AfterEach
public void cleanUpEach(RepetitionInfo info){
int currentRepetition = info.getCurrentRepetition();
int totalRepetitions = info.getTotalRepetitions();
//Use information as needed
}
}
```
Хорошего изучения!!!
> [Скачать исходный код](https://github.com/lokeshgupta1981/Junit5Examples/tree/master/JUnit5Examples)
>
> | https://habr.com/ru/post/590927/ | null | ru | null |
# Unity3D 3.x Получение текущего активного окна
Недавно перед нашей командой встала довольно простая задача. Нам нужно было сделать перетаскивание вещи из инвентаря в другие окна (эквип, сундук). Если два окна находятся друг над другом, то вещь должна упасть в то окно, которое выше.
Бегло осмотрев список свойств в классе GUI я не нашел чего-либо подходящего, потом я осмотрел GUIUtility, и даже заглянул в GUILayout. Вообщем такого свойства нигде не было. Гугление по этому запросу выдает несколько вопросов в Q&A и пару скудных постов на офф. форуме которые заканчиваются ответами в стиле «так сделать нельзя, но можно вручную отслеживать по какому окну нажали мышкой и заполнять переменную активного окна самостоятельно».
Нам не подошло ничего из того что там предлагали, но один парень натолкнул меня на интересную мысль. Мы пишем код на C#, а значит можем пользоваться всеми плюсами этого языка, в том числе и С# Reflection
##### Кишки
Скачав мой любимый [Dis#](http://netdecompiler.com/), я сразу полез в код функции **GUI.Window**
```
public static Rect Window(int id, Rect clientRect, GUI.WindowFunction func, string text)
{
return GUI.DoWindow(id, clientRect, func, GUIContent.Temp(text), GUI.skin.window, true);
}
internal static Rect DoWindow(int id, Rect clientRect, GUI.WindowFunction func, GUIContent title, GUIStyle style, bool forceRectOnLayout)
{
GUIUtility.CheckOnGUI();
GUI._Window _window = (GUI._Window)GUI._WindowList.instance.windows[id];
if (_window == null)
{
_window = new GUI._Window(id);
GUI._WindowList.instance.windows[id] = _window;
GUI.s_LayersChanged = true;
}
if (!_window.moved)
_window.rect = clientRect;
_window.moved = false;
_window.opacity = 1.0F;
_window.style = style;
_window.title.text = title.text;
_window.title.image = title.image;
_window.title.tooltip = title.tooltip;
_window.func = func;
_window.used = true;
_window.enabled = GUI.enabled;
_window.color = GUI.color;
_window.backgroundColor = GUI.backgroundColor;
_window.matrix = GUI.matrix;
_window.skin = GUI.skin;
_window.contentColor = GUI.contentColor;
_window.forceRect = forceRectOnLayout;
return _window.rect;
}
```
Ага, значит есть список окон, осталось выяснить в какой последовательности они отрисовываются, для этого заглянем в функцию **GUI.BringWindowToFront**
```
public static void BringWindowToFront(int windowID)
{
GUIUtility.CheckOnGUI();
GUI._Window _window1 = GUI._WindowList.instance.Get(windowID);
if (_window1 != null)
{
int i = 0;
foreach (GUI._Window _window2 in GUI._WindowList.instance.windows.Values)
{
if (_window2.depth < i)
i = _window2.depth;
}
_window1.depth = i - 1;
GUI.s_LayersChanged = true;
}
}
```
Все понятно, в классе GUI есть синглтон класс **\_WindowList** у которого есть список окон. У каждого окна есть **Depth**. Отрисовка происходит в порядке убывания **Depth**. Все что осталось узнать это какого типа этот список.
```
internal sealed class _WindowList
{
internal Hashtable windows;
internal static GUI._WindowList instance;
.......
```
Вот и узнали :)
##### Пишем функцию для выковыривания добра
Функция хорошо прокомментирована и надеюсь не нуждается в пояснении.
```
///
/// Функция определяет самое верхнее окно из списка
///
///
/// ID самого верхнего окна
///
///
/// Список ID окон
///
int GetTopmostId(List id\_list)
{
//Получаем тип GUI
Type guiType = typeof(GUI);
//Получаем тип списка окон
Type windowListType = guiType.Assembly.GetType("UnityEngine.GUI+\_WindowList");
//Получаем поле instance списка, в котором хранится его экземпляр (это синглтон)
FieldInfo windowListInstanceField = windowListType.GetField("instance", BindingFlags.NonPublic | BindingFlags.Static);
//Получаем значение поля, теперь нас есть экземпляр списка
object windowListInstance = windowListInstanceField.GetValue(null);
//Получаем поле спика с окнами
FieldInfo windowsField = windowListType.GetField("windows", BindingFlags.NonPublic | BindingFlags.Instance);
//Получаем сам список окон типа Hashtable
Hashtable hashtable = windowsField.GetValue(windowListInstance) as Hashtable;
//Осталось перебрать его и найти верхнее
int min = -1;
int window\_id = -1;
foreach(DictionaryEntry entry in hashtable)
{
int key = (int)entry.Key;
if (id\_list.Contains(key)) //сравнивать только если окно в нашем списке
{
//получаем значение поля глубина у окна
int depth = (int)entry.Value.GetType().GetField("depth", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(entry.Value);
if (min < 0 || depth < min)
{
min = depth;
window\_id = key;
}
}
}
return window\_id;
}
```
*Примечание: если вы собираетесь вызывать функцию каждый **OnGUI()** event, то рекомендую разбить ее на две части, и хранить **Hashtable** в переменной класса, чтобы каждый раз не терять время на выяснении кучи типов и полей.*
Для минусующих: альтернатив этому решению не существует, если нужно узнать на каком сейчас уровне находится окно, то это единственный способ | https://habr.com/ru/post/149603/ | null | ru | null |
# Автор сurl просит Microsoft удалить алиасы curl и wget из PowerShell
Позавчера компания Microsoft [опубликовала исходный код](https://habrahabr.ru/post/308076/) PowerShell. Таким образом, это средство автоматизации и конфигурирования на базе .NET Framework стало доступным под Linux.
Некоторые скептически относятся к стратегии «Microsoft любит Linux», которую декларирует редмондский гигант. Кое-кто считает, что консоль от Microsoft не нужна в операционной системе, в которой есть bash. Обычно это просто эмоциональные высказывания, но есть и вполне рациональные аргументированные возражения по существу. Например, разработчик программы `curl` Дэниель Стэнберг (Daniel Stenberg) вполне логично говорит, что наличие внутри PowerShell одноимённого алиаса `curl`, а также `wget` совершенно неуместно, потому что мешает запустить нормальные привычные программы.
«Алиасы curl и wget препятствуют использованию привычных инструментов командной строки, при этом даже близко не обеспечивают такую же функциональность, — [пишет](https://github.com/PowerShell/PowerShell/pull/1901#issue-171982204) Дэниель Стэнберг в пулл-реквесте к свежеопубликованному коду PowerShell на Github. — Они совершенно бесполезны для пользователей PowerShell, но вызывают путаницу для нынешних пользователей curl и wget».
Пулл-реквест Дэниеля Стэнберга поддержали 466 других пользователей Github. В самом деле, алиас `curl` внутри оболочки PowerShell вносит определённую путаницу для тех, кто специально установил `curl` под Windows и хочет запускать эту программу из командной строки.
Один из разработчиков PowerShell [ответил](https://github.com/PowerShell/PowerShell/pull/1901#issuecomment-240840910) на комментарий Стэнберга, что эти алиасы использовались в разных версиях PowerShell, а их удаление станет «ломающим изменением». Поэтому они отклоняют этот пулл-реквест, ибо он представляет собой «неприемлемые изменения» в соответствии с [условиями неприемлемых изменений](https://github.com/PowerShell/PowerShell/blob/master/docs/dev-process/breaking-change-contract.md), которые нарушают обратную совместимость и ломают существующие пользовательские скрипты.
Дэниелm Стэнберг вежливо [ответил](https://github.com/PowerShell/PowerShell/pull/1901#issuecomment-240842529), что на самом деле **добавление** этих алиасов в PowerShell стало «ломающим изменением» для людей, которые запускали `curl` и `wget` из консоли. «Ни один здравомыслящий человек всё равно не будет использовать эти алиасы, поскольку ваша замена `curl` и `wget` работает совершенно непохоже на оригинальные команды `curl` и `wget`. Эти алиасы только усложняют жизнь пользователям, которым нужны настоящие инструменты, и они не делают ничего хорошего для тех пользователей, которым эти инструменты не нужны».
Разработчиков PowerShell можно понять. Всем совершенно очевидно, и им тоже, что алиасы `curl` и `wget` неуместны, но существующая [многоступенчатая бюрократическая система](https://github.com/PowerShell/PowerShell/blob/master/docs/community/governance.md) не позволяет им сделать такое изменение по простому пулл-реквесту. В данный момент свободный проект PowerShell управляется комитетом из пяти мейнтейнеров, которые действуют с ведома менеджеров проекта, которые, в свою очередь, подчиняются более высокому руководству в корпорации. Такого рода значительные изменения требуют длительных согласований во всей корпоративной иерархии.
Разработчики [признают проблему](https://github.com/PowerShell/PowerShell/pull/1901#issuecomment-240847078), что когда добавили «алиасы для юниксовых команд», то под Windows эти алиасы мешают запустить нормальные программы. Это нужно исправить, но формально такое изменение является «ломающим», в соответствии с официальным документом. Сейчас мейнтейнеры проводят совещание, что делать с этими алиасами Linux и как решить проблему под Linux и под Windows.
В качестве временного решения они предлагают вручную удалить мешающие алиасы, добавив следующие строки в профиль:
`Remove-Item Alias:Curl
Remove-Item Alias:WGet` | https://habr.com/ru/post/308140/ | null | ru | null |
# Применяем визуальные эффекты к изображениям в Django
При написании собственного «инстаграма» появилась необходимость в наложении фильтров на изображение при аплоаде. Изначально, чтобы особо не нагружать сервер, было решено вынести процесс преобразования картинки на клиентскую сторону. Основная идея – загрузка изображения в канву, манипуляции над ним и выгрузка потока байт (результирующего изображения) на сервер. Для реализации была выбрана js-библиотека [CamanJS](http://camanjs.com/) , которая может работать как в браузере, так и на стороне сервера через NodeJS. Однако пришлось от нее отказаться из-за трех причин:
* CamanJS не поддерживается мобильными браузерами (Safari, Chrome в частности);
* CamanJS заставляет течь память в браузере (особенно при работе с крупными изображениями);
* CamanJS сильно тормозит в Firefox при наложении фильтров.
Затем была предпринята попытка использовать CamanJS на стороне сервера. Результат опять оказался неудовлетворительным:
* После преобразования изображение увеличивалось в 3-4 раза;
* Преобразование изображения происходило совсем не быстро.
В итоге пришлось полностью отказаться от CamanJS.
Для обработки изображений на серверной стороне самым оптимальным вариантом оказался программный комплекс [ImageMagick](http://www.imagemagick.org/), который обладает довольно богатым функционалом и имеет множество расширений для различных языков программирования. Поскольку наш проект работает на django, то нас, прежде всего, интересовали python-расширения для ImageMagick – PythonMagick и Wanda. Как выяснилось, они поддерживают не все возможности ImageMagick, часть графических эффектов просто отсутствует, поэтому мы воспользовались прямым вызовом imagemagick через subprocess.
Применение эффектов происходит через специальные bash-скрипты, которые были получены с помощью очень полезных ресурсов <http://www.fmwconcepts.com/imagemagick> — здесь лежат сами скрипты с описанием, <http://jqmagick.imagemagick.org> – а здесь можно поэкспериментировать с различными эффектами и подобрать параметры.
Сначала заходим на <http://jqmagick.imagemagick.org>, аплоадим картинку, выбираем нужный эффект, подбираем параметры к нему. Если все красиво и все нас устраивает, копируем пример команды для выполнения скрипта с необходимыми параметрами из нижнего поля раздела «options» (по дефолту правая нижняя часть интрефейса jqmagick). Например:
```
bash scripts/vintage1.sh -b 0 -c 35 -s roundrectangle -T torn -I grunge -C white output/8526-603.jpg output/3347-9458.jpg
```
Интересующий нас скрипт называется vintage1.sh. Перемещаемся на <http://www.fmwconcepts.com/imagemagick>, находим нужный скрипт, скачиваем его и не забываем выставить флажок «на исполнение». И вот таким образом подбираем все нужные нам эффекты.
Теперь все готово для программной реализации.
Итак, задача:
Дать возможность пользователям (в нашем случае это — продавцы на e-commerce площадке по продаже уникальных товаров) загружать изображения на сервер, применять к ним эффекты из заранее подготовленного набора с возможностью отображения результата.
### Загрузка изображения на сервер
Для загрузки изображения на сервер мы использовали js-библиотеку [filereader.js](http://bgrins.github.io/filereader.js/). Использование и пример конфигурации можно найти в спецификации для этой библиотеки. Непосредственную отправку файла на сервер мы реализовали с помощью метода send() oбъекта XMLHttpRequest после того, как файл будет полностью выгружен в объект FileReader браузера. Для этого определяем опцию «load»:
```
var opts = {
// …
load: function(e, file) {
var xhr = new XMLHttpRequest();
xhr.open('POST', '{% url upload_file %}', true);
xhr.onload = function() {
if (this.status == 200) {
// обрабатываем ответ от сервера после удачной загрузки
var resp = JSON.parse(this.response);
// сохраняем пути к оригинальному изображению и превью (для применения фильтров к нему)
filter_image = resp['image'];
filter_thumb = resp['thumb'];
}
};
xhr.send(file);
},
//…
};
```
Не сервере мы принимаем выгружаемое изображение, создаем его копию для превью и возвращаем клиенту название оригинальной картинки и название превью к ней, чтобы заполнить атрибут src элемента у превью.
```
import os
import datetime
from PIL import Image
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
import simplejson as json
from django.http import HttpResponse
from django.conf import settings
def upload_file(request):
max_size = (2560, 2048) # задаем максимальное разрешение для оригинала
thumb_size = (325, 325) # максимальное разрешение для превью
f_data = request.body
fake_file = StringIO()
fake_file.write(f_data)
fake_file.seek(0)
img = Image.open(fake_file)
img.thumbnail(max_size, Image.ANTIALIAS) # ужимаем при необходимости оригинал
tmp_dir = settings.TEMP_IMG_DIR # все временные изображения будем хранить в отведенном месте
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
# директории с изображениями будут группироваться по датам
inner_dir_name = datetime.datetime.now().strftime('%d.%m.%Y')
inner_dir = os.path.abspath(os.path.join(tmp_dir, inner_dir_name))
if not os.path.exists(inner_dir):
os.makedirs(inner_dir)
tmp_file_name = generate_tmp_file_name() # получение уникального имени для файла
thumb_tmp_file_name = 'thumb_' + tmp_file_name # для превью добавляем префикс
output = os.path.abspath(os.path.join(inner_dir, tmp_file_name))
output_thumb = os.path.abspath(os.path.join(inner_dir, thumb_tmp_file_name))
if not img.mode == 'RGB':
img = img.convert('RGB')
img.save(output, "JPEG") # преобразуем оригинал и сохраняем в jpeg для экономии места
img.thumbnail(thumb_size, Image.ANTIALIAS)
img.save(output_thumb, "JPEG") # аналогично и для превью
to_response = json.dumps({
'image': ''.join([settings.MEDIA_URL, '/'.join([settings.TEMP_IMG_DIR_NAME,
innder_dir_name, tmp_file_name])]),
'thumb': ''.join([settings.MEDIA_URL, '/'.join([settings.TEMP_IMG_DIR_NAME,
innder_dir_name, thumb_tmp_file_name])]),
})
return HttpResponse(to_response, mimetype="application/json")
```
Сам TEMP\_IMG\_DIR в setting.py определяется так:
```
# Директория для хранения временных картинок
TEMP_IMG_DIR = os.path.abspath(os.path.join(MEDIA_ROOT, 'temp_img'))
```
### Применение эффектов к изображению
Основная идея здесь заключается в том, что эффекты будут применяться не к оригинальному изображению, а к его превью, и лишь после финального нажатия на кнопку «Сохранить» выбранный эффект применится к самому изображению.
Функция применения эффекта на клиентской стороне:
```
function setFilter(filter_name) {
result_filter = filter_name
$.ajax({
url: '{% url set_filter %}',
method: 'POST',
data: {
'img_path': filter_thumb, // отправляем путь к превью
'filter_name': filter_name // и наименование фильтра
},
success: function(response) {
$('#result_img').attr('src', response); // отображаем результат
}
})
}
```
На серверной стороне определяем команды для применения эффектов и сопоставляем их с названиями фильтров, здесь удобно использовать словарь:
```
FILTERS_COMMAND = {
'f1': "bash_scripts/colortemp.sh -t 10950 {file_name} {output}",
'f2': "bash_scripts/colortemp.sh -t 5736 {file_name} {output}",
# …
'f8': "bash_scripts/colorfilter.sh -c sepia -m 1 -d 28 {file_name} {output}",
'f9': "bash_scripts/colorfilter.sh -c underwater -m 1 -d 20 {file_name} {output}"
}
```
Функция применения эффекта на стороне сервера:
```
import os
import sys
import subprocess
def apply_filter(img_path, filter_name, output=None):
if output is None:
output_file_name = ''.join([filter_name, '_', os.path.basename(img_path)])
output_file = os.path.abspath(os.path.join(img_path.replace(os.path.basename(img_path), ''), output_file_name))
if os.path.exists(output_file):
return output_file
else:
output_file = output
command = FILTERS_COMMAND[filter_name]
# Используем bash, стало быть, скобки должны быть в виде:
command = command.replace('(', '\(').replace(')', '\)')
command = command.format(file_name=img_path, output=output_file)
subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT)
return output_file
```
Функция apply\_filter вызывается обработчик set\_filter, который принимает 2 аргумента: путь к изображению и наименование фильтра, а возвращает — путь к измененному изображению.
После того, как пользователь определился с нужным эффектом, он нажимает кнопку «Сохранить», и вызывается функция set\_filter, в качестве аргумента передается сохраненный ранее путь к оригинальному изображению и результирующий эффект.
Напоследок приложу скрин того, как все это выглядит у нас:
 | https://habr.com/ru/post/215811/ | null | ru | null |
# Создание 1k/4k intro для Linux, часть 2
Не прошло и полгода! Как вы можете, поднапрягшись, вспомнить, [в прошлый раз](http://habrahabr.ru/post/134551/) мы остановились на унынии и обещании нырнуть в ассемблер.
Ну что же, пацан сказал — пацан сделал. Из этого аляповатого нагромождения букв вы узнаете, как можно инициализировать OpenGL-контекст в GNU/Linux в какие-то 450 байт, высвободив ещё больше места для разворачивания таланта.
Под катом вы узнаете, как в один килобайт нарисовать что-нибудь такое:
Заинтересованные пристёгиваются и вдавливают педаль в пол, а глаз — в экран.
Для начала, давайте поговорим об этом. Почему мы так плохи и никчёмны? Что же именно добавляет нам веса и тянет вниз, в пучины деградации?
Чтобы ответить на эти вопросы, нам потребуются инструменты для настоящих мужчин — readelf и objdump.
Расчехляем первый и натравливаем на оставшийся с прошлого раза файл intro — тот самый, который остаётся после обработки напильником-sstrip'ом:
```
$ readelf -a intro
ELF Header:
Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
Machine: Intel 80386
Version: 0x1
Entry point address: 0x8048250
Start of program headers: 52 (bytes into file)
Start of section headers: 0 (bytes into file)
Flags: 0x0
Size of this header: 52 (bytes)
Size of program headers: 32 (bytes)
Number of program headers: 8
Size of section headers: 40 (bytes)
Number of section headers: 0
Section header string table index: 0
There are no sections in this file.
There are no sections in this file.
Program Headers:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
PHDR 0x000034 0x08048034 0x08048034 0x00100 0x00100 R E 0x4
INTERP 0x000134 0x08048134 0x08048134 0x00015 0x00015 R 0x1
[Requesting program interpreter: /lib32/ld-linux.so.2]
LOAD 0x000000 0x08048000 0x08048000 0x005ac 0x005ac R E 0x1000
LOAD 0x000f4c 0x08049f4c 0x08049f4c 0x000c4 0x00100 RW 0x1000
DYNAMIC 0x000f4c 0x08049f4c 0x08049f4c 0x000a8 0x000a8 RW 0x4
GNU_STACK 0x000000 0x00000000 0x00000000 0x00000 0x00000 RW 0x4
GNU_RELRO 0x000f4c 0x08049f4c 0x08049f4c 0x000b4 0x000b4 R 0x1
PAX_FLAGS 0x000000 0x00000000 0x00000000 0x00000 0x00000 0x4
Dynamic section at offset 0xf4c contains 16 entries:
Tag Type Name/Value
0x00000001 (NEEDED) Shared library: [libdl.so.2]
0x00000004 (HASH) 0x804814c
0x6ffffef5 (GNU_HASH) 0x8048164
0x00000005 (STRTAB) 0x80481ac
0x00000006 (SYMTAB) 0x804817c
0x0000000a (STRSZ) 45 (bytes)
0x0000000b (SYMENT) 16 (bytes)
0x00000015 (DEBUG) 0x0
0x00000003 (PLTGOT) 0x8049ff4
0x00000002 (PLTRELSZ) 16 (bytes)
0x00000014 (PLTREL) REL
0x00000017 (JMPREL) 0x8048210
0x6ffffffe (VERNEED) 0x80481e0
0x6fffffff (VERNEEDNUM) 1
0x6ffffff0 (VERSYM) 0x80481da
0x00000000 (NULL) 0x0
There are no relocations in this file.
There are no unwind sections in this file.
Histogram for bucket list length (total of 1 buckets):
Length Number % of total Coverage
0 0 ( 0.0%)
1 0 ( 0.0%) 0.0%
2 1 (100.0%) 100.0%
No version information found in this file.
```
(конкретные цифры, размеры и смещения зависят от всего тулчейна и возраст ваших миль майская Варвара)
Что мы здесь видим? В самом начале, конечно же, стандартный ELF Header, из него слова не выкинешь. Далее мы видим, что sstrip почикал все section headers (упражнение: сравните вывод с readelf -a intro-orig, который до sstrip), что хорошо. Но дальше мы видим какой-то праздник program headers и dynamic section (at offset). Неужели они нам правда такие нужны в платье стоят красивые?
Спойлер: нет!\*
(\* — поправка: да, но не такие)
##### Разделываем эльфов
Давайте посмотрим, какого минимального размера можно соорудить корректный запускаемый эльф-файл. За основу возьмём то, что у нас есть сейчас, но просто выкинем все наши полезные кишочечки.
simple.c:
```
void _start(void)
{
asm(
"xor %eax,%eax\n"
"inc %eax\n"
"int $0x80\n"
);
}
```
Соберём его (скрипт взят из Прошлого):
```
cc -Wall -m32 -c simple.c -Os -nostartfiles -o simple-c.o && \
ld -melf_i386 -dynamic-linker /lib32/ld-linux.so.2 simple-c.o -o simple-c-orig && \
cp simple-c-orig simple-c && \
sstrip simple-c && \
cat simple-c | 7z a dummy -tGZip -mx=9 -si -so > simple-c.gz && \
cat unpack_header simple-c.gz > simple-c.sh && \
wc -c simple-c.sh && chmod +x simple-c.sh && \
./simple-c.sh
```
Смотрим на размеры получившихся и промежуточных файлов и замечаем следующее:
1. sstrip решает — размер стрипнутого simple-c (почти) в три раза меньше, чем размер simple-c-orig
2. сжатие почти не играет роли — сжатый файл с кодом распаковки занимает почти столько же, сколько и несжатый
3. (если дописать к ld параметр -s, то можно выиграть в размере нестрипнутого файла примерно на треть, никак не потеряв и не прибавив в размере промежуточного стрипнутого бинарника, и \_проиграть\_ 4 байта в размере финального сжатого)
Заглядывая в будущее можно заметить, что эти замечания будут бесполезны чуть менее, чем полностью, но мы-то ещё не в будущем!
Теперь можно натравить readelf на бинарник и посмотреть, что от него осталось, во что он превратился, кем он стал:
```
$ readelf -a simple-c
ELF Header:
Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
Machine: Intel 80386
Version: 0x1
Entry point address: 0x8048094
Start of program headers: 52 (bytes into file)
Start of section headers: 0 (bytes into file)
Flags: 0x0
Size of this header: 52 (bytes)
Size of program headers: 32 (bytes)
Number of program headers: 3
Size of section headers: 40 (bytes)
Number of section headers: 0
Section header string table index: 0
There are no sections in this file.
There are no sections in this file.
Program Headers:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x08048000 0x08048000 0x0009e 0x0009e R E 0x1000
GNU_STACK 0x000000 0x00000000 0x00000000 0x00000 0x00000 RW 0x4
PAX_FLAGS 0x000000 0x00000000 0x00000000 0x00000 0x00000 0x4
There is no dynamic section in this file.
There are no relocations in this file.
There are no unwind sections in this file.
No version information found in this file.
```
Так, sstrip вроде бы и молодчина, раздел нашу эльф-девицу, снял все эти ненужные заголовки секций. Но при этом наша дама ещё не готова — на ней ещё есть лифчик (заголовки GNU\_STACK и PAX\_FLAGS) и трусы, которые можно обнаружить, если обратить внимание на то, что FileSiz заголовка LOAD почему-то меньше, чем размер самого файла, что значит, что это не трусы вовсе, а просто мусор в конце файла, который необходимо постанывая сорвать.
Кроме того, если быть совсем уж придирчивым и декомпилировать (objdump -D, будет работать только на нестрипнутом файле, т.к. objdump читает section headers, а не program) то, что нам тут нагенерили, в высшей степени необходимо заметить не первой свежести носки из чуть более чем полностью вредных пролога и эпилога функции:
```
00 55 push ebp
01 89e5 mov ebp, esp
03 31c0 xor eax, eax
05 40 inc eax
06 cd80 int 0x80
08 5d pop ebp
09 c3 ret
```
Соотношение 5 байт «полезного» кода к 5 — бесполезного так же не может греть наши юные сердца. А что будет греть наши юные сердца? Горящие спрессованные останки динозавров и болот. В эти самые спрессованные болота и предлагаю нам с вами, мой любознательный читатель, погрузиться.
##### Делаем эльфа пальцем
Как оказывается, собрать эльфа из ничего довольно несложно, надо всего-то-лишь выключить старкрафт, открыть файл /usr/include/elf.h, ничего не понять, загуглить файл elf.pdf, прочитать его по диагонали и сорвать с кончиков пальцев примерно следующее:
```
bits 32 ; работаем в 32-битном режиме
org 0x00040000 ; эта константа автоматически прибавляется к смещениям всех меток, также, именно это значение будет лежать в спец-константе $$
; Почему здесь лежит именно такое значение? А хер его знает. (см ниже)
; начало elf-заголовка
db 0x7f, 'ELF' ; magic для опознавания файла, иначе система не поймёт, что это ELF
db 1 ; EI_CLASS = ELFCLASS32
db 1 ; EI_DATA ELFDATA2LSB
db 1 ; EI_VERSION = EV_CURRENT
times 9 db 0 ; 9 неиспользуемых байт, которые можно загадить мусором и не переживать об этом
dw 2 ; e_type = ET_EXEC -- запускаемый файл
dw 3 ; e_machine = EM_386
dd 1 ; e_version = EV_CURRENT
dd _start ; e_entry -- адрес точки входа, с этого места начнётся выполнение программы
dd phdrs - $$ ; e_phoff -- смещение относительно начала файла, по которому находятся program headers
dd 0 ; e_shoff -- --//-- section headers, коих у нас, к слову, нет, поэтому 0
dd 0 ; e_flags -- не надо нам никаких флагов
dw ehsize ; e_ehsize -- размер ELF-заголовка (52 байта)
dw phsize ; e_phentsize -- размер одного program header (32 байта)
dw 1 ; e_phnum -- их количество
dw 0 ; e_shentsize -- размер section header
dw 0 ; e_shnum -- их количество (тютюшки)
dw 0 ; e_shstrndx -- что-то там со строками связано, нам не нужно
ehsize equ ($-$$) ; $ означает текущее смещение от начала файла (+значение org), поэтому в ehsize теперь лежит размер elf-заголовка
phdrs: ; начало program header
dd 1 ; p_type = PT_LOAD -- тип заголовка "загрузи кусок файла мне в память, скотина"
dd 0 ; p_offset -- смещение относительно начала файла, откуда читать
dd $$ ; p_vaddr -- адрес в памяти, куда писать
dd $$ ; p_paddr -- физический адрес, какая-то платформенно-специфичная фигота, я сам не разобрался, поэтому давайте не будем выпендриваться и просто повторим за мной
dd file_size ; p_filesz -- размер куска файла, который будем загружать в память
dd file_size ; p_memsz -- размер этого куска в памяти. Если больше, чем e_filesz, будет полиномиально интерполироваться побайтно. Если меньше -- преобразовываться ФНЧ Чебышева второго рода 6 порядка. Шутка. ЛОЛ!!11 На самом деле, если больше, то остаток будет забиваться нулями. А если меньше И ТУТ СУКА ВЗРЫЩ КИШКИ ОБ СТЕНУ МОЗГИ ГОВНО РАСЧЛЕНЁНКА.
dd 7 ; p_flags (=PF_RWX) -- загруженные данные можно будет читать, исполнять и изменять.
dd 0x1000 ; p_align -- выравнивание, применяется и к смещению, и к адресу в памяти. 0x1000 является довольно безопасным значением
phsize equ ($-phdrs) ; аналогично рассчитываем размер program header
_start: ; поехали
xor eax, eax ; eax = 0
inc eax ; eax = 1 (exit syscall)
int 0x80 ; вызов syscall
file_size equ ($-$$) ; ну тут уже всё понятно должно быть
```
(На самом деле, вместо того, чтобы давать вот этот грубый, но слегонца откомментированный asm-файл, я хотел вам, мои лапочки ненаглядные, обнимаю, нарисовать большую схему ELF-формата, но потом понял, что это отложило бы статью еще на пару лет)
Компилировать этот файл нужно nasm'ом с директивой компиляции в «плоский» бинарник, без каких-либо лишних обвесок-заголовков:
```
$ nasm -f bin simple.asm -o simple-asm
```
Эта строчка создаст нам файл simple-asm размером 89 байт, который будет полным функциональным аналогом того 206-байтного монстра, что был создан нами ранее. Не говоря уже о том, что те 206 байт — это, на самом деле, 657 байт оригинального несжатого нестрипнутого безумия.
Можно
```
chmod +x simple-asm
```
и посмотреть, что он на самом деле валидный и даже запускается. Могу сказать, что 89 байт — далеко не предел, и можно этот файл удавить еще примерно в два раза — наложить elf header на единственный program header, и получить не то, чтобы супер-валидный эльф, но вполне себе запускающийся и имеющий размер меньше, чем сам elf header (последние 6 байт из него будут автоматически добиты нулями, как они и должны быть)[[1]](http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html). Невольно на ум приходит то, что под линуксом есть замечательные файлы /dev/fb0 и /dev/dsp, а значит можно делать интры в 128-256-512 байт DOS-style. Мы, впрочем, не будем здесь таким заниматься — это тема для отдельного нагромождения знаков.
А будем мы заниматься тем, что разберёмся, как подключить сюда OpenGL.
##### Демоническая линковка
Как мы, наверное, смутновато помним из предыдущей части, для создания OpenGL-контекста мы использовали библиотеку SDL, подключавшуюся динамически, как libSDL.so. Кроме неё нам, разумеется, нужен ещё и сам OpenGL, который идёт в виде библиотеки libGL.so.
Нетрудно, как говорится, видеть, что нам нужно научиться заставлять уметь иметь возможность наш самопальный бинарник динамически линковаться с чем бы то ни было.
Механизм динамической линковки под линуксом на низком уровне очень смешной. Система при загрузке бинарника обнаруживает у него program header с типом PT\_INTERP, который указывает на имя файла интерпретатора. «Да пошли вы в жопу со своей этой динамической линковкой, сами разбирайтесь, раз такие умные», — говорит система и вместо того, чтобы продолжить загружать наш бинарник, загружает интерпретатор и передаёт ему управление.
Дальнейшей загрузкой приложения занимается уже интерпретатор — он, как ни в чём ни бывало, самостоятельно загружает секции PT\_LOAD в процесс и, что самое важное, читает PT\_DYNAMIC, в котором находится ссылка на описание всего необходимого для динамической линковки — имена необходимых библиотек, функций, куда, и, что немаловажно, как их грузить. Формат данных, на которые ссылается PT\_DYNAMIC, сам по себе довольно простой: таблица пар двойных слов d\_tag и d\_val, где d\_tag — код параметра, а d\_val — его значение, которое для многих параметров является адресом в уже загруженном в память процессе (или что-то около того).
Какие же параметры и значения нужно указывать? Давайте вернёмся наверх к readelf-дампу нашего первоначального файла и посмотрим на всё ЭТО ЧТО ЗА ПОКЕМОН?! после строчки «Dynamic section at offset ...».
Страшно!
Успокоим себя той мыслью, что треть из них совершенно нам не понадобится. Волнение, впрочем, не отступает — оставшиеся-то поля всё равно страшные. Однако же, я не буду объяснять подробно их смысл — отчасти потому, что сам уже не помню (расковыривал это достаточно давно), a то, что помню, предпочёл бы забыть.
Поэтому вам, дорог(ой/ие) читател(ь/и) я привожу готовый рецепт, аккуратно посыпанный тонким слоем комментариев по вкусу. Пользуйтесь на здоровье.
Этот кусок добавляется к phdrs сразу после расчёта phsize:
```
dd 2 ; p_type = PT_DYNAMIC
dd dynamic - $$ ; p_offset
dd dynamic ; p_vaddr
dd dynamic ; p_paddr
dd dynamic_size ; p_filesz
dd dynamic_size ; p_memsz
dd 6 ; p_flags = PF_RW
dd 4 ; p_align
dd 3 ; p_type = PT_INTERP
dd interp - $$ ; p_offset
dd interp ; p_vaddr
dd interp ; p_paddr
dd interp_size ; p_filesz
dd interp_size ; p_memsz
dd 4 ; p_flags = PF_R
dd 1 ; p_align
; данные для PT_DYNAMIC
; только самый необходимый минимум
dynamic:
dd 1, st_libdl_name ; DT_NEEDED -- необходимо прилинковать библиотеку с именем, лежащим в st_libdl_name (индекс в таблице символов)
; опциональные рюшечки, просящие интерпретатор заранее проверить, все ли необходимые библиотеки на месте
;dd 1, st_libSDL_name
;dd 1, st_libGL_name
dd 4, dt_hash ; DT_HASH -- указатель на таблицу хешей
dd 5, dt_strtab ; DT_STRTAB -- указатель на таблицу строк. все ссылки на строки имеют смысл смещения относительно начала таблицы строк
dd 6, dt_symtab ; DT_SYMTAB -- указатель на таблицу символов
dd 10, dt_strtab_size ; DT_STRSZ -- размер таблицы строк
dd 11, dt_symtab_size ; DT_SYMENT -- размер таблицы символов
dd 17, dt_rel ; DT_REL -- указатель на таблицу релокаций
dd 18, dt_rel_size; DT_RELSZ -- размер таблицы релокаций
dd 19, 8 ; DT_RELENT -- размер одной записи в таблице релокаций
dd 0, 0 ; DT_NULL -- конец данных для DT_DYNAMIC
dynamic_size equ $ - dynamic
; данные для DT_HASH
; эти данные нужны для чего-то вроде оптимизации загрузки миллионов импортируемых
; функций из динамических библиотек, однако ж для наших двух функций это оверкилл
; поэтому здесь просто заглушка
dt_hash: dd 1, 3, 0, 0, 0, 0
; данные для DT_SYMTAB
; именно в этом месте мы говорим, какие функции нам нужно подгрузить динамически
dt_symtab:
; 0 -- первая запись пустая (зачем?!)
dd 0, 0, 0
dw 0, 0 ; SHN_UNDEF
; 1 'dlopen'
dd st_dlopen_name, 0, 0
dw 0x12 ; = ELF32_ST_INFO(STB_GLOBAL, STT_FUNC), т.е., короче говоря, тип символа -- глобальная функция
dw 0 ; SHN_UNDEF говорит, что этого символа у нас нет, и его надо искать вовне
; 2 'dlsym'
dd st_dlsym_name, 0, 0
dw 0x12, 0 ; --//--
dt_symtab_size equ $ - dt_symtab
; данные для DT_REL
; таблица релокаций. описывает, куда и как загружать адреса символов из таблицы символов
dt_rel:
dd rel_dlopen ; адрес, куда грузить
dd 0x0101 ; ELF32_R_INFO(1,R_386_32) : dt_symtab[1] ('dlopen'), тип = запиши адрес символа + r_addend(=0 у нас)
dd rel_dlsym ; --//--
dd 0x0201 ; ELF32_R_INFO(2,R_386_32) : dt_symtab[2] ('dlsym'), --//--
dt_rel_size equ $ - dt_rel
; сгруппируем строки вмете -- ожидаем, что так они будут лучше паковаться
; данные для DT_STRTAB
; таблица строк. в ней лежит всё, необходимое для PT_DYNAMIC -- названия библиотек и имена функций
dt_strtab:
st_libdl_name equ $ - dt_strtab ; адрес строки относительно начала таблицы строк
db 'libdl.so.2', 0 ; все строки -- нуль-терминированные
st_dlopen_name equ $ - dt_strtab
db 'dlopen', 0
st_dlsym_name equ $ - dt_strtab
db 'dlsym', 0
dt_strtab_size equ $ - dt_strtab
; стандартный линуксовый интерпретатор для динамической линковки
interp: db '/lib/ld-linux.so.2', 0
interp_size equ $ - interp
```
Помимо этого надо поправить следующее:
1. очевидно, изменить e\_phnum на 3
2. добавить в самый конец файла
```
; BSS-секция, в ней лежат неинициализированные данные
absolute $
bss:
; резервируем место под адреса функций
rel_dlopen: resd 1
rel_dlsym: resd 1
mem_size equ ($-$$)
```
3. в PT\_LOAD-заголовке p\_memsz установить в mem\_size
Всё, теперь наш рукотворный эльф может линковаться динамически. Проверим это.
Раз уж это более не просто тест, а потенциальная интра, переименуем файл в intro.asm. Соберём его:
```
$ nasm -f bin intro.asm -o intro && chmod +x intro
```
И запустим через strace, чтобы проверить, что он действительно пытается читать всякие so'шечки:
```
$ strace ./intro
execve("./intro", ["./intro"], [/* 67 vars */]) = 0
[ Process PID=24135 runs in 32 bit mode. ]
...
open("/lib32/libdl.so.2", O_RDONLY) = 3
...
```
Теперь можно посмотреть и на размер файла — 368 несжатых байт. Можете самостоятельно проверить, что обычным способом (cc+ld) аналогичный несжатый файл сразу раздуется до 4 килобайт.
Сколько же будет весить сжатый файл?
```
nasm -f bin intro.asm -o intro && chmod +x intro && \
cat intro | 7z a dummy -tGZip -mx=9 -si -so > intro.gz && \
cat unpack_header intro.gz > intro.sh && \
wc -c intro.sh && chmod +x intro.sh && \
./intro.sh
```
254 байта.
Но это он еще ничего не делает.
##### Пусть делает!
Теперь, как только мы заполучили в своё распоряжение dlopen и dlsym, можно наконец-то уже загрузить какие-нибудь функции из libSDL и libGL и попробовать что-нибудь эдакое накалякать.
Особо не выпендриваемся и просто портируем на ассемблер всё то, что мы делали на сях:
```
; имена библиотек и функций, которые нужно загрузить ручками
libs_to_dl:
st_libSDL_name equ $ - dt_strtab
db 'libSDL-1.2.so.0', 0 ; самое кросс-дистрибутивное название библиотеки, которое мне удалось выяснить эмпирически
db 'SDL_Init', 0
db 'SDL_SetVideoMode', 0
db 'SDL_PollEvent', 0
db 'SDL_GetTicks', 0
db 'SDL_ShowCursor', 0
db 'SDL_GL_SwapBuffers', 0
db 'SDL_Quit', 0
db 0 ; два нуля подряд = конец библиотеки
st_libGL_name equ $ - dt_strtab
db 'libGL.so.1', 0
db 'glViewport', 0
db 'glCreateShader', 0
db 'glShaderSource', 0
db 'glCompileShader', 0
db 'glCreateProgram', 0
db 'glAttachShader', 0
db 'glLinkProgram', 0
db 'glUseProgram', 0
db 'glRectf', 0
db 0, 0 ; три нуля подряд = конец загрузки
_start: ; поехали
mov ebp, bss ; пускай ebp всё время указывает на bss -- будет удобно, поверьте!
; супер-удобные штуки, см далее
%define BSSADDR(a) ebp + ((a) - bss)
%define F(f) [ebp + ((f) - bss)]
; начнём загрузку функций
mov esi, libs_to_dl+1 ; +1, т.к. ld_load ожидает, что мы уже вгрызлись на один символ в строку
lea edi, [BSSADDR(libs_syms)] ; edi = адрес места, куда следует аккуратно сохранять адреса функций
ld_load:
dec esi ; в этом месте мы уже вгрызлись в строку на 1, поэтому отступим назад
; подготовим параметры функции dlopen, они передаются через стек
push 1 ; RTLD_LAZY
push esi ; адрес имени библиотеки
call F(rel_dlopen) ; eax = dlopen([esi], 1)
; обратите внимание, что здесь мы ~~не чистим после себя~~засираем стек и РАДУЕМСЯ ЭТОМУ
mov ebx, eax ; сохраним то, что dlopen нам вернул, в ebx
; скипаем все до 0
ld_skip_to_zero:
lodsb
test al, al
jnz ld_skip_to_zero
; если следующий тоже \0 то конец текущей библиотеки
lodsb
test al, al
jz ld_second_zero
dec esi ; опять отматываемся на 1 назад
push esi ; начало строки с названием функции
push ebx ; возвращенный из dlopen указатель на загруженную библиотеку
call F(rel_dlsym) ; eax = dlsym([ebx], [esi])
stosd ; запишем eax (возвращенный указатель на функцию) в [edi], edi += 4
jmp ld_skip_to_zero ; перемотаем до следуюшего нуля
ld_second_zero:
; если третий не ноль, то подгрузим что-нибудь еще!
lodsb
test al, al
jnz ld_load
; здесь будет наша умопомрачительная интра!
; вон из Новосибирска!
xor eax, eax ; eax = 0
inc eax ; ex = 1 (exit syscall)
int 0x80 ; вызов syscall
file_size equ ($-$$) ; ну тут уже всё понятно должно быть
; BSS-секция, в ней лежат неинициализированные данные
absolute $
bss:
; резервируем место под адреса функций
libdl_syms:
rel_dlopen: resd 1
rel_dlsym: resd 1
libs_syms:
SDL_Init: resd 1
SDL_SetVideoMode: resd 1
SDL_PollEvent: resd 1
SDL_GetTicks: resd 1
SDL_ShowCursor: resd 1
SDL_GL_SwapBuffers: resd 1
SDL_Quit: resd 1
glViewport: resd 1
glCreateShader: resd 1
glShaderSource: resd 1
glCompileShader: resd 1
glCreateProgram: resd 1
glAttachShader: resd 1
glLinkProgram: resd 1
glUseProgram: resd 1
glRectf: resd 1
mem_size equ ($-$$)
```
Этот кусок надо вставить вместо всего того, что у нас происходит сразу после \_start, включая сам \_start.
Компилируем, получаем файл размером 455 байт, запускаем, проверяем, что он не падает. Если падает — пробуем раскомментировать DT\_NEEDED-строчки для libSDL и libGL, и смотрим, что происходит, страдаем и перестаём читать дальше.
Если всё хорошо, можно двигаться дальше и наконец-то уже инициализировать OpenGL с шейдерами. Здесь ничего особо хитрого (за исключением того, что написано в комментариях), мы просто повторяем на ассемблере то, что делали ранее на сях.
```
; nasm -f bin intro.asm -o intro && chmod +x intro && \
; cat intro | 7z a dummy -tGZip -mx=9 -si -so > intro.gz && \
; cat unpack_header intro.gz > intro.sh && \
; wc -c intro.sh && chmod +x intro.sh && \
; ./intro.sh
%define WIDTH 640
%define HEIGHT 360
%define FULLSCREEN 0
;%define FULLSCREEN 0x80000000
bits 32 ; работаем в 32-битном режиме
org 0x00040000 ; эта константа автоматически прибавляется к смещениям всех меток, также, именно это значение будет лежать в спец-константе $$
; Почему здесь лежит именно такое значение? А хер его знает. (см ниже)
; начало elf-заголовка
db 0x7f, 'ELF' ; magic для опознавания файла, иначе система не поймёт, что это ELF
db 1 ; EI_CLASS = ELFCLASS32
db 1 ; EI_DATA ELFDATA2LSB
db 1 ; EI_VERSION = EV_CURRENT
times 9 db 0 ; 9 неиспользуемых байт, которые можно загадить мусором и не переживать об этом
dw 2 ; e_type = ET_EXEC -- запускаемый файл
dw 3 ; e_machine = EM_386
dd 1 ; e_version = EV_CURRENT
dd _start ; e_entry -- адрес точки входа, с этого места начнётся выполнение программы
dd phdrs - $$ ; e_phoff -- смещение относительно начала файла, по которому находятся program headers
dd 0 ; e_shoff -- --//-- section headers, коих у нас, к слову, нет, поэтому 0
dd 0 ; e_flags -- не надо нам никаких флагов
dw ehsize ; e_ehsize -- размер ELF-заголовка (52 байта)
dw phsize ; e_phentsize -- размер одного program header (32 байта)
dw 3 ; e_phnum -- их количество
dw 0 ; e_shentsize -- размер section header
dw 0 ; e_shnum -- их количество (тютюшки)
dw 0 ; e_shstrndx -- что-то там со строками связано, нам не нужно
ehsize equ ($-$$) ; $ означает текущее смещение от начала файла (+значение org), поэтому в ehsize теперь лежит размер elf-заголовка
phdrs: ; начало program header
dd 1 ; p_type = PT_LOAD -- тип заголовка "загрузи кусок файла мне в память, скотина"
dd 0 ; p_offset -- смещение относительно начала файла, откуда читать
dd $$ ; p_vaddr -- адрес в памяти, куда писать
dd $$ ; p_paddr -- физический адрес, какая-то платформенно-специфичная фигота, я сам не разобрался, поэтому давайте не будет выпендриваться и просто повторим за мной
dd file_size ; p_filesz -- размер куска файла, который будем загружать в память
dd mem_size ; p_memsz -- размер этого куска в памяти. Если больше, чем e_filesz, будет полиномиально интерполироваться побайтно. Если больше -- преобразовываться ФНЧ Чебышева второго рода 6 порядка. Шутка. ЛОЛ!!11 На самом деле, если больше, то остаток будет забиваться нулями. А если меньше И ТУТ СУКА ВЗРЫЩ КИШКИ ОБ СТЕНУ МОЗГИ ГОВНО РАСЧЛЕНЁНКА.
dd 7 ; p_flags (=PF_RWX) -- загруженные данные можно будет читать, исполнять и изменять.
dd 0x1000 ; p_align -- выравнивание, применяется и к смещению, и к адресу в памяти. 0x1000 является довольно безопасным значением
phsize equ ($-phdrs) ; аналогично рассчитываем размер program header
dd 2 ; p_type = PT_DYNAMIC
dd dynamic - $$ ; p_offset
dd dynamic ; p_vaddr
dd dynamic ; p_paddr
dd dynamic_size ; p_filesz
dd dynamic_size ; p_memsz
dd 6 ; p_flags = PF_RW
dd 4 ; p_align
dd 3 ; p_type = PT_INTERP
dd interp - $$ ; p_offset
dd interp ; p_vaddr
dd interp ; p_paddr
dd interp_size ; p_filesz
dd interp_size ; p_memsz
dd 4 ; p_flags = PF_R
dd 1 ; p_align
; данные для PT_DYNAMIC
; только самый необходимый минимум
dynamic:
dd 1, st_libdl_name ; DT_NEEDED -- необходимо прилинковать библиотеку с именем, лежащим в st_libdl_name (индекс в таблице символов)
; опциональные рюшечки, просящие интерпретатор заранее проверить, все ли необходимые библиотеки на месте
;dd 1, st_libSDL_name
;dd 1, st_libGL_name
dd 4, dt_hash ; DT_HASH -- указатель на таблицу хешей
dd 5, dt_strtab ; DT_STRTAB -- указатель на таблицу строк. все ссылки на строки имеют смысл смещения относительно начала таблицы строк
dd 6, dt_symtab ; DT_SYMTAB -- указатель на таблицу символов
dd 10, dt_strtab_size ; DT_STRSZ -- размер таблицы строк
dd 11, 16 ; DT_SYMENT -- размер одной записи в таблице символов
dd 17, dt_rel ; DT_REL -- указатель на таблицу релокаций
dd 18, dt_rel_size; DT_RELSZ -- размер таблицы релокаций
dd 19, 8 ; DT_RELENT -- размер одной записи в таблице релокаций
dd 0, 0 ; DT_NULL -- конец данных для DT_DYNAMIC
dynamic_size equ $ - dynamic
; данные для DT_HASH
; эти данные нужны для чего-то вроде оптимизации загрузки миллионов импортируемых
; функций из динамических библиотек, однако ж для наших двух функций это оверкилл
; поэтому здесь просто заглушка
dt_hash: dd 1, 3, 0, 0, 0, 0
; данные для DT_SYMTAB
; именно в этом месте мы говорим, какие функции нам нужно подгрузить динамически
dt_symtab:
; 1 -- первая запись пустая (зачем?!)
dd 0, 0, 0
dw 0, 0 ; SHN_UNDEF
; 2 'dlopen'
dd st_dlopen_name, 0, 0
dw 0x12 ; = ELF32_ST_INFO(STB_GLOBAL, STT_FUNC), т.е., короче говоря, тип символа -- глобальная функция
dw 0 ; SHN_UNDEF говорит, что этого символа у нас нет, и его надо искать вовне
; 3 'dlsym'
dd st_dlsym_name, 0, 0
dw 0x12, 0 ; --//--
; данные для DT_REL
; таблица релокаций. описывает, куда и как загружать адреса символов из таблицы символов
dt_rel:
dd rel_dlopen ; адрес, куда грузить
dd 0x0101 ; ELF32_R_INFO(1,R_386_32) : dt_symtab[1] ('dlopen'), тип = запиши адрес символа + r_addend(=0 у нас)
dd rel_dlsym ; --//--
dd 0x0201 ; ELF32_R_INFO(2,R_386_32) : dt_symtab[2] ('dlsym'), --//--
dt_rel_size equ $ - dt_rel
; сгруппируем строки вмете -- ожидаем, что так они будут лучше паковаться
; стандартный линуксовый интерпретатор для динамической линковки
interp: db '/lib/ld-linux.so.2', 0
interp_size equ $ - interp
; данные для DT_STRTAB
; таблица строк. в ней лежит всё, необходимое для PT_DYNAMIC -- названия библиотек и имена функций
dt_strtab:
st_libdl_name equ $ - dt_strtab ; адрес строки относительно начала таблицы строк
db 'libdl.so.2', 0 ; все строки -- нуль-терминированные
st_dlopen_name equ $ - dt_strtab
db 'dlopen', 0
st_dlsym_name equ $ - dt_strtab
db 'dlsym', 0
dt_strtab_size equ $ - dt_strtab
; имена библиотек и функций, которые нужно загрузить ручками
libs_to_dl:
st_libSDL_name equ $ - dt_strtab
db 'libSDL-1.2.so.0', 0 ; самое кросс-дистрибутивное название библиотеки, которое мне удалось выяснить эмпирически
db 'SDL_Init', 0
db 'SDL_SetVideoMode', 0
db 'SDL_PollEvent', 0
db 'SDL_GetTicks', 0
db 'SDL_ShowCursor', 0
db 'SDL_GL_SwapBuffers', 0
db 'SDL_Quit', 0
db 0 ; два нуля подряд = конец библиотеки
st_libGL_name equ $ - dt_strtab
db 'libGL.so.1', 0
db 'glViewport', 0
db 'glCreateShader', 0
db 'glShaderSource', 0
db 'glCompileShader', 0
db 'glCreateProgram', 0
db 'glAttachShader', 0
db 'glLinkProgram', 0
db 'glUseProgram', 0
db 'glRectf', 0
db 0, 0 ; три нуля подряд = конец загрузки
shader_vtx:
db 'varying vec4 p;'
db 'void main(){gl_Position=p=gl_Vertex;p.z=length(p.xy);}'
db 0
shader_frg:
db 'varying vec4 p;'
db 'void main(){'
db 'float '
db 'z=1./length(p.xy),'
db 'a=atan(p.x,p.y)+sin(p.z+z);'
db 'gl_FragColor='
db '2.*abs(.2*sin(p.z*3.+z*3.)+sin(p.z+a*4.)*p.xyxx*sin(vec4(z,a,a,a)))+(z-1.)*.1;'
db '}', 0
_start: ; поехали
mov ebp, bss ; пускай ebp всё время указывает на bss -- будет удобно, поверьте!
; супер-удобные штуки, см далее
%define BSSADDR(a) ebp + ((a) - bss)
%define F(f) [ebp + ((f) - bss)]
; начнём загрузку функций
mov esi, libs_to_dl+1 ; +1, т.к. ld_load ожидает, что мы уже вгрызлись на один символ в строку
lea edi, [BSSADDR(libs_syms)] ; edi = адрес места, куда следует аккуратно сохранять адреса функций
ld_load:
dec esi ; в этом месте мы уже вгрызлись в строку на 1, поэтому отступим назад
; подготовим параметры функции dlopen, они передаются через стек
push 1 ; RTLD_LAZY
push esi ; адрес имени библиотеки
call F(rel_dlopen) ; eax = dlopen([esi], 1)
; обратите внимание, что здесь мы ~~не чистим после себя~~засираем стек и РАДУЕМСЯ ЭТОМУ
mov ebx, eax ; сохраним то, что dlopen нам вернул, в ebx
; скипаем все до 0
ld_skip_to_zero:
lodsb
test al, al
jnz ld_skip_to_zero
; если следующий тоже \0 то конец текущей библиотеки
lodsb
test al, al
jz ld_second_zero
dec esi ; опять отматываемся на 1 назад
push esi ; начало строки с названием функции
push ebx ; возвращенный из dlopen указатель на загруженную библиотеку
call F(rel_dlsym) ; eax = dlsym([ebx], [esi])
stosd ; запишем eax (возвращенный указатель на функцию) в [edi], edi += 4
jmp ld_skip_to_zero ; перемотаем до следуюшего нуля
ld_second_zero:
; если третий не ноль, то подгрузим что-нибудь еще!
lodsb
test al, al
jnz ld_load
; здесь наша умопомрачительная интра!
push 0x21 ; SDL_INIT_ TIMER | VIDEO
call F(SDL_Init) ; SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO);
push 2 | FULLSCREEN ; SDL_OPENGL
push 32 ; 32 бита на пиксель
push HEIGHT
push WIDTH
call F(SDL_SetVideoMode) ; SDL_SetVideoMode(WIDTH, HEIGHT, 32, SDL_OPENGL|FULLSCREEN);
; WxH уже есть в стеке! cdecl ftw!
push 0
push 0
call F(glViewport) ; glViewport(0, 0, WIDTH, HEIGHT);
call F(SDL_ShowCursor) ; SDL_ShowCursor(0);
; загрузка шейдеров
call F(glCreateProgram) ; eax = glCreateProgram();
mov edi, eax ; edi = program_id
push 0x8b31
pop esi ; esi = GL_VERTEX_SHADER
; здесь и далее используем 4 байта по адресу ebp как temp переменную -- там лежит ненужный нам более адрес dlopen, можно затирать
mov dword [ebp], shader_vtx
push esi
call F(glCreateShader) ; eax = glCreateShader(GL_VERTEX_SHADER);
mov ebx, eax
push 0
push ebp
push 1
push eax
call F(glShaderSource) ; glShaderSource(shader_id, 1, &shader_vtx, 0);
push ebx ; драйвера nVidia портят стек, поэтому нужно перезаливать аргументы
call F(glCompileShader) ; glCompileShader(shader_id);
push ebx ; опять поганая нвидия всё портит!
push edi
call F(glAttachShader) ; glAttachShader(program_id, shader_id);
dec esi ; esi = GL_FRAGMENT_SHADER
mov dword [ebp], shader_frg
; точная копия того, что вверху = хорошо жмётся!
push esi
call F(glCreateShader)
mov ebx, eax
push 0
push ebp
push 1
push eax
call F(glShaderSource)
push ebx
call F(glCompileShader)
push ebx
push edi
call F(glAttachShader)
push edi
call F(glLinkProgram) ; glLinkProgram(program_id);
call F(glUseProgram) ; glUseProgram(program_id);
mainloop:
call F(SDL_GetTicks) ; eax == SDL_GetTicks(); -- время в миллисекундах
mov [ebp], eax
fninit ; нужно сбросить состояние FPU, потому что все вокруг норовят его испортить
fild dword [ebp] ; st(0) = eax == time в миллисекундах, st(1) = 1000
push 400 ; эта константа регулирует скорость, чем она больше, тем медленнее всё
fild dword [esp] ; st(0) = 1000
fdiv ; st(0) /= 1000 = время в секундах
fld1 ; st(0) = 1, st(1) = время в с
faddp st1 ; st(0) = время в с + 1
fst dword [ebp]
mov eax, [ebp] ; eax = (float-ieee)t в секундах
fchs ; st(0) = -st(0)
fstp dword [ebp]
mov ebx, [ebp] ; ebx = -(float-ieee)t в секундах
push ebx
push ebx
push eax
push eax
call F(glRectf) ; glRectf(-t,-t,t,t)
times 5 pop eax ; здесь, к сожалению, приходится убирать за собой, т.к. мы крутимся в цикле и не можем гадить бесконечно
call F(SDL_GL_SwapBuffers)
lea edx, [BSSADDR(SDL_Event)] ; адрес памяти под структуру SDL_Event
push edx
call F(SDL_PollEvent) ; SDL_PollEvent(&SDL_Event);
pop edx ; восстановим edx
cmp byte [edx], 2 ; SDL_Event.type != SDL_KEYDOWN
jnz mainloop
call F(SDL_Quit) ; восстановим режим экрана и прочее
; вон из Новосибирска!
xor eax, eax ; eax = 0
inc eax ; ex = 1 (exit syscall)
int 0x80 ; вызов syscall
file_size equ ($-$$) ; ну тут уже всё понятно должно быть
; BSS-секция, в ней лежат неинициализированные данные
absolute $
bss:
; резервируем место под адреса функций
libdl_syms:
rel_dlopen: resd 1
rel_dlsym: resd 1
libs_syms:
SDL_Init: resd 1
SDL_SetVideoMode: resd 1
SDL_PollEvent: resd 1
SDL_GetTicks: resd 1
SDL_ShowCursor: resd 1
SDL_GL_SwapBuffers: resd 1
SDL_Quit: resd 1
glViewport: resd 1
glCreateShader: resd 1
glShaderSource: resd 1
glCompileShader: resd 1
glCreateProgram: resd 1
glAttachShader: resd 1
glLinkProgram: resd 1
glUseProgram: resd 1
glRectf: resd 1
SDL_Event: resb 24
mem_size equ ($-$$)
```
Смотрите, котятки, мы уложили в 750 байт то, что в прошлый раз еле-еле влезло в 1024. Можно ли улучшить этот результат?
Конечно можно:
1. многие структуры начинаются на то же самое, на что заканчиваются другие структуры
2. похожие данные полезно размещать рядом (рыхлые заголовки вместе, строки — вместе, x86-инструкции — тоже ничем не перемежать)
3. менять org
4. выкидывать обходимое — например, закомментировать всё с SDL\_ShowCursor
При этом стоит помнить, что размер сжатого файла далеко не монотонно зависит от размера несжатого: например, times 5 pop eax заметно выигрывает по размеру перед add esp, 20.
Итого, перенос всех строк в конец файла даёт выигрыш 16 байт, столько же можно выиграть, если закомментировать поганой метлой последние ненужные три поля elf header (e\_shentsize и следующие за ним два гуся) поудалять нули и прочие одинаковые данные между phdrs и dynamic, dt\_hash и dt\_symtab.
Итого: 718 байт за то же самое.
Не знаю, как у вас, а у меня уже чешутся ручки — наконец-то можно заняться тем, зачем мы здесь все сегодня собрались — творчеством! И у нас есть целых 306 байт для него (даже больше, если учесть то, что можно полностью заменить шейдеры с осточертевшим туннелем)!
Что же можно сделать с таким невообразимо огромным холстом?
Например, что-нибудь такое
(осторожно, нужна мощная видеокарта):
```
shader_vtx:
db 'varying vec4 p,v;'
db 'void main()'
db '{'
db 'gl_Position=gl_Vertex;'
db 'p=vec4(mat3(cos(length(gl_Vertex.xy)),0.,sin(length(gl_Vertex.xy)),0.,1.,0.,-sin(length(gl_Vertex.xy)),0.,cos(length(gl_Vertex.xy)))*vec3(gl_Vertex.xy*.1,-.9),length(gl_Vertex.xy));'
db 'v=vec4(mat3(cos(length(gl_Vertex.xy)),0.,sin(length(gl_Vertex.xy)),0.,1.,0.,-sin(length(gl_Vertex.xy)),0.,cos(length(gl_Vertex.xy)))*vec3(gl_Vertex.xy*.1,.1),length(gl_Vertex.xy));'
db '}'
db 0
shader_frg:
db 'varying vec4 p,v;'
;db 'float mx(vec3 a){return max(a.x,max(a.y,a.z));}'
db 'float mn(vec3 a){return min(a.x,min(a.y,a.z));}'
db 'float F(vec3 a){return min(mn(vec3(1.)-abs(a)),-mn(abs(mod(a+vec3(.1),vec3(.4))-vec3(.2))-.15));}'
;db 'float F(vec3 a){return min(mn(vec3(1.)-abs(a)),length(mod(a,vec3(.4))-vec3(.2))-.06);}'
db 'vec3 n(vec3 a){'
db 'vec3 e=vec3(.0001,.0,.0);'
db 'return normalize(vec3(F(a)-F(a+e.xyy),F(a)-F(a+e.yxy),F(a)-F(a+e.yyx)));'
db '}'
db 'vec4 tr(vec3 E,vec3 D){'
db 'D=normalize(D);'
db 'float L=.01;'
db 'int i=0;'
db 'for(i;i<512;++i){'
db 'float d=F(E+D*L);'
db 'if(d<.0001)break;'
db 'L+=d;'
db '}'
;db 'return vec2(L,float(i)/512.);'
db 'return vec4(E+D*L,float(i)/512.);'
db '}'
db 'float I(vec3 a){'
db 'vec3 l=vec3(sin(p.w*1.3),cos(p.w*4.2),sin(p.w*3.2))*.9,la=l-a;'
db 'return length(tr(a,la).xyz-a)*dot(n(a),-normalize(la))/dot(la,la)+.01;'
;db 'return tr(a,-lv).x*F(a+lv)/dot(lv,lv)+.01;'
db '}'
db 'void main(){'
db 'vec4 t=tr(p.xyz,v.xyz);'
db 'gl_FragColor=I(t.xyz)*(abs(t)+vec4(t.w*5.));'
;db 'vec2 t=tr(p.xyz,v.xyz);'
;db 'vec3 q=p.xyz+normalize(v.xyz)*t.x;'
;db 'gl_FragColor=I(q)+vec4(t.y);'
db '}'
db 0
```
Или такое:
```
shader_vtx:
db 'varying vec4 p,v;'
db 'void main()'
db '{'
db 'gl_Position=gl_Vertex;'
db 'p=vec4(mat3(cos(length(gl_Vertex.xy)),0.,sin(length(gl_Vertex.xy)),0.,1.,0.,-sin(length(gl_Vertex.xy)),0.,cos(length(gl_Vertex.xy)))*vec3(gl_Vertex.xy*.1,-.9),length(gl_Vertex.xy));'
db 'v=vec4(mat3(cos(length(gl_Vertex.xy)),0.,sin(length(gl_Vertex.xy)),0.,1.,0.,-sin(length(gl_Vertex.xy)),0.,cos(length(gl_Vertex.xy)))*vec3(gl_Vertex.xy*.1,.1),length(gl_Vertex.xy));'
db '}'
db 0
shader_frg:
db 'varying vec4 p,v;'
db 'float mn(vec3 a){return min(a.x,min(a.y,a.z));}'
db 'float F(vec3 a){return min(mn(vec3(1.)-abs(a)),length(mod(a,vec3(.4))-vec3(.2))-.06);}'
db 'vec3 n(vec3 a){'
db 'vec3 e=vec3(.0001,.0,.0);'
db 'return normalize(vec3(F(a)-F(a+e.xyy),F(a)-F(a+e.yxy),F(a)-F(a+e.yyx)));'
db '}'
db 'vec3 tr(vec3 E,vec3 D){'
db 'D=normalize(D);'
db 'float L=.01;'
db 'int i=0;'
db 'for(i;i<512;++i){'
db 'float d=F(E+D*L);'
db 'if(d<.001)break;'
db 'L+=d;'
db '}'
db 'return E+D*L;'
db '}'
db 'vec3 I(vec3 a,vec3 l,vec3 c){'
db 'return c*(clamp(length(tr(a,l-a)-a),0.,length(l-a))*dot(n(a),normalize(a-l))/dot(l-a,l-a));'
db '}'
db 'void main(){'
db 'vec3 t=tr(p.xyz,v.xyz);'
db 'gl_FragColor=vec4('
db 'I(t,vec3(sin(p.w*1.3),cos(p.w*4.2),sin(p.w*3.2))*.7,vec3(.9,.6,.2))+'
db 'I(t,vec3(sin(p.w*3.2),sin(p.w*4.2),sin(p.w*1.3))*.7,vec3(.0,.3,.5)),1.);'
db '}'
db 0
```
Почему эти шейдеры дают такую картинку? Об этом я, следуя доброй традиции частоты постинга, расскажу в марте следующего года! Ключевые слова для нетерпеливых и самостоятельных: raymarching distance fields (много инфы есть у [этого парня](http://www.iquilezles.org/)).
##### Эпилог
Несмотря на то, что в этом тексте полно ошибок, неоптимальностей и просто наглого вранья (посчитайте, сколько раз я здесь злоупотребил доверием), надеюсь, что он оказался полезен, и что хотя бы кто-нибудь теперь не сделает очередной стартап, а вместо этого создаст что-нибудь по-настоящему сложное, интересное и стоящее.
Несмотря на то, что с такими картинками нам уже не должно быть стыдно перед одноклассниками, и вообще мы уже должны слышать нарастающий гул каблуков и прочего визга поклонниц, развиваться всё ещё есть куда, и это ещё не конец, куда собрался, это ещё не конец!
В следующий раз вас ждёт рассказ о том, как на языке программирования «Си» доставать качающий бас из ничего и взрывать танцпол.
До встречи в октябре! | https://habr.com/ru/post/143766/ | null | ru | null |
# Reticulum — радиопротокол для mesh-сети. Зашифрованная пиринговая связь без интернета
Как мы [обсуждали](https://habr.com/ru/company/globalsign/blog/652647/) ранее, отключение интернета в конкретной стране или городе — не вымышленная угроза, а вполне реализуемое действие. В частности, международная ассоциация Internet Society зафиксировала в 2021 году [49 искусственно вызванных шатдаунов](https://pulse.internetsociety.org/blog/end-of-year-review-2021).
Но есть эффективные технологии, которые позволят пережить возможный шатдаун. Например, mesh-сети для радиосвязи.
Одна из последних разработок в этой области — [сетевой стек Reticulum](https://github.com/markqvist/Reticulum) (RNS).
К настоящему времени создано много фрагментарных решений и специализированных инструментов, но до сих пор не было полного коммуникационного стека для mesh-сети, которую могут поднять обычные пользователи без какой-либо централизованной координации. Разработчик RNS постарался восполнить этот пробел.
Подобную сеть можно за полчаса развернуть в случае системного сбоя коммуникаций в конкретной области или во всём мире. Не требуется ни драйверов, ни модулей ядра для встроенных ОС. Сетевой стек легко поставить на любой радиомодем, а для этой операции не требуется особый опыт работы с компьютерами или радиопередатчиками ([полная документация](https://markqvist.github.io/Reticulum/manual/), [pdf](https://github.com/markqvist/Reticulum/raw/master/docs/Reticulum%20Manual.pdf)).
RNS работает на основе совершенно нового протокола, у которого ряд преимуществ перед IP-протоколом (хотя IP тоже поддерживается).
Главные преимущества Reticulum перед традиционными сетевыми стеками — поддержка очень низкого битрейта и очень больших задержек. То есть можно передавать пакеты по самым простым радиоканалам во время краткосрочных сеансов связи. При этом сохраняется сквозное шифрование и полная анонимность.
### Особенности стека
* Бескоординатная глобальная адресация и идентификация.
* Полностью самоконфигурирующаяся многоцелевая маршрутизация (multi-hop).
* Асимметричное шифрование X25519 и подписи Ed25519.
* Спецификация шифрования [Fernet](https://github.com/fernet/spec/blob/master/Spec.md):
+ AES-128 в режиме CBC с набивкой PKCS7;
+ HMAC с аутентификацией SHA256;
+ генерация векторов инициализации с помощью `os.urandom()`;
+ прямая секретность с эфемерными ключами по протоколу Диффи — Хеллмана на эллиптических кривых (ECDH), набор Curve25519.
* Защищённые от подделки подтверждения доставки пакетов.
* Разнообразие типов интерфейсов.
* Интуитивно понятный и простой в использовании API.
* Надёжная и эффективная передача произвольных объёмов данных.
+ поддержка многогигабайтных файлов;
+ автоматический подсчёт контрольных сумм, координация и восстановление последовательности пакетов;
+ расширяемый механизм запросов/ответов.
* Эффективное установление соединения: три пакета общим размером 237 байт, далее расход поддержания коннекта 0,62 бита в секунду.
Разработчик сетевого стека — [Марк Квист](https://github.com/markqvist), опытный разработчик и сетевой инженер, который всю свою жизнь занимается созданием и управлением компьютерными сетями. Владелец компании [Unsigned.io](https://unsigned.io/), которая разрабатывает и продаёт [оборудование](https://unsigned.io/hardware/) для радиосвязи (модули [RNode](https://unsigned.io/rnode/), модемы [MicroModem](https://unsigned.io/micromodem/) и [OpenModem](https://unsigned.io/openmodem/)).
Reticulum может работать практически на любом девайсе, начиная с крошечного Raspberry Pi Zero. По словам Квиста, с помощью Reticulum люди с минимальными знаниями в области телекоммуникаций и компьютеров могут поднять систему обмена сообщениями на большие расстояния для своего сообщества.
Например, можно легко поднять внутри города mesh-сеть и установить канал связи с соседним городом по УКВ, [говорит](https://www.reddit.com/r/preppers/comments/tqhtgt/i_made_the_prepper_version_of_the_internet/) Квист: «Если у вас уже есть модем и радиопередатчик, на настройку уйдет пять минут. Я действительно старался сделать стек максимально гибким, но при этом очень простым в использовании для людей с минимальным опытом работы с компьютерами и радиопередатчиками».
Как это выглядит на практике, можно посмотреть на примере [Nomad Network](https://github.com/markqvist/NomadNet). Это прототип устойчивой mesh-сети на протоколах [LXMF](https://github.com/markqvist/LXMF) и [Reticulum](https://github.com/markqvist/Reticulum).
*Устройства в сети Nomad Network*
Данный проект кардинально отличается от многих других проектов mesh-сетей в мире, таких как общественная городская сеть [NYC Mesh](https://www.nycmesh.net/). Все они ставят целью в конечном итоге выход в интернет. А здесь изначально создаётся отдельная от интернета сеть, да ещё с сильным шифрованием. Это фундаментально иной уровень. Фактически, Reticulum поддерживает сценарий полного апокалипсиса.
«Reticulum — это попытка создать альтернативный протокол базового уровня для сетей передачи данных, — [говорит](https://www.vice.com/en/article/88g7pb/this-prepper-is-building-a-post-apocalyptic-internet) автор. — По сути, это не одна сеть, а инструмент для построения сетей. Его можно сравнить с IP, стеком интернет-протокола, на котором работает Интернет и 99,99% всех других сетей на Земле. Он решает те же проблемы, что и стек IP, обеспечивая передачу цифровых данных из точки А в точку Б, но делает это совершенно иначе и с совершенно другими предположениями. Реальная сила протокола заключается в том, что он может использовать все виды различных средств связи и соединять их в единую сеть. Он может использовать [дальние] приёмопередатчики, модемы, радиосвязь, Ethernet, WiFi или даже моток старой медной проволоки, если у вас есть такая возможность».
*Обмен зашифрованными сообщениями в радиосети Nomad Network*
**Ещё несколько скриншотов**
Разработка Reticulum пока находится в зачаточной стадии. Программный код не прошёл аудит на предмет безопасности шифрования. То есть в реальности его пока рановато использовать в серьёзном деле.
Проблема ещё в том, что весь существующий сетевой софт написан для протокола IP. Поэтому для сетевого стека Reticulum придётся создавать ещё и новый программный стек: существующие программы там работать не будут. Хотя кое-что уже разработано. Например, мессенджер [Sideband](https://unsigned.io/sideband/) (Android, Linux, MacOS) для обмена текстовыми сообщениями по LoRa, пакетному радио, WiFi, I2P или любому другому транспортному протоколу, который поддерживается стеком пиринговых коммуникаций [LXMF](https://github.com/markqvist/lxmf).
---
[](https://shop.globalsign.com/ru-ru/code-signing) | https://habr.com/ru/post/662489/ | null | ru | null |
# Продление жизни временных значений в С++: рецепты и подводные камни
Прочитав эту статью вы узнаете:
1. Способы, которыми можно продлить время жизни временного объекта в С++.
2. Рекомендации и подводные камни этого механизма, с которыми может столкнуться С++ программист, и с которыми сталкивался на работе я.
Информация из статьи может быть полезна как новичкам, так и профессионалам.
Если заинтересовало, то самое время налить чая, и погнали разбираться где тут референсы висят.
Оглавление
----------
* [Они на деревьях, Джонни!](https://habr.com/ru/post/669474/#enter)
* [1. Способы продления времени жизни и сохранения временных значений](https://habr.com/ru/post/669474/#1)
* [1.1 Константная lvalue ссылка](https://habr.com/ru/post/669474/#1_1)
* [1.2 rvalue ссылка](https://habr.com/ru/post/669474/#1_2)
* [1.3 Сохранение по значению](https://habr.com/ru/post/669474/#1_3)
* [2. Выведение типов компилятором (type deduction)](https://habr.com/ru/post/669474/#2)
* [2.1 auto](https://habr.com/ru/post/669474/#2_1)
* [2.2 decltype](https://habr.com/ru/post/669474/#2_2)
* [2.3 decltype(auto)](https://habr.com/ru/post/669474/#2_3)
* [2.4 template](https://habr.com/ru/post/669474/#2_4)
* [3. Рекомендации и подводные камни](https://habr.com/ru/post/669474/#3)
* [3.1 Прежде чем объявить ссылку на другую ссылку убедитесь, что последняя не указывает на временный объект](https://habr.com/ru/post/669474/#3_1)
* [3.2 Не используйте std::move там где может использоваться NRVO](https://habr.com/ru/post/669474/#3_2)
* [3.3 Прежде чем продлевать время жизни убедитесь, что значение не является xvalue (Xray&&)](https://habr.com/ru/post/669474/#3_3)
* [3.4 При создании RAII объекта всегда сохраняйте его значение в переменную, либо же объявляйте ссылку на него](https://habr.com/ru/post/669474/#3_4)
* [3.5 Прежде чем объявить ссылку на другую ссылку убедитесь, что последняя не указывает на временный объект](https://habr.com/ru/post/669474/#3_5)
* [3.6 Не продлевайте жизнь через тернарный оператор ?:](https://habr.com/ru/post/669474/#3_6)
* [3.7 Не используйте ссылки в полях классов (особенно если они указывают на временные объекты) и не используйте std::reference\_wrapper для продления жизни](https://habr.com/ru/post/669474/#3_7)
* [3.8 При передаче в new временных значений, убедитесь, что ни одно из них не сохраняется по ссылке](https://habr.com/ru/post/669474/#3_8)
* [3.9 Не продлевайте время жизни временного массива через ссылку на его элементы](https://habr.com/ru/post/669474/#3_9)
* [Заключение](https://habr.com/ru/post/669474/#end)
### Они на деревьях, Джонни!
Для начала давайте обозначим набор проблем, которые вероятнее всего могут встретиться при обращении со ссылками:
1. Висячие ссылки.
2. Всё.
Возможно в вашем варианте подобного списка будет больше пунктов, но вряд-ли они смогут потягаться с первым номером по частоте, с которой вы можете встретить их в продакшене.
Для тех кто не знает, висячая ссылка (dangling reference) — это ссылка на область памяти, в которой нет "живого" объекта. Это возможно когда время жизни ссылки дольше чем время жизни объекта, на который она указывает. Ссылка становится висячей в тот момент, когда компилятор разрушает объект (вызывает деструктор объекта и потом освобождает память, которая объектом занималась), а ссылку ещё нет.
Скрытая правда: как на самом деле появляются висячие ссылкиОпасность висячей ссылки в том, что если кто-нибудь в это время воспользуется данной ссылкой, то может произойти всё что угодно, что описывается стандартом как неопределённое поведение или UB.
Что значит неопределённое? Если оно произойдёт то может случиться коллапс?Неопределённым оно является относительно стандарта, а не вообще, то есть стандарт не описывает что *конкретно* должно произойти. На самом же деле это поведение зависит от самой программы и окружения, в котором она запускается. То есть оно зависит от:
1. Реализованного в программе алгоритма.
2. Используемого компилятора.
1. В частности, от поддерживаемых компилятором оптимизаций.
3. Выбранного уровня оптимизации.
4. Имплементации стандартной библиотеки.
5. Операционной системы.
И так далее...
Поэтому, теоретически, мы можем предполагать что произойдёт в конкретном случае (может ничего плохого, а может и упасть программа).
Хоть теоретически мы и можем предполагать что произойдёт в том или ином случае, провоцирующем UB, но что бы вы выбрали: расследовать убийство, или не допускать его? Я считаю, что намного важнее — научиться избегать UB в своих программах, потому что программа с неопределённым поведением — горе для заказчика, а горе заказчика — наше горе.
Один из спонсоров появления висячих ссылок — нюансы механизма продления времени жизни временных объектов. Данный механизм существует с C++03 (продление через константные lvalue ссылки). В C++11 его доработали (добавили rvalue ссылки) и он стал звучать так:
> Если вы приняли временный объект по *константной lvalue ссылке* или *rvalue ссылкe*, то его время жизни будет продлено до времени жизни ссылки.
>
>
Исходя из этого утверждения можно заключить, что продление жизни работает только для временных объектов, на которые указывают ссылки. А ещё, если прибавить к этому определению сохранение по значению, то получается следующий список:
1. Создание константной lvalue ссылки на временное значение.
2. Создание rvalue ссылки на временное значение.
3. Сохранение по значению.
Хотя, с точки зрения языка, сохранение по значению — не механизм продления жизни, поскольку временное значение в таком случае должно скопироваться или переместится (время жизни оригинального временного значения при этом не продлевается). Но, забегая вперёд:
1. Оптимизация copy elision приводит ко внешне похожим эффектам, как при сохранении по ссылке.
2. Сохранение по значению тоже имеет нюансы, связанные с продлением времени жизни через ссылки.
Давайте теперь поговорим про каждый из этих вариантов поподробнее. Но сперва рассмотрим класс `Xray`, при помощи которого мы будем отслеживать порядок вызова конструкторов и деструкторов.
Класс Xray
```
struct Xray
{
Xray(std::string value)
: mValue(std::move(value))
{
std::cout << "Xray ctor, value is " << mValue << std::endl;
}
Xray(Xray&& other)
: mValue(std::move(other.mValue))
{
std::cout << "Xray&& ctor, value is " << mValue << std::endl;
}
Xray(const Xray& other)
: mValue(other.mValue)
{
std::cout << "Xray const& ctor, value is " << mValue << std::endl;
}
~Xray()
{
std::cout << "~Xray dtor, value is " << mValue << std::endl;
}
std::string mValue;
};
```
### 1. Способы продления времени жизни и сохранения временных значений
Для разогрева начнём с самого простого варианта: ситуации, в которой мы вообще не сохраняем временное значение, а только создаем его.
Если мы так сделаем, то компилятор вызовет деструктор в той же строке. Пример на [godbolt](https://godbolt.org/z/TK88484e3):
```
void main()
{
// Вывод: Xray ctor, value is 1
// Вывод: Xray dtor, value is 1
Xray{"1"};
std::cout << "Wait a sec" << std::endl;
}
```
### 1.1 Константная lvalue ссылка
Что такое lvalue ссылка?Левосторонние ссылки (lvalue references) — ссылки вида: `Xray&` и `const Xray&` (тип не обязательно должен быть `Xray`, можно и любой другой, например `int`). Левосторонняя ссылка всегда ссылается только на именованные, в некотором смысле постоянные значения (более подробно разберём этот вопрос в сравнении с rvalue ссылками).
Понять что ссылка левосторонняя можно по её типу (`const T&`, `T&`), либо же так: значения на которые она ссылается всегда находятся *слева* от `=` при объявлении переменной:
```
int i = 3;
int& iRef = i;
```
Здесь `i` — lvalue, поэтому и ссылка на него `iRef` называется lvalue reference.
Теперь же рассмотрим вариант с созданием константной lvalue ссылки на временный объект:
```
void main()
{
// Вывод: Xray ctor, value is 1
const Xray& xrayRef = Xray{"1"};
// Вывод: xrayRef value is 1
std::cout << "xrayRef value is " << xrayRef.mValue << std::endl;
} // Вывод: Xray dtor, value is 1
```
Всё чисто и просто: мы создаём временное значение при помощи `Xray{"1"}` и сохраняем константную ссылку на него в `xrayRef`. После чего временное значение разрушается при выходе из функции `main` (после достижения потоком исполнения программы конца тела функции — фигурной скобки `}` ).
Аналогично работает и следующий пример, за исключением того, что теперь при создании временного объекта произойдёт неявное преобразование типа из `std::string` в `Xray`:
```
void main()
{
// Вывод: Xray ctor, value is 1
const Xray& xrayRef = std::string("1");
} // Вывод: Xray dtor, value is 1
```
Почему компиляция этого примера не завершается ошибкой?Данное преобразование не является ошибочным потому что в `Xray` объявлен конструктор, принимающий`t std::string`, и по умолчанию все конструкторы разрешают неявные преобразования.
При желании мы можем запретить неявное приведение типов, если пометим конструктор `Xray(const std::string&)` как `explicit`, в таком случае нам нужно будет явно вызывать конструктор `Xray{std::string("1")}`.
Плюс такого подхода — нет лишних вызовов конструкторов копирования. Но в этом плане это не единственный способ, обладающий таким плюсом.
#### 1.2 rvalue ссылка
Что означает правосторонняя ссылка и как она отличается от левосторонней?Правосторонняя ссылка, это ссылка вида: `Xray&&` (тип не обязательно должен быть `Xray`, можно и любой другой, например `int`). Данный вид ссылки может указывать только на временные значения. Правосторонней же она называется потому что временные значения, на которые она указывает, всегда находятся *справа* от`=` при объявлении переменной:
```
int&& iRvalueRef = 3;
```
Здесь `(int)3` — rvalue (временное значение), поэтому и ссылка на него `iRvalueRef` называется rvalue reference.
#### Отличия между rvalue и lvalue
Чтобы разобраться в отличиях, давайте рассмотрим пример:
```
int three = 3;
int& threeLvalueRef = three;
int&& fourRvalueRef = 4;
```
Здесь:
1. `(int)3` и `(int)4` — rvalue, временные значения. У данных значений нет имени, по которому к ним можно обратиться.
2. `int three` — lvalue. У неё есть имя ‘three’, по которому к ней можно обратиться.
3. `int& threeLvalueRef` — lvalue reference. Она ссылается на lvalue `three`.
4. `int&& fourRvalueRef` — rvalue reference. Она ссылается на rvalue `(int)4`.
Более подробно про виды ссылок и их различия также можно прочитать в статьях:
1. [RU] [@rhaport](/users/rhaport) [Понимание lvalue и rvalue в C и С++](https://habr.com/ru/post/348198/)
2. [ENG] fluentcpp [Understanding lvalues, rvalues and their references](https://www.fluentcpp.com/2018/02/06/understanding-lvalues-rvalues-and-their-references)
Что такое семантика перемещения и как с ней связан std::move?rvalue reference так же можно принять переместив объект (если в классе такого типа реализован конструктор перемещения, как в `Xray::Xray(Xray&&)`). Для этого нужно вызвать `std::move`:
```
Xray xray = Xray{‘123”};
Xray&& xrayRef = std::move(xray);
```
Сам `std::move` не занимается какой-то магией, он только приводит тип аргумента `Xray` к типу правосторонней ссылки `Xray&&`, чтобы таким образом, вызвался конструктор с параметром `Xray&&`, который называется конструктором перемещения, и в котором программист должен описать логику: какие поля класса нужно переместить и как.
А нужно это потому что существуют тяжеловесные типы, значения которых лучше перемещать, чем копировать.
*Пример:* скопировать значение строки `Xray::mValue` из одного места в другое — не всегда лучший выбор, поскольку это подразумевает:
1. Выделение, обычно, не маленького куска памяти размером mValue.size() байт.
2. Побайтовое копирование значения каждого байта.
Такое копирование может быть очень долгим, ведь строка может быть длинной и в 10000 символов (и больше). Поэтому переместить её значение будет намного быстрее, в таком случае указатель на данные (`const char*`), хранящийся под капотом `std::string`, просто будет отдан другому экземпляру `std::string`, без всяких дополнительных аллокаций памяти и копирования значений байт.
Упрощённая реализация `std::move` для lvalue значений:
```
template
T&& move(T& value)
{
return (T&&)value;
}
```
rvalue ссылка тоже подходит, если нужно ссылаться на временное значение, при этом не будет вызвано никаких дополнительных конструкторов перемещения или копирования:
```
void main()
{
// Вывод: Xray ctor, value is 1
Xray&& xrayRef = Xray{"1"};
} // Вывод: Xray dtor, value is 1
```
#### 1.3 Сохранение по значению
Сохранение по значению выглядит следующим образом:
```
void main()
{
// Вывод: Xray ctor, value is 1
Xray xray = Xray{"1"};
} // Вывод: Xray dtor, value is 1
```
Возможно, глядя на этот пример у вас возникает вопрос: *"Разве не будет вызова копирующего конструктора?"*.
Дело в том, что благодаря оптимизации *copy elision,* предотвращающей избыточное копирование, конструктор копирования/перемещения вызван не будет. И более того, даже в таком виде, будет вызван всего 1 конструктор (который создает объект `Xray`):
```
void main()
{
// Вывод: Xray ctor, value is 1
Xray xray = Xray{Xray{Xray{"1"}}};
} // Вывод: Xray dtor, value is 1
```
В С++ оптимизация *copy elision* появилась начиная с С++98, но поддерживалась не во всех компиляторах. Когда пришёл С++17, он навел порядок, и, начиная с него, все компиляторы обязаны поддерживать эту оптимизацию.
### 2. Выведение типов компилятором (type deduction)
В С++ существуют механизмы, которые позволяют нам самим не определять тип переменной, или определять его только частично. В таком случае компилятор, если это возможно, выведет тип самостоятельно, на основе инициализатора (присваиваемого выражения).
Хоть механизмы выведения типа отвечают только за способ выведения типа, и в конце концов выводят тип как ссылку или безссылочный тип (это означает, что при их использовании мы в конце концов всё равно приходим к одному из способов из [п.1](https://habr.com/ru/post/669474/#1): либо к передаче по ссылке, либо к передаче по значению). Но для полноты картины их стоит рассмотреть, хотя бы вкратце.
Далее, для проверки того какой же именно компилятор вывел тип, я буду использовать бесплатный сервис — [cppinsights](https://cppinsights.io/).
#### 2.1 auto
Начиная с С++11 у нас появилась возможность использовать ключевое слово `auto` для выведения типа переменной через её инициализатор. Если мы используем его без дополнительных квалификаторов и `&` (as is), то при выведении типа переменной будут проигнорированы ссылочность и квалификаторы `const`, `volatile`. Это означает, что произойдёт [сохранение по значению](https://habr.com/ru/post/669474/#1_3). Смотрите вывод типов на [cppinsights](https://cppinsights.io/s/b0de6bb9):
```
void main()
{
// Вывод: Xray ctor, value is 1
auto xray = Xray{"1"}; // type = Xray
} // Вывод: Xray dtor, value is 1
```
Примеры отбрасывания квалификаторов при выведении через autoСмотрите вывод типов на [cppinsights](https://cppinsights.io/s/7bb1f6f1):
```
int i = 0;
int& iRef = i;
const int& iConstRef = i;
volatile int& iVolatileRef = i;
const volatile int& iCVRef = i;
int* iPtr = &i
auto _1 = i; // type = int
auto _2 = iRef; // type = int
auto _3 = iConstRef; // type = int
auto _4 = iVolatileRef; // type = int
auto _5 = iCVRef; // type = int
auto _6 = iPtr; // type = int*
```
Чтобы добавить квалификаторы и ссылочность (или сохранить их при выводе типа) нужно указать их рядом с auto. При их добавлении в данном случае произойдет [продление жизни через константную lvalue ссылку](https://habr.com/ru/post/669474/#1_1) ([cppinsights](https://cppinsights.io/s/fed73942)):
```
void main()
{
// Вывод: Xray ctor, value is 1
const auto& xray = Xray{"1"}; // type = const Xray&
} // Вывод: Xray dtor, value is 1
```
Также есть возможность указать `auto&&`, тогда механизм вывода будет очень похож на perfect forwarding. При его использовании в данном случае произойдет [продление жизни через rvalue ссылку](https://habr.com/ru/post/669474/#1_2) ([cppinsights](https://cppinsights.io/s/a78d2fd8)):
```
void main()
{
// Вывод: Xray ctor, value is 1
auto&& xray = Xray{"1"}; // type = Xray&&
} // Вывод: Xray dtor, value is 1
```
Чтобы узнать что такое perfect forwarding смотрите [п.2.4 template](https://habr.com/ru/post/669474/#2_4).
Примеры вывода типа через auto&&Смотрите вывод типов на [cppinsights](https://cppinsights.io/s/a8eb1079):
```
int i = 0;
const int& iConstRef = i;
auto&& _ = i; // type = int&
auto&& _1 = iConstRef; // type = const int&
auto&& _2 = 4; // type = int&&
```
#### 2.2 decltype
С++11 принёс нам ключевое слово `decltype`, которое позволяет получить тип переданного ему выражения в compile time. Примеры вывода типов с использованием `decltype` на [cppinsights](https://cppinsights.io/s/0445b433):
```
int i = 0;
const int& iConstRef = i;
int&& iRvalueRef = 1;
decltype(i) _1 = i; // type = int
decltype(iConstRef ) _2 = iConstRef; // type = const int&
decltype(iRvalueRef) _3 = std::move(iRvalueRef); // type = int&&
decltype(3) _4 = 3; // type = int
```
При его использовании в данном случае произойдет [сохранение по значению](https://habr.com/ru/post/669474/#1_3):
```
void main()
{
// Вывод: Xray ctor, value is 1
decltype(Xray{"1"}) xray = Xray{"1"}; // type = Xray
} // Вывод: Xray dtor, value is 1
```
Если вам при этом нужно вывести тип объекта, у которого нет нужного конструктора(в частности конструктора по умолчанию), то можно воспользоваться `std::declval`:
```
decltype(std::declval()) xray = Xray{"1"}; // type = Xray&&
```
То, что вычисление типа происходит в compile time означает, что переданное в `decltype` выражение вычисляется не во время исполнения программы, а во время компиляции. Компилятор только смотрит на то какой тип получается в результате выражения и подставляет его.
*Пример:* В выражении`decltype(2+2)` не будет вычисляться результат сложения `2+2`, компилятор будет рассматривать это выражение только с точки зрения типов: `(int)+(int)`, результат — `int`.
При этом вы вероятно заметили, что использовать `decltype` в таком виде неудобно:
1. Появляется много лишней информации, которая полностью или частично дублирует присваиваемое выражение.
2. Иногда приходится использовать воркэраунды(вроде `std::declval`) чтобы вывести тип.
Видимо по этим причинам в следующем стандарте этот механизм доработали и выдали нам `decltype(auto)`.
#### 2.3 decltype(auto)
Начиная с С++14 у нас появилась возможность передавать как параметр в `decltype` ключевое слово `auto`. `decltype(auto)` позволяет вывести ровно такой-же тип, как у присваиваемого выражения, то есть ссылочность и квалификаторы при таком выводе будут сохранены.
Примеры вывода типов с использованием `decltype(auto)` на [cppinsights](https://cppinsights.io/s/60cd2c87):
```
int i = 2;
const int& iConstRef = 0;
decltype(auto) _1 = 1; // type = int
decltype(auto) _2 = iConstRef; // type = const int&
decltype(auto) _3 = std::move(i); // type = int&&
```
При его использовании в данном случае произойдёт [сохранение по значению](https://habr.com/ru/post/669474/#1_3) ([cppinsights](https://cppinsights.io/s/12f034f0)):
```
void main()
{
// Вывод: Xray ctor, value is 1
decltype(auto) xray = Xray{"1"}; // type = Xray
} // Вывод: Xray dtor, value is 1
```
#### 2.4 template
Выведение типа через шаблон очень похоже на выведение типа через `auto`, и наоборот.
Если мы укажем тип шаблона `T` (из `template`) без дополнительных квалификаторов и `&` (as is), то при выведении типа шаблонного аргумента функции будут проигнорированы ссылочность и квалификаторы `const`, `volatile`. Это означает, что произойдёт [сохранение по значению](https://habr.com/ru/post/669474/#1_3) ([cppinsights](https://cppinsights.io/s/591e8024) в данном случае показывает все типы, с которыми был инстанцирован шаблон):
```
template
void foo(T param)
{}
void main()
{
// Вывод: Xray ctor, value is 1
foo(Xray{"1"}); // type = Xray
} // Вывод: Xray dtor, value is 1
```
Примеры отбрасывания квалификаторов при выведении через шаблонСмотрите вывод типов на [cppinsights](https://cppinsights.io/s/e4a131a8):
```
template
void foo(T param)
{}
int i = 0;
int& iRef = i;
const int& iConstRef = i;
volatile int& iVolatileRef = i;
const volatile int& iCVRef = i;
int\* iPtr = &i
foo(i); // type = int
foo(iRef); // type = int
foo(iConstRef); // type = int
foo(iVolatileRef); // type = int
foo(iCVRef); // type = int
foo(iPtr); // type = int\*
```
Чтобы добавить квалификаторы или ссылочность (или сохранить их при выводе типа) нужно указать их рядом с именем параметра шаблона.
В данном случае при этом произойдет [продление жизни через константную lvalue ссылку](https://habr.com/ru/post/669474/#1_1) ([cppinsights](https://cppinsights.io/s/46466b30)):
```
template
void foo(const T& param)
{}
void main()
{
// Вывод: Xray ctor, value is 1
foo(Xray{"1"}); // type = const Xray&
} // Вывод: Xray dtor, value is 1
```
Также есть возможность указать `T&&` (идеальную ссылку), механизм вывода типа и передачи значения через которую называется perfect forwarding.
В данном случае произойдет [продление жизни через rvalue ссылку](https://habr.com/ru/post/669474/#1_2) ([cppinsights](https://cppinsights.io/s/7cb75ca2)):
```
template
void foo(T&& param)
{}
void main()
{
// Вывод: Xray ctor, value is 1
foo(Xray{"1"}); // type = Xray&&
} // Вывод: Xray dtor, value is 1
```
Примеры вывода типа через T&&Смотрите вывод типов на [cppinsights](https://cppinsights.io/s/5815865d):
```
template
void foo(T&& param)
{}
int i = 0;
const int& iConstRef = i;
foo(i); // type = int&
foo(4); // type = int&&
foo(std::move(i)); // type = int&&
foo(iConstRef); // type = const int&
```
Более подробное рассмотрение шаблонов и их отличий от других способов выведения типов выходит из рамок данной статьи, но вы можете ознакомиться с некоторыми статьями:
1. [@semenyakinVS](/users/semenyakinvs) [Просто о шаблонах](https://habr.com/ru/post/599801/)
2. [@4eyes](/users/4eyes) [О шаблонах С++, чуть сложнее](https://habr.com/ru/post/645321/)
---
### 3. Рекомендации и подводные камни
#### 3.1 Прежде чем объявить ссылку на другую ссылку убедитесь, что последняя не указывает на временный объект
Возврат ссылки из функции не продлевает время жизни, с чем связана одна из самых распространенных проблем у начинающих — они возвращают ссылку на временное значение из функции. Смотрите вывод типов на [cppinsights](https://cppinsights.io/s/3003dc15):
```
const Xray& foo()
{
return Xray(“1”);
}
// Все примеры ниже — неверные. Время жизни не будет продлено.
const Xray& _1 = foo(); // Висячая ссылка
auto _2 = foo(); // Тип Xray. Значение с неопределённым содержимым в Xray::mValue.
const auto& _3 = foo(); // Тип const Xray&, висячая ссылка
auto&& _4 = foo(); // Тип const Xray&, висячая ссылка
decltype(auto) _5 = foo(); // Тип const Xray&, висячая ссылка
decltype(foo()) _6 = foo(); // Тип const Xray&, висячая ссылка
```
В данном случае временный объект разрушится перед выходом из функции, поэтому возвращаемая ссылка будет висячей. В связи с этим компилятор даже выдаст предупреждение (запуск программы на [godbolt](https://godbolt.org/z/77nW51YYx)):
> warning: returning reference to local temporary object
>
>
Но оно не поможет вам, если вы не читаете предупреждения, либо же если при сборке у вас их больше сотни (можно проглядеть). Поможет только знание этого нюанса и внимательность, или санитайзер.
#### 3.2 Не используйте std::move там где может использоваться NRVO
Что такое NRVO?NRVO (оптимизация именованного возвращаемого значения) — одна из форм *copy elision*, которая позволяет не копировать и не перемещать именованное значение при возврате его из функции.
В данном примере `str` — именованное значение (у него есть имя "str"), и если компилятор умеет делать NRVO, то не будет ни копирования ни перемещения, объект прямо поместится в `value`:
```
std::string foo()
{
std::string str;
// .. изменение str
return str;
}
std::string value = foo();
```
Так же существует оптимизация RVO (оптимизация возвращаемого значения), это более простая форма той же оптимизации, когда мы не даём возвращаемому значению имя.
В данном примере `std::string{"1"}` — неименованное значение (у него нет имени, по сравнению с `str` из предыдущего примера), и если компилятор умеет делать RVO, то не будет ни копирования ни перемещения, объект прямо поместится в `value`:
```
std::string foo()
{
return std::string{"1"};
}
std::string value = foo();
```
Если хотите узнать больше про NRVO и RVO, то можете изучить статью [@BykoIanko](/users/bykoianko) [RVO и NRVO в C++17](https://habr.com/ru/company/vk/blog/666330/).
В целях оптимизации производительности иногда может возникать желание написать так:
```
std::string&& foo()
{
std::string str;
// .. изменение str
return std::move(str);
}
```
В данном примере проблема в том, что возвращенная ссылка будет висячей, поскольку она будет указывать на локальный объект, который разрушится при выходе из функции. В связи с этим компилятор даже выдаст предупреждение, но вы можете его не заметить среди сотен других (запуск программы на [godbolt](https://godbolt.org/z/YEEafe98K)):
> warning: returning address of local variable or temporary: str
>
>
Если вы сильно переживаете за то что не сработает NRVO (но вероятнее всего оно сработает, почти все современные компиляторы уже умеют его делать), то лучше возвращать по значению:
```
std::string foo()
{
std::string str;
// .. изменение str
return std::move(str);
}
```
А ещё лучше — положиться на NRVO и не делать move.
#### 3.3 Прежде чем продлевать время жизни убедитесь, что значение не является xvalue (Xray&&)
В C++03 время жизни временных объектов продлевалось при сохранении его по константной ссылке. Начиная с C++11 появились xvalue у которых время жизни объекта продлить нельзя. Разбор всех категорий значений выходит за рамки этой статьи, но чтобы говорить более предметно, я уточню: существуют несколько категорий значений вроде prvalue (то что мы до этого рассматривали как rvalue), lvalue, xvalue.
В данном случае нас интересуют xvalue. В перегрузках функций, xvalue ведут себя как rvalue, то есть xvalue будет передано в функцию как правосторонняя ссылка `T&&` (если такая перегрузка есть).
*Пример:* если у класса есть перемещающий конструктор, то будет вызван он, а не конструктор копирования (который бы был вызван в случае передачи lvalue):
```
Xray& lvalue();
Xray prvalue();
Xray&& xvalue();
Xray _1 = lvalue(); // Копирование Xray(Xray)
Xray _2 = prvalue(); // copy elision
Xray _3 = xvalue(); // Перемещение Xray(Xray&&)
```
Время жизни xvalue нельзя продлить (как и lvalue). Попытка сделать это приведёт к висячим ссылкам:
```
Xray const& _1 = prvalue(); // время жизни как у ссылки
Xray&& _2 = prvalue(); // время жизни как у ссылки
Xray& _3 = lvalue(); // висячая ссылка, не продлевает время жизни
const Xray& _4 = lvalue(); // висячая ссылка, не продлевает время жизни
Xray&& _5 = xvalue(); // висячая ссылка, не продлевает время жизни
const Xray& _6 = xvalue(); // висячая ссылка, не продлевает время жизни
```
#### 3.4 При создании RAII объекта всегда сохраняйте его значение в переменную, либо же объявляйте ссылку на него
Нужно быть внимательным ко времени жизни объекта, если он является RAII оберткой. Например, не стоит объявлять `std::lock_guard` временным не сохранив ссылку на него (или не сохранив по значению), потому что это приведёт к преждевременному освобождению мьютекса, а значит появятся гонки:
```
void main()
{
// Так можно и нужно
std::lock_guard lock{someMutex};
/\* Так нельзя:
std::lock\_guard{mutex};
Потому что компилятор разрушит lock\_guard ещё до выхода из main,
что приведёт к гонкам (собственно к тому, от чего мы и защищаемся мьютексом)
\*/
// .. многопоточно безопасные вызовы
// .. изменение защищенных мьютексом значений
}
```
Если вы подумали о том, что создание такого временного объекта может быть упразднено оптимизатором, то это не так, потому что в данном случае конструктор с деструктором имеют сайд эффекты. В некоторых случаях оптимизатор может заинлайнить код конструктора и деструктора, но при этом функциональность программы останется неизменной.
#### 3.5 Прежде чем объявить ссылку на другую ссылку убедитесь, что последняя не указывает на временный объект
Продлевать жизнь временного объекта можно лишь один раз — при первой привязке к ссылке. Схема вроде `&`*-указывает на>*`&`*-указывает на>временный объект* не продлевает время жизни повторно, а приводит к висячей ссылке и неопределённому поведению при её использовании:
```
template
const T& foo(const T& in)
{
return in;
}
const Xray& ref1 = Xray(1); // Верно, время жизни будет продлено.
Xray& ref2 = foo(Xray(2)); // Неверно, время жизни не будет продлено,
// ref2 — висячая ссылка.
std::cout << ref2.mValue; // Неопределённое поведение
```
#### 3.6 Не продлевайте жизнь через тернарный оператор ?:
При сохранении ссылки на выражение, полученное через тернарный оператор, будет продлено время жизни одного из временных значений, в зависимости от условия:
```
Xray&& rvalRef = cond
? Xray{“1”} // Один из временных объектов
: Xray{“2”}; // будет иметь время жизни rvalRef
const Xray& constLvalRef = cond
? Xray{“1”} // Один из временных объектов
: Xray{“2”}; // будет иметь время жизни constLvalRef
```
Данный механизм не интуитивен, поэтому я не рекомендую использовать его в вашем коде.
#### 3.7 Не используйте ссылки в полях классов (особенно если они указывают на временные объекты) и не используйте std::reference\_wrapper для продления жизни
Во-первых, создание ссылок в полях класса на объекты, временем жизни которых класс не управляет, с большей вероятностью (по сравнению с передачей по значению) может привести к висячим ссылкам.
Во-вторых, сам этот механизм работает нестабильно. Хоть в стандарте и сказано: если временный объект имеет ссылочное поле, инициализированное другим временным объектом, то продление времени жизни рекурсивно применяется к инициализатору этого поля:
```
struct X
{
const int& lvalRef;
};
const X& lvalRef = X{1}; // Временные значения X и (int)1 будут иметь время жизни lvalRef
X&& rvalRef = X{1}; // Временные значения X и (int)1 будут иметь время жизни rvalRef
auto&& _1 = X{1}; // Тоже ок, тип Xray&& (продление по rvalue ссылке)
decltype(auto) _2 = X{1}; // Тоже ок, тип Xray (сохранение по значению)
```
Но похоже, что этот трюк срабатывает только если у вас aggregate-initialization(в случае вызова `X x{1}`) или если компилятор поддерживает copy elision (в случае вызова `X x = X{1}`). Возвращаясь к нашему примеру, добавив конструктор для инициализации нашего значения, он начинает вести себя нестабильно на разных компиляторах:
```
struct X
{
template
X(T&& l)
: val(l)
{}
const int& val;
};
const X& lvalRef = X{1}; // Висячая ссылка, значение lvalRef.val == 0
X&& rvalRef = X{1}; // Висячая ссылка, значение rvalRef .val == 0
auto&& \_1 = X{1}; // Висячая ссылка, значение \_1 .val == 0, тип X&& (продление по rvalue ссылке)
decltype(auto) \_2 = X{1}; // Тип X (сохранение по значению),
// На msvc(trunk) значение \_2 .val == 1,
// но на gcc(trunk) это висячая ссылка, значение \_2 .val == 0
```
Наиболее интересной выглядит часть `decltype(auto) _2 = X{1}`, которая компилируется в `X _2 = X{1}` и её результаты. Исходная формулировка, которая описывает выражения у которых расширяется время жизни несколько туманна, и по ней не до конца понятен весь список ситуаций, которые имеются ввиду:
> the initializer expression is used to initialize the destination object
>
>
Но я предполагаю, что в случае `decltype(auto) _2 = X{1}` время жизни должно быть продлено, потому что временный объект используется в выражении, которое является инициализатором поля `X`. Поэтому думаю, что то, что время жизни не продлевается — баг компилятора.
В связи с вышеописанным я не рекомендую использовать ссылки на временные значения в полях класса, поскольку этот механизм:
1. Работает нестабильно в зависимости от компилятора.
2. Имеет туманную формулировку, на основе которой приходится строить догадки.
#### 3.8 При передаче в new временных значений, убедитесь, что ни одно из них не сохраняется по ссылке
Временные объекты, переданные как параметры при инициализации в `new`, будут жить до тех пор пока не закончится вызов `new`. Это означает, что не стоит сохранять ссылки на временные значения в полях класса, который создается через new, поскольку это приведет к висячим ссылкам:
```
struct S
{
int i; const std::pair& pair;
};
S a { 1, {2,3} }; // верно, хоть и работает нестабильно (см. п.3.7)
S\* p = new S{ 1, {2,3} }; // неверно, p->pair — висячая ссылка
```
#### 3.9 Не продлевайте время жизни временного массива через ссылку на его элементы
В С++ есть возможность продлить время жизни временного массива, создав ссылку на один из его элементов. Я рекомендую использовать этот механизм только в полемике на кухне с коллегами (и, возможно, в метапрограммировании на старых стандартах С++), поскольку он интуитивно не понятен.
Но тем не менее подобный код, как бы ни казалось, не создает висячих ссылок, время жизни временного массива будет продлено до времени жизни ссылки на его элемент:
```
int id = 0;
int&& a = int[2]{1, 2}[id];
```
К нашему счастью, код в таком виде не скомпилируется. Чтобы он заработал нужно будет создавать массив чуть менее очевидным способом ([cppinsights](https://cppinsights.io/s/d742c711)):
```
template
using dummy = T;
int main()
{
int i = 1;
const int& a = dummy{1, 2}[i]; // тип const int&
}
```
При этом можно так же продлить жизнь через rvalue ссылку:
```
int&& a = dummy{1, 2, 3}[i];
```
Хотя пример с rvalue ссылкой уже ведёт себя нестабильно на разных компиляторах:
* На gcc всё работает как надо ([godbolt](https://godbolt.org/z/Y1oYEPoxK)).
* А на msvc ошибка компиляции `cannot convert from 'int' to 'int &&'` ([godbolt](https://godbolt.org/z/K6vG7x7ro)).
Судя по всему, это баг msvc. Но мы можем обойти его если будем принимать значение через `auto&&` ([godbolt](https://godbolt.org/z/hrWbr4n3r), [cppinsights](https://cppinsights.io/s/c5f6e2ba)):
```
auto&& a = dummy{1, 2, 3}[i]; // тип int&&
```
Заключение
----------
Сохранение значения по константной ссылке создает смешанные ощущения у каждого, кто хотя-бы раз сталкивался с висячими ссылками. Контроль времени жизни — важная штука, которую лучше не перекладывать на компилятор.
Сжальтесь над программистом, который будет читать то что вы написали, он может не знать всех этих нюансов. Да даже если он где-то про них и слышал и даже знает некоторые из них, то ему может не хватить концентрации чтобы уследить за каждым. Вероятнее всего даже самый образованный специалист, читающий ваш код, через раз всё равно будет сомневаться не висячая ли это ссылка.
Большинство данных механизмов и связанных с ними подводных камней стоит использовать только в теоретических изысканиях и операциях по обезвреживанию опасного кода.
Избегайте остроумия и `HolyHandGrenade`, всем KISS.
**UPD 06.06:**
1. Исправил ошибку в разогревающем примере из [1. Способы продления времени жизни и сохранения временных значений](https://habr.com/ru/post/669474/#1). Спасибо [@HungryD](/users/hungryd)!
2. Добавил поясняющий комментарий в примере с `lock_guard` из [3.4 При создании RAII объекта всегда сохраняйте его значение в переменную, либо же объявляйте ссылку на него](https://habr.com/ru/post/669474/#3_4). Спасибо [@findoff](/users/findoff)!
**UPD 07.06:**
1. Исправил ошибку в примере и добавил более подробный анализ в [3.9 Не продлевайте время жизни временного массива через ссылку на его элементы](https://habr.com/ru/post/669474/#3_9). Спасибо [@Apoheliy](/users/apoheliy)! | https://habr.com/ru/post/669474/ | null | ru | null |
# Пытливый взгляд АНБ: что такое война за Интернет-безопасность (Часть 2)
[](http://habrahabr.ru/company/1cloud/blog/248675/)
Предположения о том, что разведывательные агентства опередили нас настолько, что защищаться от них шифрованием бессмысленно, неверны. Как показывает один документ из архива Сноудена, АНБ не преуспело в расшифровке ряда коммуникационных протоколов, как минимум в 2012 году. В презентации для конференции, проведенной в том году, значится список программ шифрования, которые американцам взломать не удалось. В процессе дешифровки криптологи АНБ разделили свои цели на пять уровней согласно уровню сложности атаки и получаемому результату, начиная с «тривиальных» и до «катастрофических».
[[первая часть](http://habrahabr.ru/company/1cloud/blog/248435/)]
Мониторинг пути перемещения документа в Сети классифицируется, как «тривиальная» цель. Запись чата в Facebook – «несложная» задача, в то время как уровень сложности дешифровки писем, отправляемых через [российский провайдер](https://1cloud.ru/) интернет-сервисов Mail.ru, рассматривается, как задача «умеренной сложности». Но все три эти уровня классификации не представляют серьезных проблем для АНБ.
Все становится сложнее на четвертом уровне. Согласно презентации, АНБ испытывает «значительные» проблемы в попытке дешифровать сообщения, посылаемые через провайдеры сообщений электронной почты, использующие усиленные методы шифрования – к ним относится, например, сервис [Zoho](https://www.zoho.com/), или при мониторинге пользователей сети Tor, которая была разработана для анонимного веб-поиска. Tor, ПО, также известное под названием The Onion Router («луковый маршрутизатор») – бесплатное программное обеспечение с открытым исходным кодом, которое позволяет пользователям выходить в Интернет через сеть из более 6 000 связанных между собой и добровольно пожертвованных проекту компьютеров. ПО автоматически шифрует данные так, чтобы ни один компьютер из сети не содержал всей информации о пользователе. Таким образом, экспертам по наблюдению становится очень непросто отследить местонахождение человека, посещающего конкретный вебсайт, или провести атаку на кого-либо, кто использует Tor для поиска в Интернете.
«Значительные» проблемы у АНБ вызывает и [Truecrypt](http://truecrypt.sourceforge.net/), программа для шифрования файлов на компьютере. Ее разработчики прекратили развитие программы в мае прошлого года, что вызвало подозрения о давлении на них со стороны государственного Агентства. Протокол под названием Off-The-Record (OTR) для сквозного шифрования мгновенных сообщений, кажется, также вызывает у АНБ значительные сложности. Код обеих этих программ можно свободно просматривать, модифицировать и распространять. Эксперты согласны в том, что разведывательным агентствам гораздо сложнее манипулировать программами с открытым исходным кодом, чем многими из закрытых систем, разрабатываемых такими компаниями, как Apple и Microsoft. Поскольку каждый может просмотреть код такого ПО, в него крайне сложно внедрить бэкдор, который не был бы обнаружен. Транскрипты перехваченных OTR-чатов, предоставленные Агентству его партнерами по Prism – программе АНБ по сбору данных от по меньшей мере девяти американских интернет-компаний, таких как Google, Facebook и Apple – показывают, что в этом случае усилия АНБ не увенчались успехом: «Это зашифрованное с помощью OTR сообщение не подлежит дешифровке». Это значит, что протокол OTR хотя бы иногда позволяет сделать коммуникации недоступными для просмотра в АНБ.
Для Агентства ситуация становится «катастрофической» на уровне «пять»: когда, к примеру, субъект использует комбинацию Tor, еще одного сервиса «анонимизации», систему мгновенных сообщений [CSpace](http://www.anonymous-p2p.org/cspace.html) и систему интернет-телефонии (VoIP) под названием [ZRTP](https://en.wikipedia.org/wiki/ZRTP). Такая комбинации, как значится в документе АНБ, приводит к «практически полной потере возможности отследить местонахождение и коммуникации выбранного объекта».
Система ZRTP, использующаяся для безопасного шифрования переговоров и чатов на мобильных устройствах, применяется в бесплатных программах с открытым кодом, таких как RedPhone и Signal.
> «Приятно осознавать, что АНБ считает шифрование коммуникаций через наши сервисы действительно непрозрачным», – говорит разработчик RedPhone под псевдонимом Дерзкий Шип Марлина (Moxie Marlinspike).
#### «Крепкий орешек» для Форт-Мид
Буква «Z» в названии ZRTP – дань одному из разработчиков системы, Филу Циммерманну (Phil Zimmermann), который создал и систему Pretty Good Privacy, остающуюся наиболее широко распространенной на сегодняшний день программой шифрования писем и документов. PGP создана больше 20 лет назад, но, как это ни удивительно, она до сих пор «не по зубам» АНБ. «Это зашифрованное с помощью PGP сообщение не подлежит дешифровке» – значится в документе АНБ, попавшем в руки издания Spiegel, по поводу писем, пересылаемых с помощью сервиса Yahoo.
Фил Циммерманн написал PGP в 1991 году. Активист прекращения американской программы ядерных вооружений хотел создать систему шифрования, которая могла бы позволить ему безопасно обмениваться информацией с другими единомышленниками. Его система быстро стала очень популярной среди диссидентов по всему миру. С учетом широкого использования программы за пределами США, американское правительство в 1990-х начало преследование Циммерманна якобы за нарушение Закона о контроле над экспортом вооружений. Прокуроры согласились, что создание системы шифрования такой сложности и распространение ее за пределами страны незаконно. Циммерманн ответил публикацией исходного кода системы в виде книги – это было проявление свободы слова, защищенное конституцией.
PGP продолжает дорабатываться, и на сегодняшний день доступно множество версий системы. Наиболее широко распространенная – GNU Privacy Guard (GnuPG), программа, разработанная немецким программистом Вернером Кохом. Один из документов показывает, что представители альянса «Пяти глаз» порой и сами используют PGP. Оказывается, хакеры, помешанные на собственной безопасности, и власти США имеют гораздо больше общего, чем можно было вообразить. Изначально и проект Tor разрабатывался при поддержке Лаборатории военно-морских исследований США.
Сегодня, как значится в одном из документов, АНБ и его союзники всеми силами пытаются разрушить систему, которую помогли создать военные США. «Деанонимизация» Tor – очевидно один из главных приоритетов АНБ, но по этому направлению Агентство едва ли достигло успеха. Один из документов за 2011 год даже упоминает попытку дешифровки результатов использования Tor самим Агентством – в качестве теста.
Документы Сноудена должны до определенной степени вызвать чувство облегчения у людей, которые полагали, что ничто не сможет остановить АНБ в его неиссякаемой жажде к сбору информации. Кажется, что у нас все еще есть безопасные каналы связи. Тем не менее, документ показывает и то, как далеко ушли разведывательные агентства в своей работе по сохранению и дешифровке наших данных.
Интернет-безопасность осуществляется на нескольких уровнях – и АНБ вместе с союзниками очевидно способны «использовать» (то есть «взломать») – некоторые наиболее широко используемые из них в масштабах доселе немыслимых.
#### Безопасность виртуальных частных сетей и в самом деле «виртуальная»
Один из примеров – виртуальные частные сети (VPN), которые часто используются компаниями и институтами, работающими в нескольких офисах и локациях. В теории VPN создает безопасный туннель между двумя точками в Сети. Все данные, криптографически защищенные, направляются в этот туннель. Но когда речь идет об уровне безопасности VPN, слово «виртуальный» как нельзя лучше подходит для его описания. Все потому, что АНБ работает над крупномасштабным проектом использования VPN для взлома большого количества соединений, что позволяет Агентству перехватывать информацию, передающуюся в сетях VPN – включая, к примеру, VPN-сеть правительства Греции. Согласно документу, попавшему в руки Spiegel, команда АНБ, ответственная за работу с греческими VPN-коммуникациями, состоит из 12 человек.
Целью АНБ был и ирландский VPN-сервис SecurityKiss. Следующий «цифровой отпечаток» для Xkeyscore, мощной программы-шпиона, созданной агентством, был, согласно отчетам АНБ, протестирован и использовался для извлечения данных сервиса:
`fingerprint('encryption/securitykiss/x509') = $pkcs and ( ($tcp and from_port(443)) or ($udp and (from_port(123) or from_por (5000) or from_port(5353)) ) ) and (not (ip_subnet('10.0.0.0/8' or '172.16.0.0/12' or '192.168.0.0/16' )) ) and 'RSA Generated Server Certificate'c and 'Dublin1'c and 'GL CA'c;`
Согласно документу АНБ, датированному 2009 годом, Агентство обрабатывало 1000 запросов в час от VPN-соединений. Ожидалось, что это число возрастет до 100 000 в час к концу 2011 года. Целью системы была полная обработка «по меньшей мере 20%» этих запросов, что означает, что полученные данные должны были быть дешифрованы и переданы адресату. Другими словами, к концу 2011 года АНБ планировало непрерывно отслеживать до 20 000 предположительно безопасных VPN-соединений в час.
VPN-соединения могут быть построены на основе различных протоколов. Наиболее часто используется туннельный протокол точка-точка (Point-to-Point Tunneling Protocol, PPTP) и протоколы безопасности IPsec (Internet Protocol Security). Эти протоколы не представляют особых проблем для шпионов АНБ, если те действительно хотят взломать соединение. Эксперты уже называли протокол PPTP небезопасным, но он продолжает использоваться во множестве коммерческих систем. Авторы одной из презентаций АНБ хвастались проектом под названием FOURSCORE, который сохраняет информацию, включающую зашифрованные метаданные, передаваемые по протоколам PPTP.
В документах АНБ значится, что, используя большое количество различных программ, службы Агентства проникли в множество корпоративных сетей. Среди тех, кто подвергся слежению, значатся: российский авиаперевозчик Трансаэро, Королевские Иорданские Авиалинии, а также телеком-провайдер из Москвы «Мир Телематики». Другое достижение этой программы – установление слежения за внутренними коммуникациями дипломатов и государственных служащих Афганистана, Пакистана и Турции.
IPsec – протокол, который, на первый взгляд, создает шпионам больше проблем. Но у АНБ есть ресурсы для проведения множества атак на маршрутизаторы, вовлеченные в процесс создания соединений, для получения ключей и скорее расшифровки, нежели дешифровки передаваемой информации – об этом свидетельствует сообщение из отдела АНБ под названием Tailored Access Operations (Операции Особого Доступа): «TAO получил доступ к маршрутизатору, через который проходит основной банковский трафик», говорится в одной из презентаций.
#### Ничего общего с безопасностью
Предположительно безопасные системы, на которые обычные интернет-пользователи полагаются постоянно при проведении финансовых операций, оплате электронных покупок или доступе к почтовым аккаунтам, оказываются еще менее защищенными, чем VPN. Обыватель может легко распознать эти «безопасные» соединения, взглянув на адресную строку в браузере: при таком соединении адрес будет начинаться не с «http» – а с «https». «S» в данном случае означает «secure», «безопасный». Проблема в том, что у этих протоколов нет ничего общего с безопасностью.
Такие соединения АНБ и его союзники взламывают играючи – по миллиону в день. Согласно документу АНБ, Агентство планировало довести объем взломанных https-соединений до 10 миллионов в день к концу 2012 года. Службы разведки особенно заинтересованы в сборе пользовательских паролей. К концу 2012 года система должна была «отслеживать состояние по меньшей мере 100 приложений, использующих шифрование и работающих на основе ввода пароля» при каждом случае их использования примерно 20 000 раз в месяц.
Например, британский Центр правительственной связи собирает информацию о шифровании с использованием протоколов TLS и SSL – это протоколы шифрования https-соединений – в БД под названием «FLYING PIG». Британские шпионы еженедельно создают отчеты по текущему состоянию системы для каталогизации сервисов, которые чаще всего используют протоколы SSL, и сохраняют подробности этих соединений. Такие сервисы, как Facebook, Twitter, Hotmail, Yahoo и iCloud отличаются особенно частым использованием подобных протоколов, а само число еженедельно фиксирующихся британской службой соединений исчисляется миллиардами – и это только для 40 наиболее популярных сайтов.
#### Мониторинг хоккейных сайтов
Канадский Центр безопасности коммуникаций следит даже за сайтами, посвященными самому популярному национальному времяпрепровождению: «Мы отследили значительное увеличение активности в чатах на сайтах, посвященных обсуждению хоккея. Вероятно, это связано с началом сезона плей-офф», – говорится в одной из презентаций.
АНБ также создало программу, с помощью которой, как оно заявляет, может быть дешифрован протокол SSH. Он, как правило, используется системными администраторами для удаленного доступа к компьютерам сотрудников, в основном для использования интернет-маршрутизаторами, системами бизнес-инфраструктуры и другими подобного рода службами. АНБ объединяет данные, полученные таким образом, с другой информацией для управления доступом к важным системам.
#### Слабеющие криптографические стандарты
Но как альянсу «Пяти глаз» удается взламывать все эти стандарты и системы шифрования? Короткий ответ: они используют все доступные возможности.
Одна из них – серьезное ослабевание криптографических стандартов, использующихся для создания подобных систем. Документы, попавшие к изданию Spiegel, свидетельствуют, что агенты АНБ посещают собрания организации Internet Engineering Task Force (IETF), которая разрабатывает подобные стандарты, для сбора информации, а также, предположительно, для оказания влияния на проводимые на собраниях дискуссии. «Новая сессия расширений политик может улучшить нашу способность пассивно отслеживать двусторонние коммуникации», – значится в коротком описании собрания IETF в Сан-Диего во внутренней информационной системе АНБ.
Этот процесс ослабевания криптографических стандартов ведется уже достаточно долго. Сборник классификаторов, документ, объясняющий, как классифицировать определенные типы секретной информации, помечает «тот факт, что АНБ/Центральная служба безопасности проводит криптографические модификации коммерческих устройств или систем обеспечения безопасности для их последующего использования» грифом «Совершенно секретно».
*Сборник классификаторов АНБ: «Криптографические модификации»*
Криптографические системы, таким образом достаточно сильно ослабевшие или неисправные, затем обрабатываются при использовании суперкомпьютеров. АНБ создало систему под названием Longhaul – «сервис оркестровки сквозных атак и восстановления ключей для трафика Data Network Cipher и Data Network Session Cipher». По сути, Longhaul для АНБ – источник поиска возможностей для дешифровки различных систем.
[](http://i.imgur.com/KXa0DW6.jpg)
Согласно документу АНБ, система использует мощности суперкомпьютеров Tordella Supercomputer в Форт-Мид, штат Мэриленд, и Окриджского дата-центра в городе Ок-Ридж, штат Теннесси. Сервис может передавать дешифрованные данные таким системам, как Turmoil – это часть секретной сети, которую АНБ развернуло по всему миру для перехвата данных. Кодовое название для разработок в этом направлении – Valientsurf. Похожая программа под названием Gallantwave разработана для «взлома туннельных протоколов и протоколов сессий».
В других случаях шпионы используют свою инфраструктуру для похищения криптографических ключей из конфигурационных файлов маршрутизаторов. Репозиторий под названием Discoroute содержит «конфигурационные данные маршрутизаторов полученные активным и пассивным образом». Активный сбор подразумевает взлом или иное проникновение в компьютерные системы, пассивный сбор означает получение данных, передаваемых по Интернету через секретные компьютеры, которыми управляет АНБ.
Важная часть работы альянса «Пяти глаз» по дешифровке состоит в том, чтобы просто собирать огромные массивы данных. Например, они собирают так называемые SSL handshake-сообщения – информацию, которой обмениваются компьютеры для установления SSL-соединения. Комбинация метаданных о соединении и метаданных протоколов шифрования может помочь получить ключи, которые в свою очередь позволяют прочесть или записать дешифрованный трафик.
Наконец, если другие способы не помогают, АНБ и союзники полагаются на метод грубой силы: они организуют хакерскую атаку на целевой компьютер или маршрутизатор для получения секретных данных – или перехватывают сами компьютеры на пути к месту доставки, вскрывают их и внедряют туда жучки – этот процесс называется «затруднение действий противника».
#### Серьезная угроза безопасности
Для АНБ дешифрование представляет собой постоянный конфликт интересов. Агентство и его союзники обладают собственными секретными методами шифрования для внутреннего использования. Но АНБ также обязано предоставлять в Национальный Институт Стандартов и Технологий США (US National Institute of Standards and Technology, NIST) «руководства по выбору надежных технологий», которые «могут быть использованы в экономически эффективных системах для защиты чувствительных данных». Другими словами, проверка качества криптографических систем – часть работы АНБ. Один из стандартов шифрования, который рекомендуется NIST – стандарт Advanced Encryption Standard (AES). Он используется в различных системах, начиная с шифрования PIN-кода банковской карты до шифрования жесткого диска компьютера.
Один из документов АНБ свидетельствует о том, что Агентство активно ищет способы взломать стандарт, который само же рекомендует – эта секция помечена грифом «Совершенно секретно»: «Электронные кодовые книги, такие как Advanced Encryption Standard, одновременно и широко распространены, и хорошо защищены от криптоатак. АНБ владеет только небольшим количеством внутренних техник по их взлому. Проект TUNDRA исследует потенциально новую технику для определения ее полезности при анализе электронных кодовых книг».
Тот факт, что огромное количество криптографических систем, заполонивших Интернет, намеренно ослаблены или взломаны АНБ и его союзниками, представляет огромную угрозу безопасности каждого, кто полагается на Интернет – начиная с пользователей, рассчитывающих на безопасность в Сети, и заканчивая институтами и компаниями, работающими с облачными вычислениями. Многие из этих «дыр» могут быть использованы каждым, кто о них узнает – и не только АНБ.
В самом разведывательном управлении об этом хорошо известно: согласно документу 2011 года, 832 сотрудника Центра правительственной связи сами стали участниками проекта BULLRUN, целью которого является широкомасштабный удар по Интернет-безопасности.
*Двое авторов статьи, Джейкоб Аппельбаум (Jacob Appelbaum) и Аарон Гибсон (Aaron Gibson), работают в проекте Tor. Аппельбаум также работает в проекте OTR и участвует в создании других программ шифрования данных.* | https://habr.com/ru/post/248675/ | null | ru | null |
# Расширение Visual Studio для визуализации пользовательских классов в режиме отладки
Доброго времени суток,
В этой статье я хочу рассказать о создании расширения для Visual Studio, которое помогает визуализировать сложные пользовательские классы в процессе отладки приложения.
#### Предыстория
В своем проекте мы активно используем отечественное геометрическое ядро [C3D Kernel](http://c3dlabs.com/). Эта библиотека предоставляет большое количество классов для работы с кривыми, телами, поверхностями и т.п. Эти классы имеют сложную структуру и в процессе отладки приложения, используя стандартные средства визуализации Visual Studio, трудно понять, какая, например, поверхность хранится в конкретной переменной. А при отладке сложных алгоритмов очень важно понимать, что происходит с объектом на каждом шаге алгоритма.
Мы пытались обойти эту проблему различными способами. Например, выписывали координаты точек на листочек, если речь шла о простой двумерной кривой. А потом по точкам рисовали эту кривую. Второй вариант решения проблемы: сохранять в нужный момент объект в файл, а затем открывать этот файл в тестовой утилите из поставки библиотеки. Это действительно помогает при отладке, но требует довольно много ручной работы. Нужно вставить код сохранения объекта в файл, перекомпилировать приложение, выполнить необходимые действия в самом приложении для запуска конкретного алгоритма, далее открыть в утилите сохраненный файл, посмотреть результат, внести при необходимости исправления в алгоритм и повторить всю процедуру опять. В целом терпимо, но хотелось иметь возможность прямо в Visual Studio в режиме отладки навести на нужную переменную и в удобном виде посмотреть, как выглядит, хранящийся там объект.
#### Visual Studio Extension
В поисках решения этой проблемы я наткнулся на расширение для Visual Studio [Image Watch](https://visualstudiogallery.msdn.microsoft.com/e682d542-7ef3-402c-b857-bbfba714f78d) от самой Microsoft для OpenSource библиотеки OpenCV. Это расширение позволяет просматривать в процессе отладки содержимое переменных типа cv::Mat, читай bitmap'ов. Тогда пришла идея написать похожее расширение, но для наших типов. К сожалению, найти исходный код этого расширения в открытом доступе не удалось, что на мой взгляд странно. Пришлось по крупицам собирать информацию, о том как писать подобные расширения для Visual Studio. С документацией по этой теме на msdn все печально. И примеров не очень много, а точнее один [std::vector visualizer](https://code.msdn.microsoft.com/Writing-graphical-debugger-a17e3d75). Который еще не так то просто найти. Суть примера: визуализация на графике int чисел, лежащих в std::vector в режиме отладки:
#### Создание расширения
Для создания расширений нужно установить Visual Studio SDK. После установки в мастере проектов появляется новый тип проекта:
Мастер создания нового проекта создаст все необходимые файлы и сконфигурирует проект.
Я не буду повторять описание из примера от Microsoft, там уже кратко описаны шаги для создания расширения. Всем заинтересовавшимся рекомендую посмотреть описание к этому примеру. В этой статье я хотел затронуть те моменты, которые не описаны в этом примере.
#### Получение значения переменной
Переменная, содержимое которой мы хотим посмотреть, и само расширение располагаются в разных процессах. Из этого примера было по-прежнему непонятно, как получить данные из более сложных пользовательских типов. В примере демонстрируется прием, когда используя интерфейс IDebugProperty3, мы узнаем адрес первого элемента в векторе и адрес последнего элемента. Вычитанием адресов находим размер участка памяти и затем копируем этот участок памяти к себе в процесс. Приведу здесь код из примера:
**Получение данных из объекта**
```
public int DisplayValue(uint ownerHwnd, uint visualizerId, IDebugProperty3 debugProperty)
{
int hr = VSConstants.S_OK;
DEBUG_PROPERTY_INFO[] propertyInfo = new DEBUG_PROPERTY_INFO[1];
hr = debugProperty.GetPropertyInfo(
enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ALL,
10 /* Radix */,
10000 /* Eval Timeout */,
new IDebugReference2[] { },
0,
propertyInfo);
Debug.Assert(hr == VSConstants.S_OK, "IDebugProperty3.GetPropertyInfo failed");
// std::vector internally keeps pointers to the first and last elements of the dynamic array
// First get the values of those members. We are going to use them later for reading vector elements.
// An std::vector variable has the following nodes in raw view:
// myVector
// + std::\_Vector\_alloc<0,std::\_Vec\_base\_types > >
// + std::\_Vector\_val >
// + std::\_Container\_base12
// + \_Myfirst
// + \_Mylast
// + \_Myend
// This is the underlying base class of std::vector (std::\_Vector\_val > node above)
DEBUG\_PROPERTY\_INFO vectorBaseClassNode = GetChildPropertyAt(0, GetChildPropertyAt(0, propertyInfo[0]));
// myFirstInfo member points to the first element
DEBUG\_PROPERTY\_INFO myFirstInfo = GetChildPropertyAt(1, vectorBaseClassNode);
// myLastInfo member points to the last element
DEBUG\_PROPERTY\_INFO myLastInfo = GetChildPropertyAt(2, vectorBaseClassNode);
// Vector length can be calculated by the difference between myFirstInfo and myLastInfo pointers
ulong startAddress = ulong.Parse(myFirstInfo.bstrValue.Substring(2), System.Globalization.NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
ulong endAddress = ulong.Parse(myLastInfo.bstrValue.Substring(2), System.Globalization.NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
uint vectorLength = (uint)(endAddress - startAddress) / elementSize;
// Now that we have the address of the first element and the length of the vector,
// we can read the vector elements from the debuggee memory.
IDebugMemoryContext2 memoryContext;
hr = myFirstInfo.pProperty.GetMemoryContext(out memoryContext);
Debug.Assert(hr == VSConstants.S\_OK, "IDebugProperty.GetMemoryContext failed");
IDebugMemoryBytes2 memoryBytes;
hr = myFirstInfo.pProperty.GetMemoryBytes(out memoryBytes);
Debug.Assert(hr == VSConstants.S\_OK, "IDebugProperty.GetMemoryBytes failed");
// Allocate buffer on our side for copied vector elements
byte[] vectorBytes = new byte[elementSize \* vectorLength];
uint read = 0;
uint unreadable = 0;
hr = memoryBytes.ReadAt(memoryContext, elementSize \* vectorLength, vectorBytes, out read, ref unreadable);
Debug.Assert(hr == VSConstants.S\_OK, "IDebugMemoryBytes.ReadAt failed");
// Create data series that will be needed by the plotter window and add vector elements to the series
Series series = new Series();
series.Name = propertyInfo[0].bstrName;
for (int i = 0; i < vectorLength; i++)
{
series.Points.AddXY(i, BitConverter.ToUInt32(vectorBytes, (int)(i \* elementSize)));
}
// Invoke plotter window to show vector contents
PlotterWindow plotterWindow = new PlotterWindow();
WindowInteropHelper helper = new WindowInteropHelper(plotterWindow);
helper.Owner = (IntPtr)ownerHwnd;
plotterWindow.ShowModal(series);
return hr;
}
///
/// Helper method to return the child property at the given index
///
/// The index of the child property
/// The parent property
/// Child property at index
public DEBUG\_PROPERTY\_INFO GetChildPropertyAt(int index, DEBUG\_PROPERTY\_INFO debugPropertyInfo)
{
int hr = VSConstants.S\_OK;
DEBUG\_PROPERTY\_INFO[] childInfo = new DEBUG\_PROPERTY\_INFO[1];
IEnumDebugPropertyInfo2 enumDebugPropertyInfo;
Guid guid = Guid.Empty;
hr = debugPropertyInfo.pProperty.EnumChildren(
enum\_DEBUGPROP\_INFO\_FLAGS.DEBUGPROP\_INFO\_VALUE | enum\_DEBUGPROP\_INFO\_FLAGS.DEBUGPROP\_INFO\_PROP | enum\_DEBUGPROP\_INFO\_FLAGS.DEBUGPROP\_INFO\_VALUE\_RAW,
10, /\* Radix \*/
ref guid,
enum\_DBG\_ATTRIB\_FLAGS.DBG\_ATTRIB\_CHILD\_ALL,
null,
10000, /\* Eval Timeout \*/
out enumDebugPropertyInfo);
Debug.Assert(hr == VSConstants.S\_OK, "GetChildPropertyAt: EnumChildren failed");
if (enumDebugPropertyInfo != null)
{
uint childCount;
hr = enumDebugPropertyInfo.GetCount(out childCount);
Debug.Assert(hr == VSConstants.S\_OK, "GetChildPropertyAt: IEnumDebugPropertyInfo2.GetCount failed");
Debug.Assert(childCount > index, "Given child index out of bounds");
hr = enumDebugPropertyInfo.Skip((uint)index);
Debug.Assert(hr == VSConstants.S\_OK, "GetChildPropertyAt: IEnumDebugPropertyInfo2.Skip failed");
uint fetched;
hr = enumDebugPropertyInfo.Next(1, childInfo, out fetched);
Debug.Assert(hr == VSConstants.S\_OK, "GetChildPropertyAt: IEnumDebugPropertyInfo2.Next failed");
}
return childInfo[0];
}
```
Все бы ничего, но здесь показано, как достать данные из объекта, если эти данные хранятся в едином участке памяти. Видимо похожий подход использует и сам MS в своем расширение Image Watch. Там изображение тоже хранится в едином куске памяти и есть указатель на начало этого куска.
А что делать, если пользовательский тип имеет сложную иерархическую структуру и не похож на обычный массив данных? Все еще хуже, если класс хранит указатели на базовые классы других классов. Восстановить такой объект по кусочкам кажется нереальной задачей. Плюс такая конструкция очень хрупкая — при добавлении в какой-то промежуточный класс нового члена расширение перестает работать. В идеале мне хотелось получить сам объект или его копию. К сожалению, я не нашел способа, как такое провернуть оставаясь исключительно в рамках одного лишь расширения. Но зная, что нужные нам классы умеют сериализовывать себя в файл или в буфер в памяти, я решил, что можно использовать гибридный подход: с shared memory и вектором. Это решение не очень изящное и требует правки классов, но вполне рабочее. Плюс ничего лучше не придумалось.
#### Реализация
Суть метода:
В каждый класс (который мы хотим дебажить), добавляется специальный класс, содержащий одно поле: std::vector. В векторе мы будем хранить строку-маркер, по которой потом можно будет найти сериализованный объект в shared memory. Далее, в каждый не константный метод класса добавляем вызов функции сохранения класса в shared memory. Теперь при каждом изменении класса, он будет сохранять себя в shared memory.
В самом расширении: достаем из объекта строку-маркер, используя метод из примера MS. Далее, по маркеру достаем из shared memory сериализованный объект и десериализуем его. В итоге мы имеем копию объекта в нашем расширении. Ну а дальше уже дело техники. Из объекта достаем полезные нам данные и как-то показываем их в удобном виде.
#### HabraLine Debug Visualizer
Для демонстрации этой идеи был написан пример расширения. Так же для демонстрации работы расширения была написано простейшая библиотека. В этой библиотеке всего два класса: HabraPoint и HabraLine. Плюс пара классов, необходимых для сериализации и работы с shared memory. Класс HabraLine — это просто отрезок. Для сериализации и работы с shared memory используется boost. После установки расширения, у нас появляется возможность визуализировать значение переменных типа HabraLine.
Посмотреть расширение в действии можно на коротком видео:
Ссылка на исходники расширения: [ТЫНЦ](https://github.com/ershovdz/HabraLineDebugVisualizer)
Ссылка на демонстрационный проект: [ТЫНЦ](https://github.com/ershovdz/HabraLineLibrary)
Надеюсь эта статья будет кому-нибудь полезна и вдохновит на написание полезных расширений к Visual Studio.
Всем удачи. | https://habr.com/ru/post/242231/ | null | ru | null |
# Интеграция XML данных — другой путь
В данной статье описывается «нетрадиционная», но достаточно мощная технология обработки XML, позволяющая импортировать любые XML-данные и преобразовывать их структуру эффективно и просто, при этом один и тот же процесс обработки позволяет трансформировать исходные данные любой структуры без какого-либо изменения программного кода.
XML как промежуточный формат обмена данными «оброс» экосистемой технологий и инструментов для работы с ним– специализированные редакторы, DOM-парсеры, XQUERY/XPATH, XSLT, специальные модули ETL и т. д. Все это многообразие и развитость инструментария идеологически приводят к тому, что у нас есть теперь технологии работы не просто с данными, а со специальными XML-данными. Это как отдельно «наука химия» и отдельно «наука химия для веществ, которые хранятся в синих коробках».
Описываемые далее принципы обработки позволили немножко «отмотать назад» условный прогресс технологий и перевести практически всю работу с XML данными на уровень «чистой» СУБД, без специфичного XML-инструментария. Такой подход дал возможность организовать унифицированное хранение любых XML-данных и обеспечить быстрый произвольный доступ к нужным частям информации. Кроме того, появилась возможность реализовывать ETL-функционал универсальным незатратным (практически без кодирования) способом.
Описываемый подход особенно хорошо показал себя на источниках данных большого объема и сложной структуры, с частыми изменениями схемы данных. Если вам приходится иметь дело с небольшим объемом информации, и/или структура несложная– возможно, данная технология вам (пока) не нужна.
Хорошим демо-кейсом для этой технологии могут служить открытые данные сервера госзакупок zakupki.gov.ru, доступные на соответствующем FTP: объём ежедневных обновлений – десятки и сотни тысяч XML файлов объемом в гигабайты или десятки гигабайт, в среднем раз в несколько недель выходит новая версия схемы данных.
Структура данных следует за требованиями законодательства, поэтому, например, информация об извещениях о проведении госзакупок представлена более чем десятком типов документов fcsNotification\* в зависимости от типа закупки (электронный аукцион fcsNotificationEF, запрос котировок fcsNotificationZK, закупка у единственного поставщика fcsNotificationEP и т. п.)
Все эти документы основаны на одном базовом типе извещения но отличаются в деталях, поэтому для целей анализа все это многообразие при импорте надо в какой-то момент “схлопывать” и приводить к «единому знаменателю».
На данных госзакупок описываемый подход успешно применен и эффективно работает.
**Кратко этапы/элементы описываемой технологии:**
**(1)** **Импорт всех XML данных в таблицу** унифицированной структуры. Речь не идет о сохранении в базу документов целиком, мы импортируем данные поэлементно как пары “имя элемента” – “значение” или “имя атрибута” – “значение”. В результате данного этапа мы избавляемся от XML как формата хранения и получаем быстрый унифицированный доступ к данным всех импортированных XML-документов любой структуры (при этом нам больше не нужен XQUERY/XPATH).
**(2)** Вторым элементом технологии является **создание спецификаций** на “вытаскивание” нужных нам данных – выявление результирующих таблиц, в которые мы будем выливать данные, и маппинг полей источника и результата. Этот этап может быть проведен как на основе XSD-схем документов, так и без использования схем, через анализ закачанных на первом этапе образцов документов. Данный этап не требует никакого программирования и специальных навыков, основной инструментарий здесь – электронная таблица.
**(3)** Завершающие шаги – выборка нужной информации из первичного хранилища импорта (1) с помощью спецификаций (2), преобразование в “колоночное” представление (“пивотирование”) и автоматизированная **трансформация в финальный “аналитический” формат** – в терминах аналитических хранилищ данных это таблицы фактов структуры “звездочка” (star) со ссылками на справочники измерений (dimensions) и числовыми показателями-мерами (measures).
#### 1. Первичный импорт.
Мы рассматриваем XML-документ как дерево, вершинами которого являются пары “имя”-“значение”. Таким образом, описываемый подход достаточно универсален и может быть применен к любому древовидному представлению данных.
**Структура таблицы для загрузки данных из XML:**
* **Record\_ID**: идентификатор элемента специального иерархического вида, позволяющий связывать друг с другом разные уровни документа
* **File\_ID**: поскольку в таблицу надо будет загружать содержимое множества XML-файлов, надо также хранить идентификатор файла
* **Path**: полный путь к данному элементу начиная с корня документа (фактически, это XPATH-путь до данного элемента)
* **Element\_Name**: название элемента или атрибута
* **Element \_Value**: значение элемента или атрибута (в виде строки – так же, как оно хранится в XML)
* **Type**: тип записи (элемент это или атрибут) – сохраним на всякий случай, вдруг потом надо будет из таблицы восстановить XML
Идея загрузки дерева в таблицу достаточно очевидная. В MS SQL (про другие СУБД не скажу, не смотрел) есть такая встроенная возможность –XML без указания схемы импортируется в так называемую EDGE-таблицу. Это не совсем то что нам нужно, т. к. в EDGE-формате хранятся отдельными записями имя элемента и его значение (то есть имя есть родительская запись для значения) – такой формат попросту неудобно использовать для дальнейших манипуляций. К тому же в EDGE таблице связи в дереве прописаны через указание ParentID.
Короче говоря, сделать нужное представление данных из EDGE таблицы можно, но придется немножко попотеть для “склеивания” названий и значений элементов, воссоздания XPATH до каждого элемента и создания иерархического идентификатора (о том, как мы его будем строить – чуть ниже). При большом объеме данных решение этих задач может оказаться довольно ресурсоемким, но зато можно обойтись единственным инструментом/языком.
Более правильный путь – получить дерево документа с помощью XML-парсера (какая-нибудь реализация есть практически в каждом языке и среде разработки) и заполнить нужную информацию одним проходом по документу.
Давайте посмотрим на конкретный пример. Есть у нас демо XML-файлы deliveries.xml и returns.xml. Файл **deliveries.xml (доставки)** содержит корневой элемент Deliveries, на верхнем уровне даты начала и окончания периода за который выгружены данные, дальше идут продукты с указанием названия и поставщика, по каждому продукту идет детализация информации доставок – дата, количество, цена.
**deliveries.xml**
```
2017-01-01
2017-01-31
Zaanse Snoepfabriek
Chocolade
2017-01-03
10.2000
70
Mayumi's
Tofu
2017-01-09
18.6000
12
2017-01-13
18.7000
20
```
Файл **returns.xml (возвраты)** абсолютно аналогичный, только корневой элемент называется Returns и в деталях элемент с датой по-другому называется.
**returns.xml**
```
2017-02-01
2017-02-28
Pavlova, Ltd.
Pavlova
2017-02-21
13.9000
2
Formaggi Fortini s.r.l.
Mozzarella di Giovanni
2017-02-27
27.8000
4
```
Имена загруженных файлов хранятся в отдельной таблице, коды наших файлов там равны 2006 (deliveries) и 2007 (returns).
В нашей таблице-приемнике образ наших демо-документов будет выглядеть так:
**(Тут не все, только начало таблицы)**
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Record\_ID** | **File\_ID** | **Path** | **Element\_Name** | **Element\_Value** | **Type** |
| 001 | 2006 | | Deliveries | | E |
| 001\001 | 2006 | Deliveries\ | PeriodBegin | 2017-01-01 | E |
| 001\002 | 2006 | Deliveries\ | PeriodEnd | 2017-01-31 | E |
| 001\003 | 2006 | Deliveries\ | Products | | E |
| 001\003\001 | 2006 | Deliveries\Products\ | Product | | E |
| 001\003\001\001 | 2006 | Deliveries\Products\
Product\ | Supplier | Zaanse Snoepfabriek | E |
| 001\003\001\002 | 2006 | Deliveries\Products\
Product\ | ProductName | Chocolade | E |
| 001\003\001\003 | 2006 | Deliveries\Products\
Product\ | Details | | E |
| 001\003\001\003\
001 | 2006 | Deliveries\Products\
Product\Details\ | Detail | | E |
| 001\003\001\003\
001\001 | 2006 | Deliveries\Products\
Product\Details\Detail\ | DeliveryDate | 2017-01-03 | E |
| 001\003\001\003\
001\002 | 2006 | Deliveries\Products\
Product\Details\Detail\ | UnitPrice | 10.2000 | E |
| 001\003\001\003\
001\003 | 2006 | Deliveries\Products\
Product\Details\Detail\ | Quantity | 70 | E |
По поводу иерархического идентификатора **Record\_ID**: его цель — уникально пронумеровать узлы дерева документа с сохранением информации о связях со всеми предками.
**К сведению:**В том же SQL Server есть специальный тип данных (объектное расширение) под названием hierarchyid, служащий для этих целей.
В приведенном примере мы используем простую платформенно-независимую реализацию c последовательной конкатенацией счетчиков элементов на каждом уровне дерева. Мы “добиваем” счетчик каждого уровня нулями до заданной фиксированной глубины, чтобы получить легкое и быстрое выделение идентификаторов предков любого уровня через выделение подстрок фиксированной длины.
Вот собственно и все на этом этапе. Теперь мы можем простыми SQL-запросами выделить подмножества данных продуктов, деталей по доставкам или возвратам и связать их друг с другом через идентификаторы файлов и элементов.
Во многих случаях этого подхода будет вполне достаточно для эффективного хранения данных и организации доступа к ним, описанные далее “продвинутые” техники могут не понадобиться.
Действительно, мы уже загрузили все наши данные в единое хранилище, не обращая внимания на возможную разницу в структуре документов, получили достаточно эффективный способ вычленять нужную информацию из всего массива простыми SQL-запросами, можем связывать между собой “вычлененные” подмножества данных.
Производительность такого решения как системы хранения исходников XML для разовых запросов, даже без оптимизации индексов и прочих ухищрений, будет явно гораздо выше, чем если бы вы хранили XML в файлах или даже записывали его в специальные поля БД. В нашем случае не надо запускать процедуру XPATH поиска (которая подразумевает новый парсинг) к каждому документу, мы это проделали один раз и дальше спокойно пользуемся сохраненным результатом через достаточно простые запросы.
**Однако:**На этом этапе мы пока не сделали так, чтобы **DeliveryDate**, **Quantity** и **UnitPrice** стали полями одной таблицы, это описывается как процесс “пивотирования” в третьем разделе.
На следующих этапах мы рассмотрим трансформацию этих XML документов в единую структуру данных, содержащую 3 таблицы: **MovementReports** (тип движения – доставка или возврат, даты начала и окончания из корня документа), **Products** (название и поставщик) и **MovementDetails** (цена, количество, дата – поле даты в результате будет единое для обоих исходных документов, несмотря на то, что в исходных файлах поля по-разному называются)
#### 2. Создание спецификаций трансформации в результирующие таблицы.
Рассмотрим процесс создания спецификаций на маппинг исходных данных и результирующих таблиц. Для создания таких спецификаций нам потребуется еще кое-что.
##### 2.1. Получение таблички со структурой документов.
Для дальнейшей обработки нужно иметь развернутую структуру всех наших XML-документов, чтобы на ее основе решать в какую структуру таблиц мы все это будем преобразовать.
Одного конкретного образца XML-документа для этой задачи нам мало, в конкретном документе может не быть каких-то необязательных элементов, которые неожиданно обнаружатся в других документах.
Если у нас нет XSD-схемы или мы не хотим с ней связываться, то нам может быть достаточно загрузить в нашу таблицу какую-то репрезентативную выборку образцов XML-документов и построить с помощью группировки по полям **Path** и **Element\_Name** нужный нам список.
Однако не забывайте, что мы хотим в итоге загрузить информацию в некие целевые “финальные” таблицы, поэтому нам надо знать где в XML хранятся отношения **один-ко-многим**. То есть надо понять какие элементы формируют “дочернюю” таблицу, где происходит размножение.
Иногда, если схема документа не очень сложная, нам это сразу понятно эмпирически, “глазками”. Также при группировке данных нашей “репрезентативной выборки” мы можем посчитать количество элементов и увидеть по этой статистике где они начинают “размножаться”. Но в общем случае, если у нас есть нормальная XSD-схема, лучше воспользоваться ей – размножение данных один ко многим мы “поймаем”, выявив XSD конструкцию **maxoccurs=unbounded**.
Как видим, задача немного усложняется: хочется получить не только простую табличку, содержащую список XPATH-путей для всех элементов наших документов, но еще и с указанием того, где начинается размножение данных. (А при анализе хорошо прописанной XSD-схемы приятном бонусом могли бы получить возможность вытащить описания элементов и их типы.)
Очень хорошо было бы для получения такой таблички использовать функциональность какого-нибудь XML-редактора, однако найти такой инструмент, который бы выдавал нужную нам структуру документов по XSD-схеме, не удалось (искали и пробовали долго).
Во всех этих Oxygen, Altova, Liquid и менее навороченных нужная информация внутри, несомненно, используется – однако отдавать ее в нужном виде никто из них не умеет. Как правило, в продвинутом редакторе есть возможность генерировать Sample XML на основании схемы, но в XSD может быть конструкция **choice**, когда в документе может присутствовать что-то на выбор из нескольких разных элементов –тогда уж лучше реальные “боевые” образцы документов проанализировать. И еще — по образцу или образцам документов мы момент размножения информации один-ко-многим в явном виде тоже не поймаем.
В итоге пришлось изобретать велосипед и писать генератор такой таблички (фактически, парсер XSD специального вида) самостоятельно. Благо XSD это тоже XML, его можно так же загрузить в наше хранилище и реляционными операциями вытащить нужный вид. Если схема простая, без ссылок на сложные типы элементов и без наследования от базовых типов, то это достаточно просто. В случае, когда все это наследование типов в наличии (как в госзакупках, например), задача посложнее.
**Для нашего примера мы получим примерно вот такую таблицу структуры документов:**
| | | |
| --- | --- | --- |
| **Path** | **Element\_Name** | **maxoccurs** |
| Deliveries\ | PeriodBegin | |
| Deliveries\ | PeriodEnd | |
| Deliveries\Products\Product\ | ProductName | Products\Product |
| Deliveries\Products\Product\ | Supplier | Products\Product |
| Deliveries\Products\Product\Details\Detail\ | DeliveryDate | Products\Product\Details\Detail |
| Deliveries\Products\Product\Details\Detail\ | Quantity | Products\Product\Details\Detail |
| Deliveries\Products\Product\Details\Detail\ | UnitPrice | Products\Product\Details\Detail |
| Returns\ | PeriodBegin | |
| Returns\ | PeriodEnd | |
| Returns\Products\Product\ | ProductName | Products\Product |
| Returns\Products\Product\ | Supplier | Products\Product |
| Returns\Products\Product\Details\Detail\ | Quantity | Products\Product\Details\Detail |
| Returns\Products\Product\Details\Detail\ | ReturnDate | Products\Product\Details\Detail |
| Returns\Products\Product\Details\Detail\ | UnitPrice | Products\Product\Details\Detail |
##### 2.2. Описание трансформации
Получив исходные данные в виде табличной спецификации документов, переходим к дизайну трансформации данных. В результате этой трансформации мы преобразуем данные нашего исходного хранилища первичного XML в новые таблицы с новыми именами полей и уникальными кодами записей целевых таблиц. Нам не нужны какие-то специальные программные инструменты, просто добавим к этой табличке несколько новых столбцов:
**В приведенном примере некоторые поля представлены с сокращениями для улучшения читабельности.**
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| **Path** | **Element\_
Name** | **maxoccurs** | **Target
Table** | **Target
Field** | **Element
Depth** | **Additional
Info** |
| Deliveries\ | PeriodBegin | | MovementReports | PeriodBegin\_Date | 1 | Deliveries |
| Deliveries\ | PeriodEnd | | MovementReports | PeriodEnd\_Date | 1 | Deliveries |
| Deliveries\...\Product\ | ProductName | …\Product | Products | ProductName\_Dim | 3 | |
| Deliveries\...\Product\ | Supplier | …\Product | Products | Supplier\_Dim | 3 | |
| Deliveries\...\...\...\Detail\ | DeliveryDate | …\Detail | MovementDetails | MovementDate\_Date | 5 | |
| Deliveries\...\...\...\Detail\ | Quantity | …\Detail | MovementDetails | Quantity\_Val | 5 | |
| Deliveries\...\...\...\Detail\ | UnitPrice | …\Detail | MovementDetails | UnitPrice\_Val | 5 | |
| Returns\ | PeriodBegin | | MovementReports | PeriodBegin\_Date | 1 | Returns |
| Returns\ | PeriodEnd | | MovementReports | PeriodEnd\_Date | 1 | Returns |
| Returns\...\Product\ | ProductName | …\Product | Products | ProductName\_Dim | 3 | |
| Returns\...\Product\ | Supplier | …\Product | Products | Supplier\_Dim | 3 | |
| Returns\...\...\...\Detail\ | Quantity | …\Detail | MovementDetails | MovementDate\_Date | 5 | |
| Returns\...\...\...\Detail\ | ReturnDate | …\Detail | MovementDetails | Quantity\_Val | 5 | |
| Returns\...\...\...\Detail\ | UnitPrice | …\Detail | MovementDetails | UnitPrice\_Val | 5 | |
Вот какие поля мы добавили:
* Имя целевой таблицы **TargetTable**. Обратите внимание, что мы учитываем информацию о размножении один-ко-многим (столбец maxoccurs) для определения, в какую таблицу какие данные заливать.
* Имя поля целевой таблицы **TargetField**. Мы далее используем подход сonvention over configuration и будем присваивать суффикс **\_Dim** для полей, которые станут справочниками-измерениями (dimensions), суффикс **\_Date** для полей дат и суффикс **\_Val** для числовых полей- мер (measures). На следующих этапах процесса соответствующие утилиты по суффиксу поймут что делать с данным полем – строить и обновлять нужный справочник или преобразовывать значение в соответствующий формат.
* Эффективная глубина вложенности элементов **ElementDepth**. Нам надо будет для последующих трансформаций сохранить единый код записи целевой таблицы на базе содержимого полей **Record\_ID** и **File\_ID**. В XML глубина элементов может быть разной, но попадать они должны будут в одну целевую таблицу, поэтому мы указываем, какую часть иерархического кода **Record\_ID** нам надо сохранить, отбросив ненужный нам остаток. Благодаря фиксированной длине каждого сегмента иерархического кода, это будет достаточно “дешевая” операция выделения подстрок длины **[Количество символов на сегмент кода]**\* **ElementDepth**.
* Дополнительная информация **AdditionalInfo**. В результате нашей трансформации мы перегрузим исходные данные в разбивке по целевым таблицам в похожую структуру с новыми названиями полей, однако в некоторых местах нам надо будет сохранить важную информацию о том, из какого именно XPATH-пути мы брали исходные данные.
Эта техника открывает несколько интересных возможностей манипуляции трансформацией данных. Не углубляясь в детали, просто перечислим что мы можем сделать:
* Если у нас есть несколько исходных схем кодирования XML-данных (например, “старая” схема госзакупок по 95 ФЗ и “новая” по 44 ФЗ), мы можем на этапе описания трансформации привести их к единой структуре данных через унификацию названий полей.
* Можем, как упоминалось ранее, “схлопнуть” разные разделы в рамках одной или нескольких схем документов в единую, более компактную структуру хранения, как мы это делаем в нашем примере.
* Можно также “схлопнуть” в единообразное представление данные разной глубины. Например, если брать схемы извещений о проведении госзакупок, то в разных схемах информация о лотах закупки может лежать “по адресу” **\lot** для однолотовых закупок (единственный элемент) и **\lots\lot** для многолотовых закупок (размножение). С помощью данного подхода можно достаточно просто весь этот зоопарк замаппить в единую таблицу информации о лотах.
После того, как наша табличка со спецификацией трансформации готова, мы загружаем ее в базу данных и джойним с нашим первичным хранилищем по полям **Path** и **Element\_Name**.
Конкатенацией **File\_ID**, “обрезанного” в соответствии с **ElementDepth** значения поля **Record\_ID** и значения **AdditionalInfo** формируем композитный ключ нашей целевой таблицы.
Результат джойна выливаем для каждой целевой таблицы в отдельную “временную” таблицу (в зависимости от объема данных можно попробовать использовать результат запроса “ на лету ”), на следующем этапе с этими таблицами будут работать завершающие утилиты нашего “конвейера”.
**Немного подробнее о композитном ключе, может быть, немного повторяясь – но это важный и тонкий момент:*** До выливки мы имеем набор данных на уровне отдельных полей (элементов). Для того, чтобы соединить поля в записи результирующей таблицы, нам нужно иметь какой-то ключ, который будет однозначно идентифицировать запись целевой таблицы, в которую попадут соответствующие поля.
* Иерархический идентификатор **Record\_ID** может быть разной длины, в зависимости от “глубины залегания” отдельных элементов в схеме документа. Однако, если углубление уровня не сопровождается размножением элементов один-ко-многим, мы обрезаем наш **Record\_ID** до минимальной достаточной глубины, определенной параметром **ElementDepth**, что обеспечит нам одинаковость идентификатора для всех полей нашей целевой таблицы. В наших демо-документах такой ситуации нет, но представьте, к примеру, что наш **UnitPrice** “разветвлялся” бы на 2 значения – оптовую и розничную цены **UnitPrice\Retail** и **UnitPrice\Wholesale**.
* Поскольку в нашем базовом хранилище лежит содержимое множества файлов, в нашем ключе без значения **File\_ID** не обойтись.
* Следующие этапы преобразования данных работают только с полученными на данном шаге “трансформированными” таблицами, никакой сквозной системы настроек у нас нет. Тип поля (dimension/measure) мы передаем через суффиксы названий, но иногда нам надо передать “по цепочке” еще и информацию о том, в каком именно разделе документа мы брали информацию (помним, что мы можем трансформировать в одинаковый вид документы, закодированные разными схемами). Для передачи на следующий этап преобразования этой информации мы используем необязательный параметр нашей трансформации **AdditionalInfo**, “подцепив” его к нашему композитному ключу так, чтобы не нарушилась нужная нам идентификация целевых записей.
Посмотрим, что получилось на выходе в нашем примере:
**Результат трансформации:*****MovementReports:***
| | | |
| --- | --- | --- |
| **KEY** | **TargetField** | **Element\_Value** |
| 001;2006@Deliveries | PeriodBegin\_Date | 2017-01-01 |
| 001;2006@Deliveries | PeriodEnd\_Date | 2017-01-31 |
| 001;2007@Returns | PeriodBegin\_Date | 2017-02-01 |
| 001;2007@Returns | PeriodEnd\_Date | 2017-02-28 |
***Products:***
| | | |
| --- | --- | --- |
| **KEY** | **TargetField** | **Element\_Value** |
| 001\003\001;2006 | Supplier\_Dim | Zaanse Snoepfabriek |
| 001\003\001;2006 | ProductName\_Dim | Chocolade |
| 001\003\002;2006 | Supplier\_Dim | Mayumis |
| 001\003\002;2006 | ProductName\_Dim | Tofu |
| 001\003\001;2007 | Supplier\_Dim | Pavlova, Ltd. |
| 001\003\001;2007 | ProductName\_Dim | Pavlova |
| 001\003\002;2007 | Supplier\_Dim | Formaggi Fortini s.r.l. |
| 001\003\002;2007 | ProductName\_Dim | Mozzarella di Giovanni |
***MovementDetails:***
| | | |
| --- | --- | --- |
| **KEY** | **TargetField** | **Element\_Value** |
| 001\003\001\003\001;2006 | MovementDate\_Date | 2017-01-03 |
| 001\003\001\003\001;2006 | UnitPrice\_Val | 10.2000 |
| 001\003\001\003\001;2006 | Quantity\_Val | 70 |
| 001\003\002\003\001;2006 | MovementDate\_Date | 2017-01-09 |
| 001\003\002\003\001;2006 | UnitPrice\_Val | 18.6000 |
| 001\003\002\003\001;2006 | Quantity\_Val | 12 |
| 001\003\002\003\002;2006 | MovementDate\_Date | 2017-01-13 |
| 001\003\002\003\002;2006 | UnitPrice\_Val | 18.7000 |
| 001\003\002\003\002;2006 | Quantity\_Val | 20 |
| 001\003\001\003\001;2007 | MovementDate\_Date | 2017-02-21 |
| 001\003\001\003\001;2007 | UnitPrice\_Val | 13.9000 |
| 001\003\001\003\001;2007 | Quantity\_Val | 2 |
| 001\003\002\003\001;2007 | MovementDate\_Date | 2017-02-27 |
| 001\003\002\003\001;2007 | UnitPrice\_Val | 27.8000 |
| 001\003\002\003\001;2007 | Quantity\_Val | 4 |
Обратите внимание – полученный ключ одинаков для всех полей, которые войдут в соответствующие записи наших целевых таблиц.
#### 3. Финальная обработка.
##### 3.1. Пивотирование
Получив в результате предыдущей трансформации “заготовку” целевой таблицы с исходными данными, разбитыми на тройки **<ключ>-<имя поля>-<значение>**, мы должны перевести ее в более привычный вид таблицы со множеством полей. Алгоритм этого преобразования очевиден – сначала группировкой значений нашего композитного ключа получаем “скелет” таблицы, потом осуществляем джойны этого “скелета” с таблицей-результатом трансформации по значению композитного ключа. (“Наращиваем мясо”, так сказать.)
То есть получится N соединений “скелета” с подмножествами таблицы- результата трансформации, выделенными по именам полей, где N- количество названий полей в целевой таблице-результате трансформации.
Мы благополучно “донесли” поле **AdditionalInfo** до данной стадии, закодировав его внутри композитного ключа. Теперь надо освободить наш ключ от этой “обузы” и отрезать AdditionalInfo-часть в новое поле **AdditionalInfo\_Dim**.
Мы соединяли код файла и идентификатор записи, чтобы передать на этап пивотирования ключ одним полем. Для “финального” хранения лучше обратно разделить код файла и иерархический идентификатор на два поля, так будет проще связывать результирующие таблицы друг с другом.
В итоге получатся такие вот
**pivot-таблички:*****MovementReports:***
| | | | | |
| --- | --- | --- | --- | --- |
| **Record\_ID** | **File\_ID** | **AdditionalInfo\_Dim** | **PeriodBegin\_Date** | **PeriodEnd\_Date** |
| 001 | 2006 | Deliveries | 2017-01-01 | 2017-01-31 |
| 001 | 2007 | Returns | 2017-02-01 | 2017-02-28 |
***Products:***
| | | | |
| --- | --- | --- | --- |
| **Record\_ID** | **File\_ID** | **Supplier\_Dim** | **ProductName\_Dim** |
| 001\003\001 | 2006 | Zaanse Snoepfabriek | Chocolade |
| 001\003\002 | 2006 | Mayumis | Tofu |
| 001\003\001 | 2007 | Pavlova, Ltd. | Pavlova |
| 001\003\002 | 2007 | Formaggi Fortini s.r.l. | Mozzarella di Giovanni |
***MovementDetails:***
| | | | | |
| --- | --- | --- | --- | --- |
| **Record\_ID** | **File\_ID** | **MovementDate\_Date** | **UnitPrice\_Val** | **Quantity\_Val** |
| 001\003\001\003\001 | 2006 | 2017-01-03 | 10.2000 | 70 |
| 001\003\001\003\001 | 2007 | 2017-02-21 | 13.9000 | 2 |
| 001\003\002\003\001 | 2006 | 2017-01-09 | 18.6000 | 12 |
| 001\003\002\003\001 | 2007 | 2017-02-27 | 27.8000 | 4 |
| 001\003\002\003\002 | 2006 | 2017-01-13 | 18.7000 | 20 |
##### 3.2. Нормализация
Следующий этап условно можно назвать нормализацией, мы заменим все поля с суффиксом **\_Dim** ссылками на соответствующие справочники, поля с суффиксами **\_Date** и **\_Val** преобразуем, соответственно, в даты и числа. Можно при необходимости и другие суффиксы типов данных использовать, это не догма.
Для каждого поля **\_Dim** мы проверим наличие соответствующего справочника (если справочника нет, то создадим его) и дополним новыми значениями из поля пивотированной таблицы.
В конце процесса перельем данные в финальную структуру хранения, соединив пивотированную таблицу с проапдейченными справочниками по значениям полей.
В итоге мы получим наши целевые таблицы, в которых будет содержаться код файла, иерархический идентификатор, ссылки на значения справочников и преобразованные к нужным типам остальные поля.
#### В заключение описания процесса
Иерархический идентификатор в каждой целевой таблице дает нам возможность связать эти таблицы друг с другом (причем в любом порядке, при необходимости можно опускать промежуточные звенья). Как отмечалось выше, фиксированный размер элементов иерархического идентификатора дает нам возможность достаточно легко строить выражения для связывания наших целевых таблиц.
Конечно же, при желании можно дополнить структуру таблиц связями через значения привычных автоинкрементных ключей.
Отметим достаточную толерантность описанного подхода к ошибкам и упущениям разработчика (точнее, человека, конфигурирующего маппинг). Если в процессе подготовки трансформации вы упустили нужное поле, или если в схеме файлов произошли изменения типа добавления или переименования полей, которые не были отслежены вовремя – ничего страшного, даже если большой объем информации уже обработан без учета этой ошибки.
Вся информация у нас сохранена и доступна в нашем “первичном” табличном хранилище, поэтому заново парсить исходники не придется.
Можно прописать маппинг полей для «маленькой» трансформации данных – только для нужного нам пропущенного фрагмента. После того как мы “вытащим” недостающий кусок данных, мы сможем достаточно легко “подцепить” его к основному обработанному массиву через связку по иерархическому идентификатору.
#### Выводы
Как видим, мы с самого начала поместили всю исходную информацию вне зависимости от схем документов в единообразный вид, позволяющий быстро “вытаскивать” нужные данные в режиме ad-hoc.
В процессе дальнейшей обработки ~~ни одно животное не пострадало~~ не возникло необходимости в создании или модификации каких-либо скриптов или объектов типа ETL task, специфичных для структуры исходных XML-файлов.
Конечно, само программное окружение нашего “фреймворка” (инфраструктуру закачки и переливок данных) нужно было создать один раз, но затем интеграция данных любых структур XML сводится к редактированию таблицы маппинга исходного и целевого представлений. | https://habr.com/ru/post/325186/ | null | ru | null |
# Ключевое слово «mutable» в C++
Ключевое слово **mutable** относится к малоизвестным уголкам языка С++. В то же время оно может быть очень полезным, или даже необходимым в случае, если вы хотите строго придерживаться const-корректности вашего кода или писать лямбда-функции, способные изменять своё состояние.
Пару дней назад Eric Smolikowski написал в своём твиттере:
*«Я часто спрашиваю программистов на собеседовании насколько хорошо (по 10-бальной шкале) они знают С++. Обычно они отвечают 8 или 9. И тогда я спрашиваю что такое „mutable“. Они не знают. :)»*
Впечатления от таких вопросов и ответов у меня двоякие. С одной стороны, задавать подобные вопросы на собеседовании — дело бесполезное, это почти ничего не говорит о способностях интервьюируемого. Но, с другой стороны, ключевое слово **mutable** незаслуженно забыто многими программистами, а ведь оно может быть очень полезным в некоторых сценариях.
Const-корректность: семантическая константность против синтаксической константности
-----------------------------------------------------------------------------------
Когда мы пытаемся писать код, корректный с точки зрения использования понятия константности, то столкнёмся с тем, что семантическая неизменность не эквивалентна синтаксической неизменности. Другими словами, нам может понадобиться изменить состояние объекта (если этого требуют детали реализации), сохранив при этом видимое извне состояние объекта константным.
Изменение внутреннего состояния может требоваться по каким-то глубоко техническим причинам и это не должно быть заметно для внешних клиентов нашего класса. Но выбор у нас не большой — если мы используем ключевое слово const при объявлении метода, то компилятор не позволит нам изменить объект этого класса, даже если эти изменения никто вне класса и не заметит.
Кешированные данные
-------------------
Хорошим примером может быть кеширование данных. Давайте посмотрим на вот этот класс полигона:
```
class Polygon {
std::vector vertices;
public:
Polygon(std::vector vxs = {})
: vertices(std::move(vxs))
{}
double area() const {
return geometry::calculateArea(vertices);
}
void add(Vertex const& vertex) {
vertices.push\_back(vertex);
}
//...
};
```
Давайте предположим, что geometry::calculateArea — это очень ресурсозатратная функция, которую мы не хотим вызывать каждый раз при вызове метода area(). Мы можем рассчитывать новую площадь при изменении полигона, но в некоторых сценариях это может быть настолько же (или даже больше) ресурсозатратно. Хорошим решением в данной ситуации может быть вычисление площади только тогда, когда это необходимо, с кеширование результата и очисткой кеша в случае изменения полигона.
```
class Polygon {
std::vector vertices;
double cachedArea{0};
public:
//...
double area() const {
if (cachedArea == 0) {
cachedArea = geometry::calculateArea(vertices);
}
return cachedArea;
}
void resetCache() {
cachedArea = 0;
}
void add(Vertex const& vertex) {
resetCache();
vertices.push\_back(vertex);
}
//...
};
```
Но, эй, погодите, не так быстро! Компилятор не даст вам провернуть подобный фокус, ведь метод area() помечен константным, а мы зачем-то пытаемся в нём изменять свойство cachedArea. Убрать const из объявления метода? Но тогда нас не поймут клиенты данного класса. Ведь area() — это простой геттер, данная функция точно не должна менять ничего в классе. Так почему же в её объявлении нет const?
Мьютексы
--------
Ещё один пример это потокобезопасность с использованием мьютексов. Контейнер вершин в примере выше не потокобезопасен. Таким образом, в многопоточном приложении, где разные потоки будут совместно использовать данные одних и тех же полигонов, нам необходимо обеспечить безопасность доступа к этим данным:
```
class Polygon {
std::vector vertices;
std::mutex mutex;
public:
Polygon(std::vector vxs = {})
: vertices(std::move(vxs))
{}
double area() const {
std::scoped\_lock lock{mutex};
return geometry::calculateArea(vertices);
}
void add(Vertex const& vertex) {
std::scoped\_lock lock{mutex};
vertices.push\_back(vertex);
}
//...
};
```
В данном случае компилятор снова начнёт жаловаться на метод area(), который бодро обещает быть константным, но сам (вот ведь негодяй!) пытается выполнить операцию mutex::lock(), которая меняет состояние мьютекса. То есть — мы не можем залочить константный мьютекс.
Получается, что мы снова не можем сделать метод area() константным и будем вынуждены либо отказаться от потокобезопасности, либо вводить в заблуждение клиентов нашего класса, избавляясь от const в объявлении метода. Из-за технических деталей реализации, которые не имеют совершенно никакого отношения к видимому извне состоянию объекта, нам приходится либо отказываться от части функционала, либо вводить в заблуждение пользователей класса.
Ключевое слово «mutable» спешит на помощь
-----------------------------------------
Ключевое слово **mutable** существует в стандарте языка С++ именно для решения данного класса проблем. Его можно добавить к переменным членам класса для указания того, что данная переменная может изменяться даже в константном контексте. С использованием **mutable** решение обоих вышеуказанных примеров будет выглядеть вот так:
```
class Polygon {
std::vector vertices;
mutable double cachedArea{0};
mutable std::mutex mutex;
public:
//...
double area() const {
auto area = cachedArea;
if (area == 0) {
std::scoped\_lock lock{mutex};
area = geometry::calculateArea(vertices);
cachedArea = area;
}
return area;
}
void resetCache() {
assert(!mutex.try\_lock());
cachedArea = 0;
}
void add(Vertex const& vertex) {
std::scoped\_lock lock{mutex};
resetCache();
vertices.push\_back(vertex);
}
//...
};
```
Изменяемые лямбда-функции
-------------------------
Есть и ещё один вариант применения ключевого слова **mutable** и он связан с сохранением состояния в лямбда-функциях. Обычно оператор вызова функции замыкания является константным. Другими словами — лямбда не может модифицировать переменные, захваченные по значению:
```
int main() {
int i = 2;
auto ok = [&i](){ ++i; }; //OK, i захватывается по ссылке
auto err = [i](){ ++i; }; //Ошибка: попытка изменения внутренней копии i
auto err2 = [x{22}](){ ++x; }; //Ошибка: попытка изменения внутренней переменной x
}
```
Но ключевое слово **mutable** может быть применено ко всей лямбда-функции, что сделает все её переменные изменяемыми:
```
int main() {
int i = 2;
auto ok = [i, x{22}]() mutable { i++; x+=i; };
}
```
Следует заметить, что в отличии от mutable-переменных в объявлении класса, мутабельные лямбда-функции должны использоваться относительно редко и очень аккуратно. Сохранение состояния между вызовами лямбда-функции может быть опасным и контринтуитивным.
Выводы
------
**mutable** — это не какой-то тёмный и покрытый пылью уголок языка С++, который вам никогда не понадобится. Это инструмент, который играет свою роль в чистом коде, и играет её тем лучше, чем чаще вы используете const и чем больше пытаетесь делать свой код безопасным и надёжным. С применением **mutable** вы можете лучше объяснить компилятору, где его проверки важны и нужны, а где вы хотите их избежать. Всё это повышает общую корректность кода. | https://habr.com/ru/post/341264/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.